Why This Fork

Plate's Slate fork is an agent-first editor substrate, not an official upstream Slate release. It keeps Slate's JSON document model and operation idea, then rebuilds the runtime around explicit reads, explicit writes, typed transactions, multi-root documents, state fields, and browser proof. This page explains the bet, the runtime shape, the package split, and the current proof limits.

On This Page

• The Main Fork
• Why Not Stay Closer To Slate?
• Who It Is For
• What Stays Slate
• Runtime Shape
• Document Shape
• Extension Model
• React Runtime
• Overlay Model
• Browser Proof
• Package Ownership
• Current Boundaries
• Complete Change Map
• Read Next

The Main Fork

The first fork is the maintenance model.

Contenteditable bugs do not end. Browsers shift, selection breaks, paste paths fork, IME has edge cases, and large documents expose every hidden shortcut. A runtime that depends on occasional human cleanup will rot.

This fork is built for the opposite shape:

• agents run the boring loops;
• humans steer taste, API boundaries, and product calls;
• every serious behavior claim needs executable proof;
• every regression should become a test, harness repair, or workflow repair;
• APIs can be hard-cut when the old shape makes the system harder to verify.

That is the real fork. The code matters, but the maintenance philosophy matters more.

Why Not Stay Closer To Slate?

The first attempted design was conservative: keep upstream Slate core intact, rewrite slate-react, and push the hard work into the renderer. That would have kept the public runtime closer to Slate 0.x while trying to unlock extra roots, document state, overlays, and React performance from React alone.

That path broke down because the renderer cannot safely own the facts that make a rich-text editor correct. React can render a tree, but it cannot be the source of truth for write boundaries, selection authority, operation batching, dirty regions, stable node identity, history grouping, collaboration metadata, and DOM repair.

If slate-react tried to own those anyway, it would become a hidden second runtime beside Slate. The adapter would have to translate between mutable editor fields, React subscriptions, browser selection, history, collaboration, and test proof. That is the black box this fork avoids.

The fork keeps Slate's core model: JSON nodes, paths, points, ranges, operations, and app-owned schema. It rewrites the runtime around editor.read(...), editor.update(...), transaction groups, commits, and state fields so React can subscribe to precise state instead of guessing from broad tree changes.

The influence is narrow. Lexical is the reference for explicit read/update discipline and dirty reconciliation. ProseMirror is the reference for transaction authority and DOM-selection import/export. The document layer stays Slate-shaped, which is the point: keep the flexible JSON model, replace the runtime shape that made React and browser proof fight the core.

Who It Is For

Use this fork when you want the editor runtime maintained like infrastructure.

This is not a nicer wrapper around Slate 0.x. It is a stricter runtime for teams that prefer proof and maintainability over compatibility comfort.

What Stays Slate

The fork keeps the parts of Slate that make the model worth preserving:

• documents are nested JSON nodes;
• selections use paths, points, and ranges;
• edits produce operations;
• schema is application-owned;
• React renders the editor instead of owning the document model.

Those choices are still good. The fork changes the runtime around them.

Runtime Shape

The public authoring model has two boundaries:

const value = editor.read((state) => state.value.get());
 
editor.update((tx) => {
  tx.text.insert("Hello");
});Copy

const value = editor.read((state) => state.value.get());
 
editor.update((tx) => {
  tx.text.insert("Hello");
});Copy

Reads go through editor.read(...). Writes go through editor.update(...). Inside an update, transaction groups own text, nodes, fragments, selection, marks, roots, history, operations, and extension namespaces.

The editor still produces Slate operations. The difference is that local runtime truth is also captured as a commit so history, React, DOM repair, collaboration adapters, benchmarks, and proof tooling can observe the same edit.

Document Shape

The short value is still an array of blocks:

const initialValue = [{ type: "paragraph", children: [{ text: "Body" }] }];Copy

const initialValue = [{ type: "paragraph", children: [{ text: "Body" }] }];Copy

Use a full document value when one editor owns extra editable regions or serialized metadata:

const initialValue = {
  children: [{ type: "paragraph", children: [{ text: "Body" }] }],
  roots: {
    header: [{ type: "paragraph", children: [{ text: "Draft" }] }],
    footer: [{ type: "paragraph", children: [{ text: "Internal" }] }],
  },
  state: {
    "document.title": "Launch brief",
  },
};Copy

const initialValue = {
  children: [{ type: "paragraph", children: [{ text: "Body" }] }],
  roots: {
    header: [{ type: "paragraph", children: [{ text: "Draft" }] }],
    footer: [{ type: "paragraph", children: [{ text: "Internal" }] }],
  },
  state: {
    "document.title": "Launch brief",
  },
};Copy

children is the primary editable body. roots stores extra editable regions. state stores persistent document metadata and small shared model state.

Omit root for the primary editable. Root keys are for extra document regions.

Extension Model

Extensions add named state and transaction groups. They do not replace the operation pipeline or patch random methods onto the editor object.

import { defineEditorExtension } from "@platejs/slate";
 
const todo = defineEditorExtension({
  name: "todo",
  tx: {
    todo(tx) {
      return {
        toggle() {
          tx.nodes.set({ checked: true, type: "todo" });
        },
      };
    },
  },
});Copy

import { defineEditorExtension } from "@platejs/slate";
 
const todo = defineEditorExtension({
  name: "todo",
  tx: {
    todo(tx) {
      return {
        toggle() {
          tx.nodes.set({ checked: true, type: "todo" });
        },
      };
    },
  },
});Copy

This keeps method-style ergonomics while making ownership visible. App commands live in the runtime instead of in ad hoc editor mutation helpers.

React Runtime

React editors start with useSlateEditor, <Slate>, and <Editable>.

import { Editable, Slate, useSlateEditor } from "@platejs/slate-react";
 
const Editor = () => {
  const editor = useSlateEditor({
    initialValue: [{ type: "paragraph", children: [{ text: "" }] }],
  });
 
  return (
    <Slate editor={editor}>
      <Editable placeholder="Start typing..." />
    </Slate>
  );
};Copy

import { Editable, Slate, useSlateEditor } from "@platejs/slate-react";
 
const Editor = () => {
  const editor = useSlateEditor({
    initialValue: [{ type: "paragraph", children: [{ text: "" }] }],
  });
 
  return (
    <Slate editor={editor}>
      <Editable placeholder="Start typing..." />
    </Slate>
  );
};Copy

useSlateEditor installs the normal React, DOM, clipboard, and history path. Use createReactEditor when the editor must be created outside component ownership.

React rendering is selector-first. App chrome should subscribe to the editor facts it needs, not to the whole editor tree.

Overlay Model

The fork treats overlays as separate lanes.

A comment is not just a decoration with more props. A widget is not a text leaf. Those lanes can share projection infrastructure, but they do not share ownership semantics.

Use <Editable decorate={...} /> for simple editor-local ranges. Use the Slate React decoration-source and annotation-store hooks when ranges are shared, external, frequent, durable, or source-scoped.

Browser Proof

Model tests are not enough for editor behavior. DOM checks are not enough either.

For cursor, selection, paste, undo, hidden DOM, large documents, and collaboration-adjacent behavior, the fork expects proof across the layers that can actually fail.

That is why @platejs/browser exists. It is not the product editing API. It is the proof harness used to keep the editor honest.

Package Ownership

The packages are split by responsibility.

Apps should import public package exports. /internal subpaths are for sibling packages in this repo.

Current Boundaries

This fork is intentionally narrow about what it claims.

The line is simple: if the proof lane does not own it, the docs should not pretend it is done.

Complete Change Map

This table is intentionally exhaustive. It gives humans and agents one place to route deeper reading.

Read Next

• Installing Slate
• Migration
• React Editor Setup
• Roots
• Document State
• Slate Browser
• Slate Layout

The fork's promise is narrow: Slate's model, rebuilt for agent-run maintenance and proof-heavy editor behavior.