Slate v2 synced content roots

Objective: Close the Slate v2 Synced Blocks / document-flow content-root architecture plan for user review. The plan must define how a root-editor node renders an editable same-runtime child or shared root, how a Notion-style Synced Blocks example is added, how focus/selection/history stay one-runtime, and what proof gates are required before implementation can claim the UX behaves like ordinary sibling blocks.

Goal plan: docs/plans/2026-05-26-slate-v2-synced-content-roots.md

Template: docs/plans/templates/slate-plan.md

Primary template: docs/plans/templates/slate-plan.md

Applied packs:

• slate-plan

Completion threshold:

• Slate Plan closure is legal only when score >= 0.92, no dimension is below 0.85, every pass row is complete or intentionally skipped with evidence, issue/reference sync rows are closed, final handoff is emitted, and node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md passes.
• Planning closure does not implement .tmp/slate-v2. Execution requires a later explicit accepted-plan invocation.

Verification surface:

• Planning artifact: this file and any issue/reference/research rows under the Slate Plan allowed edit scope.
• Live source grounding: .tmp/slate-v2 reads for roots data, contentRoot, root view registration, content-root navigation, current editable-voids example, examples route registration, and Playwright coverage.
• Future implementation gates: focused package tests for slate and slate-react, route typecheck, a new /examples/synced-blocks Playwright file, the existing editable-voids route rows, and a repeated/shared-root stress row.

Constraints:

• Planning mode only. Do not patch .tmp/slate-v2 implementation, examples, tests, or package exports before explicit user acceptance and a later execution invocation.
• Keep default voids legacy-like and atomic. Do not make every void navigable or root-backed.
• Keep raw Slate unopinionated. Notion-like chrome can live in the example; Slate owns the substrate, not workspace permissions or product sync UI.
• Prefer the best long-term architecture over a local example hack.

Boundaries:

• Allowed planning edit scope: docs/plans/**, docs/research/**, docs/slate-issues/**, docs/slate-v2/ledgers/**, and docs/slate-v2/references/**.
• Live source read workspace: .tmp/slate-v2.
• Target execution files, not edited in planning mode: .tmp/slate-v2/site/examples/ts/synced-blocks.tsx, .tmp/slate-v2/site/pages/examples/[example].tsx, .tmp/slate-v2/site/constants/examples.ts, .tmp/slate-v2/site/examples/ts/custom-types.d.ts, .tmp/slate-v2/packages/slate-react/src/components/editable-text-blocks.tsx, .tmp/slate-v2/packages/slate-react/src/hooks/use-slate-runtime.tsx, .tmp/slate-v2/packages/slate-react/src/editable/content-root-navigation.ts, and .tmp/slate-v2/playwright/integration/examples/synced-blocks.test.ts.

Blocked condition:

• Block only if current source, required ledgers, or a user-owned boundary become unavailable and no source-grounding, ledger, research, or plan-hardening move remains runnable.

Slate Plan lane state:

• slate_plan_lane_status: complete
• current_pass: closure-score-and-final-gates
• current_pass_status: complete
• next_pass: none
• next_action: none - plan is ready for user review; execution requires explicit user acceptance and a later Slate Plan execution invocation
• final_handoff_status: emitted

Current verdict:

• verdict: revise the current content-root primitive into a first-class document-flow slot API, then add a new Synced Blocks example that proves shared-root projections rather than independent nested editors.
• confidence: 0.92 final.
• keep / cut / revise call: keep one runtime editor and keyed roots; keep contentRoot: { slot: string }; make props.slots.contentRoot('body', options) the canonical React DX; keep <ContentRoot /> out of the canonical example unless later pressure proves component sugar is worth the extra API; add active projection/view identity before claiming multiple mounts of the same root are production-correct; cut one-editor-per-block and mirrored-root sync as the canonical substrate.
• reason: live Slate v2 already stores document roots in one value and has same-runtime root views, content-root metadata, root lifecycle helpers, and browser rows for editable-void child roots. The remaining hard part is DX and ambiguity when the same root is mounted in more than one place: current getMountedViewEditor(root) returns a single arbitrary root view from a set, which is not enough for Notion-style repeated synced blocks.

Completion rule:

• Do not call update_goal(status: complete) while any required checklist item remains unchecked. If an item does not apply, check it and add N/A: <reason>.
• Do not call update_goal(status: complete) until every Slate Plan completion gate below is satisfied and the checker command passes.
• Do not create hook state for this goal. This file plus the active goal are the durable state.

Start Gates:

Work Checklist:

• Objective includes lane outcome, full pass schedule, one-pass-per- activation policy, completion threshold, verification surface, constraints, boundaries, and blocked condition.
• One-pass-per-activation policy respected: this activation completed only the closure score and final gates pass; earlier passes completed current-state read, related issue discovery, full issue-ledger scan, intent/boundary decision brief, ecosystem refresh, pressure passes, maintainer objections, high-risk deliberate mode, ecosystem maintainer pressure, revision, and issue/reference sync accounting.
• Live source grounding recorded for every current implementation claim in this pass.
• Issue ledger / ClawSweeper pass applied or skipped with concrete evidence: related discovery completed in pass 2; full ledger, cluster, candidate, package-impact, benchmark, and requirements scan completed in pass 3 with no new fixed/improved claims.
• Research and ecosystem synthesis complete for every external system used as evidence.
• Intent/boundary record and decision brief complete.
• Scorecard recorded with evidence; total score >= 0.92 and no dimension below 0.85 before closure.
• Applicable implementation-skill review matrix applied or skipped with concrete reason.
• Slate maintainer objection ledger complete for every breaking/paradigm change.
• Verification workspace gate recorded for every Slate v2 source, runtime, browser, package, public API, or issue-fix claim.
• TDD used for behavior/proof changes with a sane test surface, or marked N/A with reason: planning mode changed no behavior; the execution plan names the first failing public behavior rows.
• Browser proof captured for browser-surface claims, or marked N/A with reason: planning mode makes no browser-behavior claim; it defines the required /examples/synced-blocks proof gates for execution.

Completion Gates:

Phase / pass table:

Scorecard:

Weighted score after pass 11: 0.92.

Reviewer-ready summary:

• Build Synced Blocks as content-root block projections, not editable voids and not nested independent editors.
• The root editor stores owner blocks in the main root; each owner block points childRoots.body at a keyed content root. Multiple owners may point at the same root key.
• React DX is props.slots.contentRoot('body', options). The slot internally wires root lookup, root chrome, nested Editable, DOM coverage, placeholder, and active projection registration.
• Active projection identity is runtime-local view state. Root key answers what content is being edited; projection identity answers which mounted copy gets DOM focus.
• Duplicate and unsync are example-local commands that prove root identity: duplicate creates another owner pointing at the same root; unsync clones the body root and updates only that owner.
• Default voids stay atomic. Only content-root elements get document-flow navigation.
• Current slate-yjs support is not claimed. The future adapter needs a root-keyed shared type map plus root-qualified selection/history/cursors.

Source-backed architecture north star:

• target shape: a root editor contains a normal app-defined block node that projects an editor-owned content root. Synced copies can point at the same root key, so edits are shared by data identity, not by mirroring.
• source evidence: current InitialValue accepts roots: Record<RootKey, V> at .tmp/slate-v2/packages/slate/src/interfaces/editor.ts:94; current element specs can declare contentRoot: { slot: string } at .tmp/slate-v2/packages/slate/src/interfaces/editor.ts:523; current child roots are stored on element.childRoots[slot] by convention in .tmp/slate-v2/packages/slate-react/src/hooks/use-slate-child-root.ts:37.
• rejected drift: do not create one editor per block; do not model Synced Blocks as copied mirror roots by default; do not redefine all voids as navigable; do not force users to hand-wire every root mount in examples.
• migration posture: raw Slate exposes the root projection primitive and a small React slot; Plate can wrap this into richer synced-block UI later.

Current-state source facts:

Public API target:

Vocabulary boundary:

Canonical slot call-site:

const SyncedBlock = (props: RenderElementProps<SyncedBlockElement>) => (
  <section {...props.attributes} data-slate-synced-block>
    <SyncedBlockToolbar contentEditable={false} element={props.element} />
    {props.slots.contentRoot('body', {
      ariaLabel: 'Synced block content',
      className: syncedBlockBodyCss,
      placeholder: 'Empty synced block',
    })}
  </section>
)

Why this wins:

• It keeps the renderer as the single owner of product chrome.
• It gives Slate React enough context to consume or cover the owner node's placeholder children internally.
• It avoids forcing users to import a component and hope element context is available.
• It lets the slot wire useSlateContentRoot, root chrome, nested Editable, placeholder, DOM coverage, and active projection registration behind one public call.
• It keeps useSlateContentRoot for advanced users without teaching that hook stack as the default.

Internal runtime target:

Hook / component / render DX target:

Plate migration-backbone target:

slate-yjs migration-backbone target:

Intent / boundary record:

• intent: make same-runtime embedded documents feel like ordinary document blocks, and demonstrate this with a Notion-style Synced Blocks example.
• outcome: a root-editor node can render an editable content root internally; multiple nodes can project the same root; focus, selection, undo/redo, and browser navigation behave like a simple editor where the projected root sits in document flow.
• in-scope: raw Slate content-root substrate, render DX, route/example shape, active projection identity, root lifecycle, focus/selection/history routing, and browser proof.
• raw Slate owns: keyed roots, content-root schema vocabulary, root lifecycle transactions, root-qualified selection/history metadata, React projection mounting, active projection identity, and browser-visible editing behavior.
• raw Slate does not own: cross-workspace permissions, server sync, access requests, source-page ownership, Notion product menus, or current slate-yjs adapter compatibility.
• example owns: Notion-like border/top chrome, duplicate/copy affordance, unsync affordance, two synced copies, and explanatory visual labels.
• Plate owns later: synced-block menus, comments, permissions, persistence, workspace copy flows, and richer collaboration display policy.
• non-goals: cross-workspace permissions, server sync, Notion product parity, full slate-yjs implementation, and changing ordinary void semantics.
• decision boundaries: this plan may choose API shape, example route shape, runtime identity requirements, proof gates, and example-local copy/unsync behavior without asking again.
• unresolved user-decision points: none for this pass. Remote cursor projection policy stays a future Plate/slate-yjs adapter choice, not a blocker for raw Slate planning.

Decision brief:

• principles: one runtime editor; keyed roots as content identity; owner node path as projection order; projection identity is runtime-local; explicit content-root bridge only; example DX must teach the public API, not internal plumbing.
• top drivers: same-root duplicate projection ambiguity; developer-facing example simplicity; preservation of default void behavior; collaboration readiness; browser proof after real user-reported failures.
• viable options:
  • Option A: same root, many projections, active projection identity, rendered through props.slots.contentRoot(...). Best long-term substrate and best call-site DX.
  • Option B: mirrored roots with sync commands. Easier demo; wrong substrate because undo, collab, selection, and conflict behavior split.
  • Option C: independent nested editors per block. Easy local mount; fails the shared history/selection/collab goal.
  • Option D: make default voids traversable. Too broad and regresses legacy-like void behavior.
  • Option E: canonical <ContentRoot /> component. Tempting, but weaker than the slot because the slot already has renderer-local access to owner children, attributes, and DOM coverage ownership.
• chosen option: Option A.
• rejected alternatives: B, C, D, and E are rejected for canonical Slate. B and C can exist as app experiments. E can be reconsidered only as sugar after the slot API proves repetitive.
• consequences: execution must add active projection identity, a content-root slot API, a route example, and route-specific browser tests before claiming done.
• follow-ups: ecosystem synthesis, pressure passes, objection ledger, and final proof matrix.

Decision rows:

Issue accounting:

Issue-ledger sync status:

• ClawSweeper related-issue pass: complete for pass 2, ledger/cache-first. Full issue-ledger pass: complete for pass 3, ledger/cache-first. No broad live GitHub discovery was run.
• generated live gitcrawl rows read: #6034, #6016, #5524, #5212, #2072, #5874, #5537, and #5117.
• durable issue sources read: docs/slate-v2/ledgers/issue-coverage-matrix.md, docs/slate-v2/ledgers/fork-issue-dossier.md, docs/slate-v2/references/pr-description.md, docs/slate-issues/gitcrawl-v2-sync-ledger.md, docs/slate-issues/open-issues-ledger.md, and docs/slate-issues/gitcrawl-live-open-ledger.md.
• pass 3 additions read: docs/slate-issues/issue-clusters.md:59, docs/slate-issues/package-impact-matrix.md:64, docs/slate-issues/requirements-from-issues.md:72, docs/slate-issues/benchmark-candidate-map.md:458, and relevant rows in docs/slate-issues/test-candidate-map/**.
• manual v2 sync ledger update: not written in pass 3 because all reviewed issues keep existing statuses and claim text.
• fork issue dossier update: not written in pass 3 because the existing content-root, multi-root, #5874, #6016, #5537, and #5117 sections already cover the claim stance, and the new rows are guardrails rather than fixed/improved claims.
• issue coverage matrix update: not written in pass 3 because no fixed/improved claim or status changes.
• PR description sync: closed by the issue-sync accounting pass; pass 3 added no new PR claim, and pass 11 recorded the current non-claim stance.

Full issue-ledger pass coverage:

Ecosystem strategy synthesis:

Ecosystem pressure conclusions:

• ProseMirror and Tiptap both say the same thing in different layers: an editable child surface should be a named content slot inside visible chrome, not a second editor app wired by users.
• React ProseMirror is the warning label. Portal handoffs and stale render phases are exactly why the public Synced Blocks example should not teach manual nested <Editable root> plumbing.
• Lexical's nested composer is not a green light for one editor per block. It creates a nested editor that must configure its own plugins/nodes; that is useful for isolated embeds, but wrong for shared selection/history.
• slate-yjs forces root-qualified migration metadata. A repeated root view is local projection state; collaboration data must name the document root and range, not the mounted copy as persisted truth.
• Plate should get a clean substrate and then wrap it. Raw Slate should expose the slot/root primitive and browser behavior, not Notion workspace features.
• The final ecosystem pass did not change the chosen architecture. It made the render/effect lifecycle boundaries stricter and kept current slate-yjs support as a hard non-claim.
• The only acceptable "nested editable" answer for Synced Blocks is another Editable view over the same runtime root. A nested editor/composer per block is useful for isolated embeds, but wrong for shared content, shared history, and simple-editor-like navigation.

Ecosystem maintainer pass:

Performance / DX / migration / regression / simplicity pressure results:

Performance review lane:

Legacy regression proof matrix:

Browser stress / parity strategy:

Verification workspace gate:

Applicable implementation-skill review matrix:

High-risk deliberate-mode pre-mortem:

High-risk deliberate-mode conclusions:

• Active projection identity is the hard runtime requirement. Without it, Synced Blocks can render, but undo/redo and focus restoration are wrong by design when the same root has multiple mounted views.
• Root lifecycle must stay explicit. A root is content identity; an owner node is projection/order. Deleting an owner must not silently delete shared content.
• Root-qualified selection and operation-root middleware are not optional implementation details. Prior wrong-root bugs crashed before examples could repair them, so package-level tests must cover them.
• Browser proof must test human paths: visual text/chrome clicks, native selection ownership, model selection, model text, and follow-up typing. Focus alone is a liar here.
• Performance proof must avoid benchmark helper traps. If a row reads full snapshots after every small edit, it is measuring snapshots, not interaction cost.
• slate-yjs compatibility remains a non-claim until a root-keyed adapter exists. Persisted collaboration data names roots and ranges, not projection ids.

Slate maintainer objection ledger:

Hard cuts and rejected alternatives:

Plan deltas from review:

• Pass 1 created the plan and narrowed the target from generic editable voids to Synced Blocks as repeated content-root projections.
• Pass 1 added the active projection/view identity gap as the central runtime risk.
• Pass 1 chose route-specific browser proof for /examples/synced-blocks instead of relying on existing editable-voids proof.
• Pass 2 kept the no-new-fixed/no-new-improved issue stance. It reused the existing content-root / vertical-navigation accounting and added shared-identity guardrails: Synced Blocks may share root keys inside one runtime, but must not support shared Slate node objects across owner nodes or independent editors.
• Pass 3 completed the full issue-ledger scan. It added no fixed/improved claims, but widened proof coverage to mobile/IME, placeholder isolation, clipboard/drop/move, delete/range-delete, performance budgets, collaboration/history, accessibility pressure, and package ownership.
• Pass 4 chose the public DX and sharpened boundaries: canonical props.slots.contentRoot(...), no canonical <ContentRoot />, runtime-local active projection identity, content-root element vocabulary, and example-local duplicate/unsync actions.
• Pass 5 refreshed the ecosystem evidence. ProseMirror, Tiptap, and React ProseMirror support the slot/content-root direction; Lexical and slate-yjs sharpen the rejection of nested independent editors and the need for root-qualified migration metadata. No implementation code changed.
• Pass 6 applied the performance, DX, migration, regression, and simplicity pressure passes. It kept the same architecture, but added concrete budgets: one mounted projection as the repeated unit, 20/100 projection cohorts, selector fanout limits, active-projection history/focus proof, route-specific browser rows, source DX audit, memory/DOM tags, and TDD order. No implementation code changed.
• Pass 7 completed the Slate maintainer objection ledger. It did not change the architecture; it made the acceptance conditions sharper: slot API is accepted as React DX over a core schema concept, same-root duplicate projections are accepted only with runtime-local active projection identity, default voids stay atomic, Notion chrome stays example-local, owner/root lifetime policy becomes a high-risk follow-up, slate-yjs remains a non-claim, and perf/browser claims stay gated. No implementation code changed.
• Pass 8 completed high-risk deliberate mode. It preserved the chosen architecture but hardened the execution gates: active projection identity is a hard runtime requirement; owner/root lifetime is explicit; rootless selection and operation-root middleware need package tests; browser proof must assert focus, native selection, Slate selection, model text, and follow-up typing; perf rows must avoid snapshot-helper traps; slate-yjs remains a non-claim. No implementation code changed.
• Pass 9 completed the ecosystem maintainer pass. It preserved the chosen architecture again, then added final external-owner constraints: Slate React lifecycle owns root view setup, render stays pure, effects do not create document roots, current slate-yjs remains a non-claim, Tiptap-style wrapper clarity is copied without command-chain ceremony, and Lexical nested editors stay rejected as the shared Synced Blocks substrate. No implementation code changed.
• Pass 10 completed the revision pass. It did not change the architecture. It promoted the plan to review-ready shape by filling the final handoff outline, marking TDD/browser proof as planning-only N/A, raising the score to 0.92 from cited evidence, and narrowing the remaining work to issue/reference sync accounting plus final closure gates. No implementation code changed.
• Pass 11 completed issue/reference sync accounting. It added the Synced Blocks planning-sync section to the manual gitcrawl sync ledger, issue coverage matrix, fork issue dossier, and PR description reference. The sync records zero new fixed or improved claims and keeps the reviewed issues related, unchanged, or non-claim until execution proof exists. No implementation code changed.
• Pass 12 completed closure score and final gates. It set the lane to complete, emitted the final user-review handoff, kept execution explicitly gated on a later accepted-plan invocation, and recorded final checker evidence. No implementation code changed.

Open questions and decision-changing evidence:

Implementation phases with owners:

Fast driver gates:

Final user-review handoff outline:

• accepted plan items: first-class content-root block model, canonical props.slots.contentRoot('body', options) DX, one-runtime shared roots, runtime-local active projection identity, Notion-style Synced Blocks example, route-local duplicate/unsync, and explicit proof gates.
• before / after API shape: current best demo uses useSlateContentRoot plus manual <Editable root>; target demo renders product chrome and calls one content-root slot.
• hard cuts: no one-editor-per-block substrate, no mirrored-root canonical sync, no default void traversal change, no raw Slate product command DSL, no current slate-yjs support claim, and no canonical <ContentRoot /> component yet.
• issue claims and non-claims: no new fixed/improved issue claim from planning; #5212, #2072, #5524, #5874 / #4309, #6016, #5537 / #5117, and related delete/clipboard/mobile/perf/collab clusters stay related or non-claim until execution proof exists.
• proof gates: focused Slate/Slate React package rows, source DX audit, /examples/synced-blocks Playwright rows for shared edit, active-copy undo/redo, ArrowUp/Down, click outside, placeholder isolation, clipboard/move, delete/range delete, selector fanout, memory/DOM pressure, and editable-voids regression.
• accepted-plan execution handoff: implement phases in order: content-root slot API, active projection identity, Synced Blocks route, navigation/focus proof, then regression and sync accounting.

Final completion gates:

Findings:

• The answer to "does it render another Editable root per node internally?" is yes in React terms, but no in editor-state terms: it should mount another Editable view over the same runtime root, not create another editor.
• The current lower-level API already does this manually; Synced Blocks should make that internal through a content-root slot.
• Same-root multiple projections are the real missing architecture piece.
• The canonical authoring API should be props.slots.contentRoot(...), not <ContentRoot />, because the slot is renderer-local and can own the hidden mechanics without another import.
• Issue-ledger pass found no exact upstream issue that Synced Blocks should claim as fixed. The nearest direct risk is identity confusion: #5874 / #4309 and #6016 make clear that sharing node objects or editor values is not the same as sharing a root key inside one runtime.
• The broader risk set is runtime behavior: placeholder isolation, mobile/IME, clipboard/drop, delete/range-delete, collaboration/history, and perf budgets all need proof before this becomes implementation-ready.

Decisions and tradeoffs:

• One runtime editor wins. One editor per block stays rejected.
• Synced Blocks should be a normal content-root block renderer, not a default void behavior change.
• A shared body root is the canonical sync model. Mirrored roots are not the long-term substrate.
• Active projection identity is runtime-local view state, not serialized document data.
• Duplicate/copy and unsync belong in the example because they prove the shared root model; permissions and workspace sync do not.
• No issue-ledger writes in passes 3-9. Existing ledgers already carry the correct related/non-claim stance, and writing duplicate sections would add noise.

Error attempts:

External/browser findings:

• User-provided Notion content is treated as product scenario input, not as raw Slate requirements. Raw Slate will mimic the local synced editing behavior, not Notion permissions or workspace sync.
• ProseMirror/Tiptap are useful because of wrapper/content-slot discipline, not because Slate should copy their position model, command chain, or node-view API wholesale.
• Lexical's nested composer is an isolated-editor tool. It is explicitly not the target substrate for shared Synced Blocks.
• slate-yjs currently assumes one sharedRoot per editor; Slate v2 integration needs a root-keyed shared type map plus root-qualified selection/history.

Timeline:

• 2026-05-26T08:26:57.567Z Slate Plan goal plan created.
• 2026-05-26T08:33Z Pass 1 live source read completed and initial plan score set to 0.74.
• 2026-05-26T09:02Z Pass 2 related issue discovery completed; score moved to 0.75 and no ledger files were changed because no claim/status changed.
• 2026-05-26T09:34Z Pass 3 full issue-ledger scan completed; score moved to 0.76 and no ledger files were changed because no claim/status changed.
• 2026-05-26T09:50Z Pass 4 intent/boundary and decision brief completed; score moved to 0.78 and the next pass is ecosystem research refresh.
• 2026-05-26T10:19Z Pass 5 ecosystem/live-source refresh completed; score moved to 0.82 and the next pass is the performance/DX/migration/regression/ simplicity pressure pass.
• 2026-05-26T10:48Z Pass 6 pressure pass completed; score moved to 0.85 and the next pass is the Slate maintainer objection ledger.
• 2026-05-26T11:07Z Pass 7 maintainer objection ledger completed; score moved to 0.87 and the next pass is high-risk deliberate mode.
• 2026-05-26T11:29Z Pass 8 high-risk deliberate mode completed; score moved to 0.88 and the next pass is the ecosystem maintainer pass.
• 2026-05-26T11:45Z Pass 9 ecosystem maintainer pass completed; score moved to 0.90 and the next pass is revision.
• 2026-05-26 Pass 10 revision pass completed; score moved to 0.92 and the next pass is issue/reference sync accounting.
• 2026-05-26T09:20Z Pass 11 issue/reference sync accounting completed; score stayed 0.92 and the next pass is closure score and final gates.
• 2026-05-26T09:31Z Pass 12 closure score and final gates completed; score stayed 0.92 and the plan is ready for user review.

Verification evidence:

• .tmp/slate-v2: read packages/slate/src/interfaces/editor.ts for roots, root lifecycle, and content-root spec.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-slate-runtime.tsx for mounted root view registry and root-only lookup gap.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-slate-content-root.ts, use-slate-child-root.ts, and use-slate-root-chrome.ts for current helper composition.
• .tmp/slate-v2: read site/examples/ts/editable-voids.tsx for current manual root rendering and tx root creation in the example.
• .tmp/slate-v2: read packages/slate-react/src/editable/content-root-navigation.ts and keyboard-input-strategy.ts for current navigation integration.
• .tmp/slate-v2: read playwright/integration/examples/editable-voids.test.ts for existing browser proof floors.
• plate-2: read docs/research/README.md, docs/research/index.md, and docs/research/log.md; reused the 2026-05-25 content-root plan as prior decision context.
• plate-2: read docs/slate-v2/ledgers/issue-coverage-matrix.md:80, :123, and :212 for vertical/content-root claim policy.
• plate-2: read docs/slate-v2/references/pr-description.md:63 for existing PR non-claim wording.
• plate-2: read docs/slate-v2/ledgers/fork-issue-dossier.md:100, :150, :235, and :780 for content-root, multi-root focus, and shared-node identity decisions.
• plate-2: read docs/slate-issues/gitcrawl-live-open-ledger.md:20, :22, :47, :111, :176, and :634 for current generated live rows.
• plate-2: read docs/slate-issues/open-issues-ledger.md:160, :484, :512, :588, :835, and :1150 for current issue/cluster statuses.
• plate-2: read docs/slate-issues/gitcrawl-v2-sync-ledger.md:248, :365, :384, and :425 for manual current sync stance.
• plate-2: read docs/slate-issues/issue-clusters.md:59, :71, :124, :182, :209, and :235 for macro issue pressure.
• plate-2: read docs/slate-issues/package-impact-matrix.md:64, :75, :110, and :123 for package ownership.
• plate-2: read docs/slate-issues/requirements-from-issues.md:72, :106, :220, :247, :275, :302, :326, and :401 for requirements.
• plate-2: read docs/slate-issues/benchmark-candidate-map.md:458, :488, and :518 for dirty-path, rerender breadth, and large-document performance candidates.
• plate-2: read relevant docs/slate-issues/test-candidate-map/** rows for #5117, #5630, #5582, #5568, #4896, #4888, #4842, #4839, #4806, #4802, #5771, #3283, #3177, and #4301.
• .tmp/slate-v2: read packages/slate-react/src/components/editable-text-blocks.tsx:415, :424, :521, and :830 for slot ownership and renderer-local context.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-slate-content-root.ts:25 and use-slate-root-chrome.ts:26 for the hook stack the slot should hide.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-element.ts:10 for why <ContentRoot /> component sugar is technically possible but not the canonical choice.
• .tmp/slate-v2: read site/examples/ts/editable-voids.tsx:227 and :243 for the current manual API that Synced Blocks should stop teaching.
• plate-2: read docs/research/entities/prosemirror.md, docs/research/entities/tiptap.md, docs/research/entities/lexical.md, docs/research/systems/editor-architecture-landscape.md, and docs/research/systems/slate-v2-perfect-plan-steal-reject-defer-map.md for accepted cross-editor ownership boundaries.
• plate-2: read docs/research/decisions/editor-node-dx-should-use-runtime-owned-shells-and-spec-first-renderers.md and docs/research/decisions/slate-v2-react-19-2-perf-architecture-vs-field.md for runtime-owned shells, selectors, and dirty-commit pressure.
• ../prosemirror-view and ../prosemirror-state: read viewdesc.ts, transaction.ts, and selection.ts for NodeView.contentDOM, transaction-owned selection, and bookmark pressure.
• ../react-prosemirror: read README.md and migration-guides/v2.md for the portal/double-render warning and React-owned render rewrite.
• ../tiptap / ../tiptap-docs: read NodeViewWrapper.tsx, NodeViewContent.tsx, CommandManager.ts, and command docs for product DX and chain().run() boundaries.
• ../lexical: read LexicalDecoratorNode.ts, useReactDecorators.tsx, LexicalNestedComposer.tsx, LexicalUpdates.ts, and LexicalUtils.ts for decorator, nested-editor, and dirty-node pressure.
• ../slate-yjs: read withYjs.ts, withYHistory.ts, withCursors.ts, and position.ts for one-sharedRoot assumptions and relative selection/history storage.
• plate-2: read Plate createSlatePlugin, createPlatePlugin, toPlatePlugin, pluginInjectNodeProps, and pipeInjectNodeProps sources for raw-Slate vs Plate ownership.
• plate-2: read prior solution notes for multi-root public DX, rootless explicit selections, operation-root middleware, and root chrome clicks.
• plate-2: read performance-oracle, performance, tdd, shadcn, vercel-react-best-practices, and react-useeffect skill files as planning lenses for the applicable implementation-skill matrix.
• plate-2: read performance rule files for cohort segmentation, repeated-unit budgets, effect/subscription budgets, interaction matrices, memory/DOM tags, browser trace boundaries, and native editor behavior.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-editor-selector.tsx:104 and :213 for selector subscription and runtime-id fanout behavior.
• .tmp/slate-v2: read packages/slate-react/test/provider-hooks-contract.tsx:545, :615, :946, and :1079 for current selector fanout and mounted render selector contracts.
• .tmp/slate-v2: read packages/slate-react/test/content-root-navigation-contract.test.ts:1 for existing content-root navigation unit coverage.
• plate-2: read docs/solutions/performance-issues/2026-05-23-slate-v2-core-operation-benchmarks-must-not-hide-snapshot-costs.md and docs/solutions/performance-issues/2026-05-12-slate-render-props-should-not-carry-moving-paths.md for benchmark and render-prop performance guardrails.
• plate-2: ran node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md; it correctly reported the plan incomplete because later pass rows remained pending.
• .tmp/slate-v2: re-read packages/slate/src/interfaces/editor.ts:87, :249, :487, and :513 for root storage, root lifecycle, void kinds, and content-root schema during the maintainer objection pass.
• .tmp/slate-v2: re-read packages/slate-react/src/components/editable-text-blocks.tsx:415, :506, and :2032 for slot ownership, renderer props, and internal root-bound Editable wrapping.
• .tmp/slate-v2: re-read packages/slate-react/src/hooks/use-slate-runtime.tsx:348, :386, and :639 plus use-slate-history.ts:173 for mounted view sets, root-only lookup gap, root-scoped selector gates, and history focus restore.
• .tmp/slate-v2: re-read use-slate-content-root.ts:25, use-slate-child-root.ts:37, content-root-navigation.ts:136, and site/examples/ts/editable-voids.tsx:137 / :227 for current low-level content-root API and example ceremony.
• ../prosemirror-view, ../react-prosemirror, ../tiptap, and ../slate-yjs: re-read the local source slices for NodeView.contentDOM, React/ProseMirror render-phase hazards, NodeViewContent, and current one-sharedRoot slate-yjs assumptions.
• .tmp/slate-v2: read packages/slate-react/src/hooks/use-slate-runtime.tsx:348, :386, and :639, plus packages/slate-react/src/hooks/use-slate-history.ts:173, for the wrong-copy focus/high-risk pass.
• .tmp/slate-v2: read packages/slate-react/src/editable/content-root-navigation.ts:61, :136, :443, and :980 plus packages/slate-react/test/content-root-navigation-contract.test.ts:77, :131, :228, and :253 for content-root boundary and key filtering risk.
• .tmp/slate-v2: read playwright/integration/examples/editable-voids.test.ts:379, :787, and :910 for current browser proof floors around keyboard, vertical movement, and click-outside behavior.
• plate-2: read the prior rootless selection, operation-root middleware, multi-root chrome click, and benchmark-helper solution notes for failure modes that must not repeat in Synced Blocks execution.
• .tmp/slate-v2: read packages/slate-react/test/provider-hooks-contract.tsx:545, :615, and :946 for selector fanout and mounted render selector risk.
• ../slate-yjs: read withYjs.ts:29, :156, and :204 for the current one-sharedRoot assumption that keeps collaboration support as a non-claim.
• ../prosemirror-view: re-read viewdesc.ts:31, :35, :71, :81, and :993 for maintainer pressure around outer chrome, editor-owned content slots, event boundaries, and child updates.
• ../prosemirror-state: re-read transaction.ts:67 and selection.ts:436 for transaction-owned selection and selection-near/content search pressure.
• ../react-prosemirror: re-read README.md:109, :117, and :215 for render-phase purity and view/layout method timing constraints.
• ../tiptap: re-read NodeViewWrapper.tsx:10, NodeViewContent.tsx:10, and CommandManager.ts:51 for wrapper/content DX and command-chain boundaries.
• ../lexical: re-read DecoratorNode.ts:23, LexicalNestedComposer.tsx:33, LexicalUpdates.ts:243, and useReactDecorators.tsx:18 for decorator, nested-editor, dirty-node, and external-store pressure.
• ../slate-yjs: re-read withYjs.ts:29, withYHistory.ts:68, and withCursors.ts:31 for current single-shared-root, relative history, and cursor assumptions.
• .tmp/slate-v2: re-read packages/slate-react/src/hooks/use-editor-selector.tsx:104, :157, and :213, plus packages/slate-react/src/hooks/use-slate-runtime.tsx:348, :386, and :639, for React selector/runtime lifecycle constraints.
• plate-2: re-read docs/research/systems/slate-v2-perfect-plan-steal-reject-defer-map.md:30, :60, :74, :104, :117, and :131 plus docs/research/decisions/editor-node-dx-should-use-runtime-owned-shells-and-spec-first-renderers.md:136 for the final steal/reject map.
• plate-2: reran node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md after pass 9; it correctly reported incomplete because revision, issue-sync, closure rows, and final checklist gates remain pending.
• plate-2: ran revision scans for stale pending/pass text with rg -n "pending|after pass 9|pass 9|revision|Final user-review|Final completion|Work Checklist|Completion Gates|Weighted score|score >=|TDD used|Browser proof|Verification workspace" docs/plans/2026-05-26-slate-v2-synced-content-roots.md.
• plate-2: re-read this plan's work checklist, completion gates, scorecard, final handoff outline, final completion gates, reboot status, and open risks before the revision pass.
• plate-2: reran node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md after pass 10; it correctly reported incomplete because only issue-sync and closure rows remain pending.
• plate-2: read issue/reference sync surfaces with rg and nl -ba: docs/slate-v2/ledgers/issue-coverage-matrix.md, docs/slate-v2/ledgers/fork-issue-dossier.md, docs/slate-issues/gitcrawl-v2-sync-ledger.md, and docs/slate-v2/references/pr-description.md.
• plate-2: updated those four sync/reference files with the Synced Blocks planning-sync stance: no new Fixes, no new Improves, and all reviewed rows stay related, unchanged, or non-claim until execution proof exists.
• plate-2: reran node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md after pass 11; it correctly reported incomplete because only the closure row remains pending.
• plate-2: final closure pass set the plan lane state to complete, marked the closure phase complete, and prepared the final checker run.
• plate-2: final checker passed: node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-26-slate-v2-synced-content-roots.md returned [autogoal] complete: docs/plans/2026-05-26-slate-v2-synced-content-roots.md.

Reboot status:

Open risks:

• Current root view lookup can focus the wrong copy when a root has multiple mounted projections.
• Existing browser proof covers editable-voids, not the new Synced Blocks route.
• Browser proof still must prove the slot implementation and active projection behavior on /examples/synced-blocks.
• Browser proof still cannot be claimed until execution adds the route and runs the native interaction rows.