Slate v2 Editable Input Rule Ownership Ralplan

Date: 2026-05-13

Status: done

Owner: slate-ralplan

Completion: active goal state

Current Verdict

EditableInputRule is the wrong public Slate v2 abstraction.

The old example-level editor.deleteBackward = (...args) => { ... } was ugly, but it was at least a model command override. The current EditableInputRule shape moved checklist behavior into the editor construction path, which was the right instinct, but it overshot into a React/beforeinput rule abstraction that belongs in Plate.

Accepted target:

• Slate core owns transform middleware as the public Slate-close extension DX, with low-level command middleware as the semantic runtime substrate.
• Slate React owns DOM beforeinput routing and app escape hatches such as onDOMBeforeInput.
• Plate owns semantic input-rule families, triggers, priorities, and feature rule factories.
• Checklist Backspace should use transforms.deleteBackward(...) over the core delete command substrate, not an EditableInputRule.

Intent Boundary

Live Source Evidence

Decision Brief

Principles:

• Model behavior belongs to model commands, not DOM event strings.
• Slate remains low-level and unopinionated.
• Plate owns semantic plugin rule families.
• Examples should teach the durable substrate, not a temporary convenience.
• Browser-specific escape hatches stay available without becoming the primary plugin API.

Top drivers:

• Checklist Backspace must work through every deletion path, not only native beforeinput deleteContentBackward.
• The current public type forces users to think in inputType: string and InputEvent even when they are authoring model behavior.
• Slate v2 already has a command registry; failing to use it is architectural waste.

Options:

Public API Target

Cut from slate-react public exports:

EditableInputRule
EditableInputRuleContext
EditableInputRuleResult
editableInputRules(...)
EDITABLE_INPUT_RULE_CAPABILITY

Keep Editable DOM escape hatches:

<Editable onDOMBeforeInput={...} onKeyDown={...} />

Expose Slate-close transform middleware as the normal public extension DX. It should feel like the old withX(editor) override shape, but structured, typed, ordered, and cleanup-aware:

const withChecklists = <T extends ReactEditor<CustomValue>>(editor: T): T => {
  editor.extend({
    name: "checklists",
    transforms: {
      deleteBackward({ editor, next, unit }) {
        if (applyChecklistBackspaceStart(editor)) return;

        next();
        // or next({ unit: 'word' })
      },
    },
  });

  return editor;
};

Text shortcuts use the same public shape:

const withMarkdownShortcuts = <T extends ReactEditor<CustomValue>>(
  editor: T,
): T => {
  editor.extend({
    name: "markdown-shortcuts",
    transforms: {
      insertText({ editor, next, options, text }) {
        if (applyMarkdownTextShortcut(editor, text)) return;

        next();
        // or next({ options, text: normalizedText })
      },
    },
  });

  return editor;
};

applyChecklistBackspaceStart should read current selection from editor.read(...); it should not accept a DOM-derived selection parameter.

Transform middleware next contract:

• next() forwards the current transform arguments unchanged.
• next(overrides) forwards the current transform arguments shallow-merged with explicit overrides.
• Handling is expressed by not calling next(), matching the old Slate override mental model.
• A middleware handler must not call next() more than once.

Keep low-level command middleware and typed built-in command definitions available underneath for advanced users, tests, and runtime implementation. Transform middleware should compile to that substrate:

transforms.deleteBackward -> EditorCommands.delete({ direction: 'backward' })
transforms.insertText -> EditorCommands.insertText({ text, options })

Internal Runtime Target

• Keep the runtime beforeinput pipeline and DOM repair queue.
• Remove extension capability collection for editable input rules.
• Route native/model input through transform middleware that dispatches to core commands where possible:
  • delete paths -> EditorCommands.delete
  • text insertion -> EditorCommands.insertText
  • break insertion -> EditorCommands.insertBreak
  • fragment/data insertion -> command route where already represented
• Keep direct Editor.registerCommand(...) as the low-level substrate, not the default example API for ordinary Slate users.
• Keep browser-only formatting events in onDOMBeforeInput examples when they are truly browser formatBold / formatItalic intents.

Plate Ownership Target

Plate keeps:

• semantic inputRules on plugins;
• enabled, resolve, apply, priority, plugin key, triggers;
• markdown rule families such as HeadingRules.markdown(), TaskListRules.markdown(...), LinkRules.autolink(...);
• delete/reset/lift behavior families where Plate has product node semantics.

Slate provides the substrate Plate can build on:

• command middleware;
• state/tx extension namespaces;
• DOM/input runtime correctness;
• operation and commit determinism.

Ecosystem Strategy Synthesis

Issue Ledger Accounting

ClawSweeper pass: skipped with reason already covered by completed input-runtime/checklist ledger surfaces; this pass changes API ownership narrative and adds no fixed issue claim.

Related rows read from durable ledgers:

No new Fixes #... line.

PR reference sync: updated in docs/slate-v2/references/pr-description.md#62-react-editable-input-rule-ownership so Section 6.2 no longer presents editableInputRules(...) as the accepted target. Ralph must still refresh the proof rows after implementation.

Regression Proof Matrix

Applicable Implementation-Skill Review Matrix

High-Risk Deliberate Mode

Trigger: public API cut plus example behavior migration.

Blast radius:

• slate-react public exports and docs;
• examples using inputRules;
• PR narrative;
• Plate migration story;
• browser input proof.

Pre-mortem:

1. Transform middleware misses native beforeinput deletion because one runtime path bypasses Editor.deleteBackward.
2. Markdown/inline examples lose Android or composition behavior during migration.
3. Cutting public exports breaks consumers who copied the temporary API from v2 docs.

Proof plan:

• package tests for transform middleware over the delete and insert-text command substrate;
• editable-behavior contract proving no stale editableInputRules capability;
• surface contract proving exports are removed and built-in command definitions are exported;
• browser smoke for /examples/check-lists, /examples/markdown-shortcuts, and /examples/inlines;
• site typecheck and slate-react typecheck;
• PR reference update after implementation.

Rollback answer:

• If transform middleware cannot cover all native paths, revise by routing those paths through commands first. Do not restore EditableInputRule as public API.

Maintainer Objection Ledger

Scorecard

Weighted total: 0.93.

Status: done.

Implementation Phases For Ralph

1. Add transform middleware extension DX in slate, with context-object handlers such as deleteBackward({ editor, next }) and insertText({ editor, next, text }).
2. Compile transform middleware to the existing command middleware substrate so native beforeinput, keyboard fallback, and programmatic editor transforms share one semantic path.
3. Export typed built-in command definitions from slate, at least delete and insert-text, for low-level command middleware users and tests.
4. Migrate checklist behavior from EditableInputRule capability to transforms.deleteBackward(...).
5. Migrate markdown shortcut and inline URL typed insertion away from EditableInputRule to transforms.insertText(...), or explicitly keep a DOM handler only where browser intent is the behavior.
6. Remove EditableInputRule*, editableInputRules, and EDITABLE_INPUT_RULE_CAPABILITY from public slate-react.
7. Remove runtime-root extension capability merging for editable input rules; keep DOM beforeinput routing and repair behavior.
8. Refresh docs and PR section 6.2 after implementation with final proof rows.
9. Add/adjust tests before implementation:
   • transform middleware handles checklist Backspace through core delete;
   • transform middleware handles typed shortcuts through insert text;
   • command middleware remains the internal substrate and low-level escape hatch;
   • public surface no longer exports editable input rule helpers;
   • examples typecheck without manual EditableInputRule / Selection annotations.

Fast Driver Gates

From cwd=/Users/zbeyens/git/slate-v2:

bun --filter slate test
bun --filter slate-react test:vitest -- editable-behavior
bun --filter slate-react test:vitest -- surface-contract
bun --filter slate-react typecheck
cd site && bun x tsc --project tsconfig.json --noEmit
PLAYWRIGHT_BASE_URL=http://localhost:3100 PLAYWRIGHT_RETRIES=0 PLAYWRIGHT_WORKERS=1 bun x playwright test playwright/integration/examples/check-lists.test.ts playwright/integration/examples/markdown-shortcuts.test.ts playwright/integration/examples/inlines.test.ts --project=chromium
bun lint:fix

From cwd=/Users/zbeyens/git/plate-2:

bun run completion-check

Plan Deltas From Review

• Revised the prior accepted EditableInputRule stance.
• Reclassified checklist Backspace as transform middleware public DX over command middleware runtime substrate, not input rule.
• Kept Slate React DOM beforeinput escape hatches for browser-specific intents.
• Moved rich semantic input-rule family ownership to Plate.
• Added requirement to expose transform middleware for normal examples and typed built-in command definitions for the low-level substrate.
• Added browser and command proof rows for checklist, markdown shortcuts, and inline URL examples.

Final Completion Gates

• Plan score reaches 0.93.
• No new fixed issue claim is made.
• PR reference records the transform-middleware public DX over command-substrate ownership target; final proof-row refresh is assigned to Ralph because live implementation still exposes the old public API.
• Implementation phases and driver gates are explicit.
• Slate Ralplan did not edit .tmp/slate-v2 implementation.

2026-05-15 Revalidation Pass

Status: done

Trigger:

• User re-asked after example cleanup whether the current checklist editableInputRules(({ inputType }) => ...) shape is acceptable DX or whether Slate v2 should change the architecture before this becomes public teaching.

Harsh verdict:

• The current code is better than legacy monkeypatching but still the wrong final DX.
• editableInputRules makes Slate developers author model behavior through browser inputType strings. That is cleaner syntax around a leaky abstraction.
• Checklist Backspace is semantic delete behavior. It belongs on transform middleware over the delete-command substrate, not on a React beforeinput rule registry.
• Keeping this public would be exactly the kind of "temporary example helper" that becomes API gravity and makes v2 feel clever but awkward.

Live source re-read:

Decision after revalidation:

• Keep the prior target unchanged: remove EditableInputRule*, editableInputRules(...), and EDITABLE_INPUT_RULE_CAPABILITY from public Slate React.
• Add transform middleware as the normal public extension-author DX.
• Add or expose typed built-in command definitions for delete and insert-text so low-level substrate users do not register handlers against naked strings.
• Migrate check-lists to transforms.deleteBackward(...).
• Migrate markdown and inline URL text shortcuts to transforms.insertText(...), or leave only truly browser-specific cases on onDOMBeforeInput.
• Keep onCommand / onDOMBeforeInput on <Editable> as escape hatches; do not make them the primary extension story.

Pass-state ledger:

Score after revalidation:

Weighted total: 0.93.

Completion decision:

• Slate Ralplan remains done for planning/review.
• Implementation is not done.
• Next executable owner: ralph implementation of the seven phases above.
• No Slate v2 implementation files were edited by this revalidation pass.

Strict Slate Ralplan Pass Schedule Audit - 2026-05-15

Status: done

Purpose: make the closure contract explicit. The prior plan had the material evidence, but the runtime completion file compressed it too much. This audit maps every required Slate Ralplan pass to the evidence that closes it.

Final user-review handoff outline:

• Public API: cut public EditableInputRule* and editableInputRules(...).
• Runtime: keep Slate React DOM input runtime; route semantic model behavior through transform middleware backed by core command middleware.
• DX: teach transform middleware examples; export typed built-in command definitions only for the low-level substrate.
• Examples: checklist Backspace, markdown shortcuts, and inline URL shortcuts become Ralph implementation targets.
• Issue accounting: no new fixed/improved issue claims until implementation proof exists.
• Gates: implementation must run the .tmp/slate-v2 command/browser gates listed in Fast Driver Gates.

Full 12-Pass Slate Ralplan Rerun - 2026-05-15

Status: done

Trigger:

• User explicitly asked to run the actual 12 Slate Ralplan passes, not merely fix the Stop-hook state.

Goal:

• Prove this editable input-rule ownership plan is ready for user review, with all required passes recorded before status: done.

Fresh current-state read:

Fresh verification:

Key-command/renderers ownership answer:

• editableKeyCommands fits slate-react, not core slate, and not Plate-only. It is React/keyboard/native-event extension glue for examples and app escape hatches. Do not use it for semantic model behavior that already has a core command route.
• editableRenderers fits slate-react. Rendering is React-owned; core slate must stay renderer-agnostic. Plate can build richer product/component registries on top, but raw Slate React should keep the low-level renderer extension registry.
• editableInputRules is the odd one out. It looks like Plate product rule DX, but it lives in Slate React and speaks DOM inputType; cut it.
• Direct Editor.registerCommand(...) is also too ceremonial as the main example DX. Keep it underneath; expose transform middleware as the normal Slate-close authoring surface.

Issue/accounting rerun:

Issue sync accounting decision:

• docs/slate-v2/references/pr-description.md:582-640 records transform middleware as the accepted Section 6.2 public DX and says implementation is not complete.
• docs/slate-v2/references/pr-description.md:642-675 already records the native command boundary, including editableKeyCommands.
• docs/slate-v2/references/pr-description.md:818-832 already records editableRenderers ownership.
• docs/slate-v2/ledgers/issue-coverage-matrix.md unchanged: no new Fixes #... or Improves #... claim is legal before implementation proof.
• docs/slate-v2/ledgers/fork-issue-dossier.md unchanged: existing input-runtime/checklist/renderers/key-command surfaces cover the related issue context; this rerun adds no new issue classification.

Fresh 12-pass ledger:

Fresh score after full rerun:

Weighted total: 0.93.

Completion gates:

• Score is 0.93, no dimension below 0.85.
• Every scheduled pass row is complete.
• No issue row is Fixes or Improves; all touched issues remain related until implementation proof exists.
• pr-description updated: Section 6.2 now records transform middleware as the public Slate-close DX over command middleware substrate.
• No .tmp/slate-v2 implementation file was edited.
• Remaining work is implementation by ralph, not Slate Ralplan review.

Final user-review handoff outline for this rerun:

• Public API: cut EditableInputRule*, editableInputRules(...), and EDITABLE_INPUT_RULE_CAPABILITY from Slate React.
• Runtime: keep Slate React DOM input routing and repair queue; remove public semantic input-rule collection.
• Model behavior: move checklist Backspace to transform middleware public DX over the core delete-command substrate.
• Typed commands: expose built-in delete and insert-text command definitions for low-level substrate users and tests, not as the normal example shape.
• Text shortcuts: migrate markdown and inline URL insertion to transforms.insertText(...), or keep only truly browser-specific paths on onDOMBeforeInput.
• Plate boundary: keep rich semantic input-rule families in Plate.
• editableKeyCommands: keep in Slate React for extension-owned keyboard glue; do not use it for model commands that belong in core command middleware.
• editableRenderers: keep in Slate React for extension-owned renderer registration; core Slate stays renderer-agnostic and Plate can layer product registries above it.
• Issue accounting: #3384, #4528, #3408, #4532, #3568, and #3586 stay related/not fixed.
• Proof gates: Ralph must run the .tmp/slate-v2 command/browser gates before implementation can claim release-ready.

Transform Middleware DX Revision - 2026-05-15

Status: done

User correction:

• Direct Editor.registerCommand(..., EditorCommands.delete, ...) is a good substrate but not the absolute-best Slate authoring DX.

Accepted final shape:

const withChecklists = <T extends ReactEditor<CustomValue>>(editor: T): T => {
  editor.extend({
    name: "checklists",
    transforms: {
      deleteBackward({ editor, next }) {
        if (applyChecklistBackspaceStart(editor)) return;

        next();
      },
    },
  });

  return editor;
};

Text shortcuts use the same shape:

editor.extend({
  name: "markdown-shortcuts",
  transforms: {
    insertText({ editor, next, options, text }) {
      if (applyMarkdownTextShortcut(editor, text)) return;

      next();
      // or next({ options, text: normalizedText })
    },
  },
});

Architecture decision:

• Public DX: transform middleware.
• next() DX: preserve current args by default; allow explicit partial overrides such as next({ text: normalizedText }).
• Runtime substrate: command middleware.
• Low-level escape hatch: direct Editor.registerCommand(...) with typed built-in command definitions.
• Rejected DX: public examples centered on direct Editor.registerCommand(...); too far from Slate's withX(editor) override tradition.
• Still rejected: editableInputRules(...); it is DOM inputType / Plate-rule vocabulary in the wrong package.

Plan delta:

• Updated Public API Target, Internal Runtime Target, implementation phases, scorecard wording, objection ledger, full rerun handoff, and PR reference sync status to reflect transform middleware public DX.
• Finalized the transform middleware next() contract: no-arg next() delegates unchanged, explicit overrides are shallow-merged, and handled behavior means not calling next().

Ralph Execution Start - 2026-05-15

Status: done

Goal:

• Land the editable input-rule ownership plan in .tmp/slate-v2: transform middleware public DX with next() forwarding/overrides, command middleware substrate, public editableInputRules cut, example migration, reference sync, issue accounting, and passing focused/closeout gates.

Continuation prompt:

• active goal state

Current pass:

• tdd-pass
• Owner: .tmp/slate-v2/packages/slate extension runtime
• Scope: add transform middleware public DX for deleteBackward and insertText, including next() default forwarding and partial overrides.
• Trigger: public API behavior requires red-green-refactor proof.

First runnable slice:

• Add a public behavior test in .tmp/slate-v2/packages/slate/test/extension-methods-contract.ts proving extension transform middleware can delegate unchanged and override insertText args through next({ text }).
• Confirm RED before implementation.
• Implement the smallest runtime seam needed for that test, then keep top-level completion pending for the remaining plan phases.

Ralph Execution Done Handoff - 2026-05-15

Status: done

Implemented:

• Added extension.transforms.deleteBackward and extension.transforms.insertText to .tmp/slate-v2/packages/slate, backed by the existing command middleware substrate.
• Added next() forwarding and next(overrides) shallow override behavior, with a double-next() guard.
• Cut public EditableInputRule*, editableInputRules, the input-rule capability helper, and the Editable inputRules prop from Slate React.
• Migrated checklist Backspace, markdown typed shortcuts, and inline URL typed insertion to transform middleware in the public examples.
• Kept onDOMBeforeInput, onCommand, editableKeyCommands, and editableRenderers in Slate React; those are browser/render/key glue, not Plate semantic input-rule families.
• Added changesets for slate and slate-react in .tmp/slate-v2/.changeset.
• Updated this plan, the Ralph continuation prompt, completion state, and docs/slate-v2/references/pr-description.md.

Pass accounting:

Verification:

• bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "extension transform middleware": pass.
• bun test ./packages/slate/test/extension-methods-contract.ts: pass.
• bun test ./packages/slate/test/transaction-contract.ts --test-name-pattern "routes delete commands|stores command handlers|registers typed internal command definitions": pass.
• bun --filter slate-react test:vitest -- editable-behavior surface-contract keyboard-input-strategy-contract: pass.
• bun --filter slate typecheck: pass.
• bun --filter slate-react typecheck: pass.
• bun x tsc --project site/tsconfig.json --noEmit: pass.
• bun test ./packages/slate/test: pass.
• bun lint:fix: pass.
• PLAYWRIGHT_RETRIES=0 PLAYWRIGHT_WORKERS=1 bun x playwright test playwright/integration/examples/check-lists.test.ts playwright/integration/examples/markdown-shortcuts.test.ts playwright/integration/examples/inlines.test.ts --project=chromium: pass.
• bun check: pass.
• rg -n "EditableInputRule|editableInputRules|EDITABLE_INPUT_RULE|inputRules" .tmp/slate-v2/packages/slate-react/src .tmp/slate-v2/packages/slate-react/test .tmp/slate-v2/site/examples/ts .tmp/slate-v2/packages/slate/src .tmp/slate-v2/packages/slate/test: no matches.
• pnpm lint:fix: pass in /Users/zbeyens/git/plate-2.
• node tooling/scripts/completion-check.mjs: pass in /Users/zbeyens/git/plate-2.

Issue accounting:

• No new fixed or improved issue claim.
• The related issue rows from the Slate Ralplan pass stay related only: #3384, #4528, #3408, #4532, #3568, and #3586.
• ClawSweeper was not rerun because implementation did not change claim status, issue surface, or PR issue narrative.

Done Handoff

The full plan is landed. Public Slate v2 example DX is now transform middleware:

const withChecklists = <T extends ReactEditor<CustomValue>>(editor: T): T => {
  editor.extend({
    name: "checklists",
    transforms: {
      deleteBackward({ editor, next }) {
        if (applyChecklistBackspaceStart(editor)) return;

        next();
      },
    },
  });

  return editor;
};

editableInputRules is gone from public Slate React, examples no longer teach DOM inputType rules for model behavior, and the completion hook is cleared by same-turn evidence.

Full Transform Middleware Coverage Hard Cut - 2026-05-16

Status: done

Current Verdict

The current EditorTransformMiddlewareMap is too narrow. It was a good first slice for checklist and typed-text examples, but it is not the final Slate v2 extension authoring surface.

Hard cut target: transform middleware must cover every public mutating editor transform except engine controls. No compatibility aliases, no restored editableInputRules, no public commands extension slot, and no root export of raw command registry helpers.

Intent Boundary

Live Source Evidence

Decision Brief

Principles:

• Public extension DX should feel like structured Slate withX(editor) overrides.
• Command middleware remains substrate, not the normal example API.
• Full coverage means no silent transform family gaps.
• Engine-control APIs do not become plugin policy hooks.
• No backward-compat shim is allowed for wrong public API.

Options:

Public API Target

EditorTransformMiddlewareMap should be derived from an explicit key set, not hand-written as two properties.

Accepted transform middleware keys:

Explicit exclusions:

Target type shape:

type EditorPublicTransformMiddlewareKey = Exclude<
  keyof EditorTransformApi,
  "bookmark" | "normalize" | "setNormalizing" | "withoutNormalizing"
>;

type EditorTransformMiddlewareMap<
  TEditor extends BaseEditor<any> = Editor,
  V extends Value = Value,
> = {
  [K in EditorPublicTransformMiddlewareKey]?: (
    context: EditorTransformMiddlewareContext<
      TEditor,
      EditorTransformMiddlewareArgs<V>[K]
    >,
  ) => EditorCommandResult | void;
};

EditorTransformMiddlewareArgs must use named object args, not tuple soup:

type EditorTransformMiddlewareArgs<V extends Value = Value> = {
  addMark: { key: string; value: unknown };
  collapse: { options?: SelectionCollapseOptions };
  delete: { options?: TextDeleteOptions };
  deleteBackward: { unit: TextUnit };
  deleteForward: { unit: TextUnit };
  deleteFragment: { options?: EditorFragmentDeletionOptions };
  deselect: {};
  insertBreak: {};
  insertFragment: {
    fragment: DescendantIn<V>[];
    options?: TextInsertFragmentOptions;
  };
  insertNode: {
    node: ElementOrTextIn<V>;
    options?: NodeInsertNodesOptions<ElementOrTextIn<V>>;
  };
  insertNodes: {
    nodes: ElementOrTextIn<V> | ElementOrTextIn<V>[];
    options?: NodeInsertNodesOptions<ElementOrTextIn<V>>;
  };
  insertSoftBreak: {};
  insertText: { options?: TextInsertTextOptions; text: string };
  liftNodes: {
    options?: EditorTransformApi<V>["liftNodes"] extends (
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  mergeNodes: {
    options?: EditorTransformApi<V>["mergeNodes"] extends (
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  move: { options?: SelectionMoveOptions };
  moveNodes: {
    options: EditorTransformApi<V>["moveNodes"] extends (
      options: infer O,
    ) => void
      ? O
      : never;
  };
  removeMark: { key: string };
  removeNodes: {
    options?: EditorTransformApi<V>["removeNodes"] extends (
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  select: { target: Location };
  setNodes: {
    props: Partial<NodeProps<NodeIn<V>>>;
    options?: EditorTransformApi<V>["setNodes"] extends (
      props: any,
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  setPoint: { options?: SelectionSetPointOptions; props: Partial<Point> };
  setSelection: { props: Partial<Range> };
  splitNodes: {
    options?: EditorTransformApi<V>["splitNodes"] extends (
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  toggleMark: { key: string; value?: unknown };
  unsetNodes: {
    options?: EditorTransformApi<V>["unsetNodes"] extends (
      props: any,
      options?: infer O,
    ) => void
      ? O
      : never;
    props: string | string[];
  };
  unwrapNodes: {
    options?: EditorTransformApi<V>["unwrapNodes"] extends (
      options?: infer O,
    ) => void
      ? O
      : never;
  };
  wrapNodes: {
    element: ElementIn<V>;
    options?: EditorTransformApi<V>["wrapNodes"] extends (
      element: any,
      options?: infer O,
    ) => void
      ? O
      : never;
  };
};

Implementation can simplify the helper types, but it must keep the named context DX:

editor.extend({
  name: "tables",
  transforms: {
    insertFragment({ editor, fragment, next, options }) {
      if (insertTableFragment(editor, fragment, options)) return;

      next();
    },
    wrapNodes({ element, next, options }) {
      next({ element, options: { ...options, split: true } });
    },
  },
});

Internal Runtime Target

• Replace bespoke deleteBackward / insertText registration branches with a table-driven transform middleware bridge.
• Every accepted transform key gets a command/default-handler route before it is exposed.
• Extract private applyX helpers where needed so one public transform does not accidentally fire a second public transform middleware when defaulting through an implementation alias.
• Preserve current operation output for no-middleware defaults.
• Preserve next() semantics:
  • next() forwards current args unchanged.
  • next(overrides) shallow-merges explicit overrides.
  • not calling next() means handled.
  • calling next() twice throws.
• Preserve command ordering: extension install order plus command priority must stay deterministic.

Hard Cuts

• Cut any idea of restoring editableInputRules.
• Cut old methods extension slots.
• Cut public extension commands slots.
• Cut root exports for defineCommand, registerCommand, executeCommand, or EditorCommands.
• Cut manual two-key middleware maps. The accepted key set must drift-fail when EditorTransformApi grows.

Issue Ledger Accounting

ClawSweeper pass: reused existing dossier and matrix rows. No broad live GitHub search. No fixed or improved claim changes in this planning pass.

Regression Proof Matrix

Applicable Review Matrix

Ecosystem Strategy Synthesis

Slate Maintainer Objection Ledger

Pass Ledger

Scorecard

Weighted total: 0.94.

Implementation Phases For Ralph

1. Type coverage RED:
   • Add a public type/source contract proving current map misses accepted transform keys.
   • Expected RED: keys beyond deleteBackward / insertText missing.
2. Runtime bridge refactor:
   • Add EditorTransformMiddlewareArgs.
   • Add EditorPublicTransformMiddlewareKey.
   • Replace bespoke branches in core/editor-extension.ts with keyed registration.
3. Command/default coverage:
   • Add command routes or private applyX helpers for every accepted key.
   • Preserve no-middleware operation output.
4. Family tests:
   • Marks, text/delete, break/fragment, nodes, selection.
   • Include next(), next(overrides), handled-without-next, double-next.
5. Example/docs sync:
   • Keep examples on transform middleware where model-owned.
   • Do not add editableInputRules or extension commands docs.
6. Verification:
   • Run all gates in the regression matrix.
   • Promote issue claims only after exact proof.

Fast Driver Gates

• cwd .tmp/slate-v2: bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "transform middleware"
• cwd .tmp/slate-v2: bun test ./packages/slate/test/transaction-contract.ts --test-name-pattern "routes delete commands|stores command handlers|registers typed internal command definitions"
• cwd .tmp/slate-v2: package tests covering the new transform middleware family matrix.
• cwd .tmp/slate-v2: bun --filter slate typecheck
• cwd .tmp/slate-v2: bun --filter slate-react test:vitest -- editable-behavior surface-contract keyboard-input-strategy-contract
• cwd .tmp/slate-v2: bun x tsc --project site/tsconfig.json --noEmit
• cwd .tmp/slate-v2: relevant Playwright example rows for checklist, markdown-shortcuts, inlines, richtext, paste-html/images if affected.
• cwd .tmp/slate-v2: bun check
• cwd plate-2: pnpm lint:fix
• cwd plate-2: node tooling/scripts/completion-check.mjs

Full Coverage Done Handoff

• Public API: EditorTransformMiddlewareMap two-key shape -> type-driven full mutating transform coverage; status revise; before .tmp/slate-v2/packages/slate/src/interfaces/editor.ts:641-656.
• Exclusions: bookmark, normalize, setNormalizing, withoutNormalizing; status cut from middleware; proof .tmp/slate-v2/packages/slate/src/interfaces/editor.ts:508-618.
• Command substrate: keep internal command middleware; status keep; proof .tmp/slate-v2/packages/slate/src/core/command-registry.ts:69-120.
• Root command exports: keep absent; status cut; proof .tmp/slate-v2/packages/slate/test/public-surface-contract.ts:381-398.
• Legacy extension methods and public commands: keep rejected; status cut; proof .tmp/slate-v2/packages/slate/test/extension-methods-contract.ts:15-71.
• Runtime bridge: bespoke two-key registration -> table-driven registration; status revise; before .tmp/slate-v2/packages/slate/src/core/editor-extension.ts:297-370.
• Drift guard: manual map -> key equality contract against accepted transform set; status add.
• Mark middleware: add addMark, removeMark, toggleMark; status add.
• Text/delete middleware: add/keep delete, deleteBackward, deleteForward, deleteFragment, insertText; status add.
• Break/fragment middleware: add insertBreak, insertSoftBreak, insertFragment; status add.
• Node middleware: add insertNode, insertNodes, liftNodes, mergeNodes, moveNodes, removeNodes, setNodes, splitNodes, unsetNodes, unwrapNodes, wrapNodes; status add.
• Selection middleware: add collapse, deselect, move, select, setPoint, setSelection; status add.
• Plate boundary: keep rich semantic input rules in Plate; status keep.
• editableInputRules: keep cut; status cut.
• Issue #3557: stay Related until insert-node/fragment proof lands; candidate Improves after Ralph proof; status gate.
• Issue #5050: stay Related; transform middleware is adjacent but not exact browser/input repro proof; status gate.
• Issue #4613: existing Improves unchanged; clipboard data intake stays slate-dom capability, not transform middleware; status keep.
• Issue #3568: stay Related; mark middleware is adjacent but native beforeinput crash closure needs focused runtime proof; status gate.
• Verification: require type coverage, runtime invocation, no-middleware parity, focused Slate tests, Slate React tests, site typecheck, browser examples, and bun check; status gate.

Final decision: the API must not stay as the two-key map. Full hard-cut coverage is the right Slate v2 shape, with explicit engine-control exclusions and no backward-compat shims.

Ralph Full Coverage Execution Start - 2026-05-16

Status: pending

Goal:

• Implement full hard-cut transform middleware coverage in .tmp/slate-v2, with every public mutating transform except engine controls available through extension.transforms, no backward-compat shims, preserved no-middleware behavior, synced reference docs, and passing focused plus broad gates.

Continuation prompt:

• active goal state

Current pass:

• tdd-pass
• Owner: .tmp/slate-v2/packages/slate extension runtime and type surface.
• Scope: add failing type/runtime coverage for transform middleware keys beyond deleteBackward and insertText, then implement the full keyed bridge.

First runnable slice:

• Add a failing coverage test proving a non-current transform key, starting with insertFragment or insertNode, is missing from transform middleware.
• Add a type/key coverage contract for the accepted key set and engine-control exclusions.
• Confirm RED before implementation.

Ralph Full Coverage Execution Progress - 2026-05-16

Status: pending

TDD pass:

• Public behavior: extension.transforms covers every public mutating transform except bookmark, normalize, setNormalizing, and withoutNormalizing.
• RED runtime command: cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "transform middleware".
• RED runtime failure: addMark defaulted without calling transform middleware; spy saw [] instead of ["addMark"].
• RED type command: cwd .tmp/slate-v2, bun --filter slate typecheck.
• RED type failure: root slate export lacked EditorPublicTransformMiddlewareKey.
• GREEN implementation: added EditorPublicTransformMiddlewareKey, EditorTransformMiddlewareArgs, full EditorTransformMiddlewareMap, keyed internal transform middleware registration, transform default-depth guarding, and full key drift tests.
• Node override proof: insertNode middleware can next({ node, options }) with overridden args.
• Double-next proof: transform middleware throws on a second next() call.
• No issue claim promoted. #3557 stays related because the package proof covers the extension pressure, not the exact upstream repro closure.

Verification so far:

• cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "transform middleware": pass, 5 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts: pass, 12 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/public-surface-contract.ts ./packages/slate/test/generic-extension-namespace-contract.ts: pass, 361 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/transforms-contract.ts: pass, 15 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/transaction-contract.ts --test-name-pattern "routes delete commands|stores command handlers|registers typed internal command definitions": pass, 3 tests.
• cwd .tmp/slate-v2, bun --filter slate typecheck: pass.
• cwd .tmp/slate-v2, bun lint:fix: pass; Biome fixed formatting in touched files.

Changed Slate v2 files:

• .tmp/slate-v2/packages/slate/src/interfaces/editor.ts
• .tmp/slate-v2/packages/slate/src/core/editor-extension.ts
• .tmp/slate-v2/packages/slate/src/core/transform-middleware.ts
• .tmp/slate-v2/packages/slate/src/create-editor.ts
• .tmp/slate-v2/packages/slate/src/index.ts
• .tmp/slate-v2/packages/slate/test/extension-methods-contract.ts
• .tmp/slate-v2/packages/slate/test/generic-extension-namespace-contract.ts
• .tmp/slate-v2/.changeset/full-transform-middleware.md

Reference sync:

• Updated docs/slate-v2/references/pr-description.md Section 6.2 from the stale two-key implementation wording to the full transform middleware shape.

Next pass:

• Run focused gates after lint rewrite, then diff-review-pass and verification-sweep-pass.

Diff review:

• Status: complete.
• Finding fixed: initial implementation widened setNodes middleware props to plain Node to satisfy an internal default call. That weakened custom-value inference. Public args now use NodeIn<V> again; only the internal default call casts through erased runtime types.
• P0/P1 findings after fix: none.
• P2 findings after fix: none.
• Accepted risk: transform middleware commits with installed transform handlers use keyed transform:<key> command context; no-middleware command metadata is preserved by the no-handler fast path and existing command tests.

Done Handoff

Status: done

Implemented in .tmp/slate-v2:

• Full extension.transforms coverage for every public mutating EditorTransformApi key except bookmark, normalize, setNormalizing, and withoutNormalizing.
• Public types: EditorPublicTransformMiddlewareKey, EditorTransformMiddlewareArgs, and full EditorTransformMiddlewareMap.
• Runtime bridge: keyed transform middleware registration through internal command storage plus transform-registry default forwarding.
• Default guard: internal transform aliases do not accidentally double-fire public transform middleware while defaulting.
• insertNode static API now forwards options to the transform registry.
• Changeset: .tmp/slate-v2/.changeset/full-transform-middleware.md.

Proof:

• cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "transform middleware": pass, 5 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts: pass, 12 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/public-surface-contract.ts ./packages/slate/test/generic-extension-namespace-contract.ts: pass, 361 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/transforms-contract.ts: pass, 15 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/transaction-contract.ts --test-name-pattern "routes delete commands|stores command handlers|registers typed internal command definitions": pass, 3 tests.
• cwd .tmp/slate-v2, bun --filter slate typecheck: pass.
• cwd .tmp/slate-v2, bun lint:fix: pass.
• cwd .tmp/slate-v2, bun check: pass.
• cwd plate-2, pnpm lint:fix: pass.
• cwd plate-2, node tooling/scripts/completion-check.mjs: pass.
• Knowledge capture: added docs/solutions/developer-experience/2026-05-16-slate-transform-middleware-defaults-need-alias-depth-guard.md.

Reference and issue state:

• Updated docs/slate-v2/references/pr-description.md Section 6.2 to the full transform middleware shape.
• No fixed/improved issue claim promoted. #3557 remains related: the package proof covers insert-node/fragment extension pressure, not the exact upstream repro closure.
• Browser/example verification skipped because this Ralph execution did not change browser, React, or example files.

Full Editor Method Override Coverage Ralplan - 2026-05-16

Status: done

Current Verdict

The user is right. Full transform middleware is necessary, but it is not full legacy override coverage. Old Slate made core methods overrideable across transforms, pure queries, refs, schema predicates, normalization, operation application, and change notification. A transform-only answer covers writes and misses a large part of the old withX(editor) power.

Hard target: every legacy-overridable editor method must have one of three states:

• first-class v2 extension surface;
• intentionally replaced by a safer v2 surface;
• explicitly cut as engine/snapshot/lifecycle control with proof.

Anything else is a regression hiding behind nicer type names.

Live Source Evidence

Intent Boundary

Decision Brief

Principles:

• Do not overload transforms. Writes and reads need different contracts.
• Preserve Slate-close override ergonomics through extension slots, not method monkeypatching.
• Schema predicates are declarative policy, not ad hoc read hooks.
• Snapshot, ref, and lifecycle controls are engine-owned unless there is a real behavior-extension use case.
• No silent gaps. If a method is not overrideable, say why.

Options:

Method-Family Coverage Map

Public Query API Target

Add extension.queries as a grouped middleware map that mirrors the public read view instead of inventing flat names like nodesEntries.

Target authoring shape:

editor.extend({
  name: "tables",
  queries: {
    nodes: {
      entries({ next, options }) {
        return next({
          options: { ...options, voids: true },
        });
      },
    },
    text: {
      string({ at, next, options }) {
        if (isTableSelection(editor, at)) return "";

        return next({ at, options });
      },
    },
  },
});

Target type shape:

type EditorQueryNext<TArgs extends object, TResult> = (
  overrides?: Partial<TArgs>,
) => TResult;

type EditorQueryMiddlewareContext<
  TEditor extends BaseEditor<any>,
  TArgs extends object,
  TResult,
> = TArgs & {
  editor: TEditor;
  next: EditorQueryNext<TArgs, TResult>;
};

type EditorPublicQueryGroups<V extends Value = Value> = Pick<
  EditorCoreStateView<V>,
  "fragment" | "marks" | "nodes" | "points" | "ranges" | "text"
>;

type EditorQueryMiddlewareMap<TEditor extends BaseEditor<any> = Editor> = {
  [G in keyof EditorPublicQueryGroups<ValueOf<TEditor>>]?: {
    [K in keyof EditorPublicQueryGroups<ValueOf<TEditor>>[G]]?: (
      context: EditorQueryMiddlewareContext<
        TEditor,
        EditorQueryMiddlewareArgs<ValueOf<TEditor>>[G][K],
        EditorQueryMiddlewareResult<ValueOf<TEditor>>[G][K]
      >,
    ) => EditorQueryMiddlewareResult<ValueOf<TEditor>>[G][K];
  };
};

Implementation can simplify the helper types, but the public shape must stay grouped and must infer callback parameter types in examples.

Accepted query groups:

Explicit query exclusions:

Query middleware contract:

• next() forwards current args unchanged.
• next(overrides) shallow-merges explicit overrides.
• Not calling next() means the middleware owns the returned value.
• Calling next() twice throws, including generator-returning queries.
• Query handlers must not open editor.update; tests must prove no operations are produced by query-only calls.
• No-handler path must call the existing direct runtime/helper functions with no extra allocation.
• Handler lookup must be keyed by group and method, never a global every-read scan.

Schema Predicate Replacement

Do not add queries.schema.isVoid or queries.nodes.isInline. That would be two competing policy systems.

Target shape:

editor.extend({
  name: "images",
  elements: [
    { type: "image", void: "block" },
    {
      match: (element) => element.type === "mention",
      type: "mention",
      void: "markable-inline",
    },
  ],
});

Coverage:

| Legacy method | V2 replacement | | ------------------- | ------------------------------------------------- | -------- | ----------------- | --------------------- | | isInline | elements: [{ inline: true, type }] | | isVoid | elements: [{ type, void: 'block' | 'inline' | 'editable-island' | 'markable-inline' }] | | markableVoid | void: 'markable-inline' or markableVoid: true | | isSelectable | selectable: false for non-selectable elements | | isElementReadOnly | readOnly: true or match based element specs | | isBlock | Derived from schema inline policy |

Normalizer / Apply / Change Coverage

The transform plan excluded normalize for the right reason, but the no-regress story is incomplete unless normalizers are typed and tested.

Target:

• normalizers becomes a first-class typed ordered map, not Record<string, unknown>.
• A normalizer handler receives { editor, entry, operation, explicit, force, fallbackElement, next }.
• next() delegates to the next normalizer and eventually the built-in normalizer.
• shouldNormalize remains engine policy unless a concrete extension use case proves a safe typed hook.
• operationMiddlewares is the v2 replacement for old apply overrides.
• commitListeners / subscribeSource replace old onChange.

Regression Proof Matrix

Issue Ledger Accounting

No fixed or improved issue claim changes in this planning pass.

Applicable Review Matrix

Slate Maintainer Objection Ledger

Pass Ledger

Scorecard

Weighted total: 0.94.

Ralph Full Method Coverage Execution Plan

1. Query coverage RED:
   • Add type/source contract for EditorQueryMiddlewareMap.
   • Add failing runtime tests proving nodes.entries, text.string, and fragment.get cannot be intercepted yet.
2. Query registry implementation:
   • Add grouped query middleware registration under extension.queries.
   • Route EditorStaticApi, InternalEditorQueryRuntime, and public state read methods through one keyed query dispatcher.
   • Fix direct helper bypasses in state.nodes.children/get/entries/find/some/toArray.
3. Schema proof:
   • Add or strengthen tests proving old isVoid, isInline, markableVoid, isSelectable, and isElementReadOnly cases map to elements / schema.define.
4. Normalizer hardening:
   • Replace normalizers?: Record<string, unknown> with typed normalizer middleware and tests for ordering, cleanup, next(), and fallback.
5. Operation/change proof:
   • Ensure operationMiddlewares and commitListeners cover old apply and onChange use cases.
6. Cut proof:
   • Add public surface tests proving no extension.refs, extension.snapshot, or lifecycle middleware slots.
7. Verification:
   • Run focused query/schema/normalizer/operation contracts, bun --filter slate typecheck, and bun check from .tmp/slate-v2.
   • Run slate-react and browser rows only if React or example files change.

Fast Driver Gates

• cwd .tmp/slate-v2: bun test ./packages/slate/test/query-extension-contract.ts
• cwd .tmp/slate-v2: bun test ./packages/slate/test/schema-contract.ts
• cwd .tmp/slate-v2: bun test ./packages/slate/test/extension-methods-contract.ts --test-name-pattern "query middleware|normalizer|operation middleware|commit listener"
• cwd .tmp/slate-v2: bun test ./packages/slate/test/query-contract.ts
• cwd .tmp/slate-v2: bun test ./packages/slate/test/snapshot-contract.ts
• cwd .tmp/slate-v2: bun --filter slate typecheck
• cwd .tmp/slate-v2: bun check
• cwd plate-2: pnpm lint:fix
• cwd plate-2: COMPLETION_CHECK_ID=019e1fc0-dba0-7de1-9236-b484a144cda6 node tooling/scripts/completion-check.mjs

Done Handoff - Full Editor Method Override Coverage

Status: done

Decision:

• The transform-only plan is not enough. It covers writes, not all old-overridable editor behavior.
• Add grouped extension.queries for pure read methods.
• Keep extension.transforms for writes.
• Keep elements / schema.define as the replacement for old schema predicate overrides.
• Harden normalizers into a typed ordered middleware surface.
• Keep operationMiddlewares and commitListeners as the replacement for old apply and onChange.
• Cut refs, snapshots, runtime ids, lifecycle controls, and engine controls from extension override middleware.

Before/after shape:

// Old Slate mental model
const withTables = (editor: Editor) => {
  const { nodes, string } = editor;

  editor.nodes = (options) => nodes({ ...options, voids: true });
  editor.string = (at, options) =>
    isTableSelection(editor, at) ? "" : string(at, options);

  return editor;
};

// Slate v2 target
const withTables = <T extends Editor>(editor: T): T => {
  editor.extend({
    name: "tables",
    queries: {
      nodes: {
        entries({ next, options }) {
          return next({ options: { ...options, voids: true } });
        },
      },
      text: {
        string({ at, next, options }) {
          if (isTableSelection(editor, at)) return "";

          return next({ at, options });
        },
      },
    },
  });

  return editor;
};

Ralph next owner:

• Implement extension.queries in .tmp/slate-v2/packages/slate.
• Start with RED tests for query key coverage and state-read bypasses.
• Do not touch React/browser examples unless the implementation changes those paths.
• Do not promote issue claims until exact proof lands.

Verification for this Slate Ralplan pass:

• Planning/source read only; no Slate v2 implementation edited from slate-ralplan.
• Plate-2 artifact gates are listed in the completion file.

Ralph Full Method Coverage Execution Progress - 2026-05-16

Status: pending

Current pass:

• verification-sweep-pass
• Owner: complete.
• Scope: full no-regression editor-method extension coverage.

TDD pass:

• Public behavior: extensions can register grouped pure-read middleware under extension.queries, and the first read paths invoke it without method monkeypatching.
• RED command: cwd .tmp/slate-v2, bun test ./packages/slate/test/query-extension-contract.ts.
• RED failure: state.text.string([0]) returned one instead of one!, proving extension.queries.text.string was not on the read path.
• GREEN implementation: added public query middleware types, a query middleware registry, grouped query registration during extension install, and a keyed query dispatcher.
• First routed keys: fragment.get, nodes.entries, and text.string.
• Static/read parity proof: Editor.string(editor, [1]) and editor.read((state) => state.text.string([0])) both hit queries.text.string.
• Implementation extension: routed the full accepted query set: fragment.get, marks.get, accepted nodes.*, accepted points.*, accepted ranges.*, and text.string.
• Static/read parity: Editor.* pure reads and editor.read grouped reads hit the same query keys for accepted methods, including nodes.path, nodes.elementReadOnly, nodes.shouldMergeNodesRemovePrevNode, and points.positions.
• Generator safety: query default-depth covers lazy generator iteration, so nodes.entries, nodes.levels, and points.positions do not double-fire nested middleware after next().
• Purity: query middleware rejects editor.update and query-only calls emit no operations.
• Normalizers: replaced normalizers?: Record<string, unknown> with a typed ordered normalizer middleware map with next(overrides), fallback delegation, cleanup, and double-next proof.
• Operation/change proof: existing operationMiddlewares and commitListeners remain the v2 replacement for old apply and onChange; the commit-listener ordering test now matches runtime truth (commitListeners before public subscribers).
• Cut proof: public-surface tests keep refs, raw snapshots, runtime ids, lifecycle controls, legacy methods, and public extension commands out of extension override middleware.
• No issue claim promoted.
• Reference docs: Section 6.2 updated to record full accepted v2 capability parity, not legacy method-slot monkeypatch compatibility.

Changed Slate v2 files:

• .tmp/slate-v2/packages/slate/src/interfaces/editor.ts
• .tmp/slate-v2/packages/slate/src/index.ts
• .tmp/slate-v2/packages/slate/src/core/extension-registry.ts
• .tmp/slate-v2/packages/slate/src/core/editor-extension.ts
• .tmp/slate-v2/packages/slate/src/core/query-middleware.ts
• .tmp/slate-v2/packages/slate/src/core/normalize-node.ts
• .tmp/slate-v2/packages/slate/src/core/public-state.ts
• .tmp/slate-v2/packages/slate/src/create-editor.ts
• .tmp/slate-v2/packages/slate/test/query-extension-contract.ts
• .tmp/slate-v2/packages/slate/test/normalization-contract.ts
• .tmp/slate-v2/packages/slate/test/apply-onchange-hard-cut-contract.ts
• docs/slate-v2/references/pr-description.md
• active goal state
• active goal state

Verification:

• cwd .tmp/slate-v2, bun test ./packages/slate/test/query-extension-contract.ts: pass, 5 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/normalization-contract.ts: pass, 11 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/query-contract.ts: pass, 80 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/snapshot-contract.ts: pass, 201 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/extension-methods-contract.ts: pass, 12 tests.
• cwd .tmp/slate-v2, bun --filter slate typecheck: pass.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/schema-contract.ts: pass, 9 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/transaction-contract.ts --test-name-pattern "operation middleware|commit listeners|normalizer|extension registry": pass, 4 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/apply-onchange-hard-cut-contract.ts: pass, 4 tests.
• cwd .tmp/slate-v2, bun test ./packages/slate/test/public-field-hard-cut-contract.ts ./packages/slate/test/public-surface-contract.ts: pass, 364 tests.
• cwd .tmp/slate-v2, bun lint:fix: pass after formatting; Biome checked 1622 files.
• cwd .tmp/slate-v2, bun check: pass; package typechecks, site/root typechecks, 1008 Bun tests passed with 95 skipped, and Slate React Vitest passed 267 tests across 26 files.

Done Handoff - Full Editor Method Override Coverage Execution

Status: done

Decision:

• Keep the Slate v2 architecture hard cut: no legacy method monkeypatching, no public extension commands, no restored methods.
• Use first-class extension slots for capability parity: extension.transforms for writes, grouped extension.queries for pure reads, typed normalizers for normalizeNode, operationMiddlewares for old apply, and commitListeners / subscribe for old onChange.
• Keep schema predicates declarative through elements / schema.define.
• Keep refs, raw snapshots, runtime ids, lifecycle controls, and engine controls out of override middleware.

Implemented:

• Grouped query middleware registry, dispatcher, public types, and extension registration.
• Query routing for accepted state and static pure read methods, including fragment.get, marks.get, accepted nodes.*, accepted points.*, accepted ranges.*, and text.string.
• Static/read parity for Editor.string, Editor.path, Editor.positions, Editor.elementReadOnly, and Editor.shouldMergeNodesRemovePrevNode.
• Generator-safe default delegation and double-next protection.
• Query purity guard blocking editor.update inside query middleware.
• Typed ordered normalizer middleware with fallback override and cleanup proof.
• PR reference sync with no issue claim promotion.

Verification:

• .tmp/slate-v2: focused query, normalization, schema, snapshot, operation/change, public-surface, typecheck, lint, and bun check all pass.
• plate-2: planning/reference artifacts updated; run pnpm lint:fix and the scoped completion check after the completion file is set to done.