Slate v2 void roots and editable islands

Objective: Close the Slate v2 long-term void/root/editable-island architecture plan for user review. The plan must choose the best durable split between default atomic voids, root-backed editable islands with shared Slate state, navigation across editor-only rooted content, and the possible separate node type for an island that contains only an editor. Complete the scheduled Slate Plan passes one activation at a time: current-state read and initial score; related issue discovery; issue-ledger pass; intent/boundary and decision brief; research / ecosystem / live-source refresh; performance, DX, unopinionated-core, migration, regression, research, and simplicity pressure passes; Slate maintainer objection ledger; high-risk deliberate mode; ecosystem maintainer pass; revision pass; issue sync accounting; closure score and final gates.

Goal plan: docs/plans/2026-05-25-slate-v2-void-roots-and-editable-islands.md

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

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

Applied packs:

• none

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-25-slate-v2-void-roots-and-editable-islands.md passes.
• Planning closeout is user-review-ready only. Implementation waits for later explicit user acceptance and a second slate-plan invocation naming this plan.

Verification surface:

• Planning-only checks run in plate-2.
• Every Slate v2 source/runtime/browser/API claim must cite the live .tmp/slate-v2 workspace source or command evidence.
• Issue claims must be verified from docs/slate-issues/**, docs/slate-v2/ledgers/**, and docs/slate-v2/references/**.
• Browser and package proof for new behavior is an execution gate, not a pass-1 planning claim.

Constraints:

• Planning mode may edit only docs/plans/**, docs/research/**, docs/slate-issues/**, docs/slate-v2/ledgers/**, and docs/slate-v2/references/**.
• Do not patch .tmp/slate-v2 implementation in planning mode.
• Keep raw Slate unopinionated. Plate/app code owns product widgets, forms, labels, validation, layout, and shadcn-style component polish.
• Do not widen renderVoid with path/actions/children/focus prop bags.
• Do not hide a top-level root ordering migration inside this island/void lane.

Boundaries:

• In scope: default void semantics, editable-island semantics, child-root lifecycle, root-backed editor-only content, arrow/navigation policy, selection/focus/history/clipboard/delete/move semantics, example DX, migration backbone, issue accounting, and proof gates.
• Non-goals: current-version Plate adapters, current-version slate-yjs adapters, raw Slate form-builder APIs, rich content as normal void element descendants, automatic roots for every void, and implementation before user acceptance.
• Decision boundary: Slate Plan may choose the target architecture/API and proof gates; user review is required before implementation.

Blocked condition:

• Block only if the live .tmp/slate-v2 workspace or required issue ledgers are unavailable after three consecutive attempts and no alternate source-grounding, research, ledger, or plan-hardening move remains runnable.

Slate Plan lane state:

• slate_plan_lane_status: complete
• current_pass: closure-score-final-gates
• current_pass_status: complete
• next_pass: none
• next_action: none
• final_handoff_status: complete

Current verdict:

• verdict: ready for user review. The accepted long-term shape is stable: default voids stay atomic, editable-island handles mixed native/app-control islands, editor-only rooted flow uses planned object-only contentRoot: { slot: string }, root lifecycle authoring gets public tx.roots.create/replace/delete, and React gets a small useSlateContentRoot helper over useSlateChildRoot + useSlateRootChrome. No boolean/string contentRoot shorthand, no built-in editable node type, no new void kind, no current slate-yjs support claim, and no new fixed/improved issue claim.
• confidence: 0.92
• keep / cut / revise call: revise the previous "editable-island only" answer into a three-surface split:
  1. keep default void atomic, legacy-like, and not navigable through content;
  2. keep editable-island for mixed native/app controls plus optional rich same-runtime child roots;
  3. add a separate editor-only rooted-content surface for the case where the element is just an editor and should navigate like document blocks.
• reason: live Slate v2 source already proves editable-island is a distinct void kind, same-runtime child roots work in the example/tests, root-scoped views/selectors exist, and root lifecycle metadata is transaction-owned. The pressure pass rejects default root creation for every void, one editor per block, raw replace_children authoring, and product-form APIs in raw Slate. The maintainer objection pass keeps that target but makes the API discipline explicit: the new surface must not be another void kind, must not be a built-in node type, must not claim slate-yjs support early, and must earn cross-root navigation through high-risk proof. The high-risk pass keeps the plan honest: existing child-root browser proof is an isolation floor, not sibling-flow proof, and current slate-yjs is still a single-sharedRoot adapter. The ecosystem maintainer pass makes the final architectural steal explicit: host shell plus editor-owned content hole, root-scoped subscription, and policy hooks without adopting another editor's engine shape. The revision pass freezes the concrete public shape; the issue-sync accounting pass confirms every claim artifact uses that frozen shape as planned architecture only. The closure pass verified the score, pass table, proof gates, issue sync, handoff, and remaining implementation boundaries.

Completion rule:

• Do not call update_goal(status: complete) while any required checklist item remains unchecked.
• Do not call update_goal(status: complete) while any pass row is pending, in progress, revised, or blocked with a runnable next move.
• The current activation completed only the closure score and final gates pass. All earlier pass rows were already complete before this activation started.

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 for this activation.
• Live source grounding recorded for pass-1 current implementation claims.
• Related issue discovery / ClawSweeper input pass applied with concrete evidence.
• Final issue-ledger accounting pass closed with concrete evidence.
• Intent/boundary record and decision brief complete.
• Research and ecosystem synthesis complete for every external system used as evidence.
• Applicable implementation-skill review matrix applied or skipped with concrete reason.
• Slate maintainer objection ledger complete for every breaking/paradigm change.
• Scorecard recorded with evidence; total score >= 0.92 and no dimension below 0.85 before closure.
• 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.
• Browser proof captured for browser-surface claims, or marked N/A with reason.

Completion Gates:

Phase / pass table:

Scorecard:

Weighted score after pass 12: 0.92.

Source-backed architecture north star:

• target shape: split the model into atomic voids, mixed editable islands, and editor-only rooted content.
• source evidence: current Slate v2 already distinguishes void from atom: editable-island is a void kind, but create-editor makes atom true for normal voids and false for editable islands at .tmp/slate-v2/packages/slate/src/create-editor.ts:309.
• rejected drift: do not redefine default voids as traversable content; do not use void element children for rich island content; do not use a mixed native-control island as the only answer for editor-only rooted flow content.
• migration posture: keep existing void behavior by default; migrate rich same-runtime island examples to child roots; add an editor-only rooted surface only if it gives cleaner navigation and DX than overloading editable-island.

Current-state source facts:

Public API target:

Internal runtime target:

Hook / component / render DX target:

Revision-pass frozen API surface:

export type EditorElementContentRootSpec = {
  /**
   * Slot key on `element.childRoots` that stores the projected content root.
   *
   * The slot is schema vocabulary. The actual `RootKey` is document data:
   * `element.childRoots[slot]`.
   */
  slot: string
}

export type EditorElementSpec = {
  contentRoot?: EditorElementContentRootSpec
  type: string
  void?: EditorElementVoidKind
  // existing fields unchanged
}

export type EditorTransactionRootsApi<V extends Value = Value> = {
  create: (root: RootKey, children: V) => void
  delete: (root: RootKey) => void
  replace: (root: RootKey, children: V) => void
}

Revision-pass API rules:

• contentRoot is object-only. No true shorthand, no string shorthand, and no implicit default slot in the schema field. Agents should see slot in the type.
• contentRoot is not a void kind. Ordinary void: 'block' | 'inline' | 'markable-inline' stays atomic; void: 'editable-island' stays the mixed-control island.
• contentRoot.slot points to element.childRoots[slot]. The spec never stores root ids.
• tx.roots.create throws or fails loudly when the root already exists; tx.roots.replace requires an existing root; tx.roots.delete must not delete main and records rootIsPresent: false through operation lifecycle.
• useSlateContentRoot(element, options?) is the only new React helper target. It resolves the content-root slot from schema or options.slot, delegates to useSlateChildRoot, and returns { chrome, root } using useSlateRootChrome.

Revision-pass keyboard/navigation law:

Plate migration-backbone target:

slate-yjs migration-backbone target:

Intent / boundary record:

• intent: choose the durable long-term Slate v2 model for voids and root-backed editable content now that multi-root support exists and editable voids can be same-runtime instead of nested independent editors.
• outcome: a Slate user can keep ordinary voids atomic, build mixed interactive islands with shared child roots, and build editor-only root-backed content whose keyboard navigation feels like document blocks.
• in-scope: source-grounded API/runtime target, issue mapping, decision boundaries, proof gates, root lifecycle, navigation semantics, and migration backbone.
• non-goals: implementation, product UI, current-version adapters, rich content under normal void children, automatic roots for every void, one-editor-per- block as the default substrate, and broad top-level root ordering redesign.
• decision boundaries: this plan may choose target surfaces and proof gates; user review is required before execution. Future implementation must still prove final naming and public API shape.
• explicit semantic boundary: void means atomic by default. A root-backed element can share state without being a default traversable void.
• explicit navigation boundary: mixed native-control islands are isolated; editor-only rooted content is the only surface allowed to project child-root blocks into parent-flow navigation.
• explicit ordering boundary: keyed roots remain storage identity. The parent element path owns document-flow placement for editor-only rooted content; this lane must not smuggle in ordered top-level roots.
• unresolved user-decision points: none for the architecture. User review is still required before implementation.

Decision brief:

• principles: default voids stay atomic; editor-only content should not pretend to be app/native UI; app/native controls should not pretend to be document text; render callbacks render content only; root lifecycle is transaction- owned; cross-root navigation needs explicit proof.
• top drivers: user wants legacy void semantics plus root-backed shared state plus natural navigation; current source already separates void and atom; current examples prove same-runtime child roots inside mixed islands; browser tests prove isolation but not sibling-block navigation.
• viable options:
  • Option A: one overloaded editable-island type for mixed controls and editor-only rooted content. Pro: fewer names. Con: native-control and editor-flow navigation policies conflict.
  • Option B: three-surface split. Pro: preserves voids, keeps mixed islands honest, gives editor-only root content a clean navigation contract, and matches the current one-runtime, many-root direction. Con: adds one public concept.
  • Option C: make void children/root content navigable by default. Pro: simplest mental model in the narrow case. Con: breaks the definition of void and reopens spacer/selection bugs.
  • Option D: one editor per block/root. Pro: natural React containment and local block isolation. Con: cross-selection, history, clipboard, undo/redo, focus, normalization, and collaboration would need a second editor- federation layer. That fights the user's shared-state requirement and the current one-editor/many-root implementation.
• chosen option: Option B.
• rejected alternatives: C is rejected because it changes what a void is. A is rejected as the default target because the mixed native-control case and pure editor-flow case need different focus/navigation contracts. D is rejected for this lane because it makes "children as sibling blocks" harder, not easier, once shared selection/history/collab matter.
• consequences: need public root lifecycle helpers, object-only contentRoot with { slot: string }, a minimal useSlateContentRoot helper, cross-root caret/navigation tests, delete/undo/clipboard/collab lifecycle proof.
• follow-ups: maintainer objection ledger, high-risk proof hardening, ecosystem maintainer pass, revision pass, and final issue/reference sync.

Decision law:

Pressure pass decision matrix:

Issue accounting:

Issue-ledger sync status:

• ClawSweeper related-issue pass: complete for the changed prompt using durable ledgers and live generated rows; no live GitHub write/read was needed.
• final issue-ledger pass: complete. The current plan adds no fixed issue claims and no improved issue claims. It preserves existing fixed floors #3991, #4301, #4984, and #4806 only where already proven.
• generated live gitcrawl rows read: #5212, #2072, #3482, #3367, #3435, #3884, #3991, #4301, #3868, #5582, #5477, #4896, #4350, #4328, #5630, #4984, #4842, #3909, #4806, #4802, #4104, #3926, #4888, #4623, #5183, #5391, #5559, #4839, #5087, #5411, #3611, #1769, and #3893, plus clusters 12, 17, and 21.
• manual v2 sync ledger update: appended 2026-05-25 Void Roots / Editor-only Rooted Flow Planning Delta to docs/slate-issues/gitcrawl-v2-sync-ledger.md.
• fork issue dossier update: appended Void Roots / Editor-only Rooted Flow Surface Review - 2026-05-25 to docs/slate-v2/ledgers/fork-issue-dossier.md.
• issue coverage matrix update: appended Void Roots / Editor-only Rooted Flow Planning Delta - 2026-05-25 to docs/slate-v2/ledgers/issue-coverage-matrix.md.
• issue coverage matrix top fixed list: restored existing #4806 fixed claim to the top fixed-issue list because the detailed matrix row and PR reference already claimed it. This is sync repair, not a new claim.
• PR description sync: pass 2 left the PR reference unchanged; pass 3 added a non-claim planning-summary bullet for the 2026-05-25 void roots/editor-only rooted-flow delta. Fixed/improved issue claim count remains unchanged.
• issue-sync accounting pass: complete. The sync ledger, fork dossier, coverage matrix, and PR reference now all describe object-only contentRoot with { slot: string } as planned architecture only. No artifact claims current implementation support, no fixed/improved issue claim was added, and the unique fixed issue ID set remains unchanged between the coverage matrix and PR reference.

Final issue-claim stance:

Ecosystem strategy synthesis:

Ecosystem maintainer pass:

Ecosystem maintainer verdict:

• steal ProseMirror/Tiptap's content-hole discipline, not their engine shape.
• steal Lexical's policy vocabulary and nested-editor caution, not nested editors.
• steal React's external-store contract, not React-owned editor semantics.
• treat Plate as product pressure and slate-yjs as migration pressure.
• keep the Slate answer unopinionated: app-defined element spec plus root slot, public tx root helpers, root-scoped selectors, and explicit boundary tests.

Legacy regression proof matrix:

Browser stress / parity strategy:

Verification workspace gate:

Applicable implementation-skill review matrix:

High-risk deliberate-mode pre-mortem:

High-risk execution proof gates:

Slate maintainer objection ledger:

Hard cuts and rejected alternatives:

Plan deltas from review:

• Created this new slate-plan template plan for the changed prompt instead of reusing the completed 2026-05-24 plan unchanged.
• Updated the north star from "editable-island plus child root" to a stricter split: default atomic void, mixed editable island, and editor-only rooted element for sibling-block navigation.
• Recorded that the live example has moved beyond the stale nested-editor claim: it now uses same-runtime child roots, but still has poor insertion DX through raw replace_children.
• Lowered confidence to 0.72 because the new editor-only rooted-flow decision has not yet passed issue, research, migration, objection, or proof gates.
• Pass 2 updated confidence to 0.73 after bounded issue discovery. The decisive issue signal is that #2072/#3367/#3482 support a split surface, while #3435/#3884/#4301/#3991/#5630 and nested/contenteditable rows make default void traversal a bad long-term move.
• Pass 2 corrected the stale 2026-05-24 ledger premise: the live canonical example now uses same-runtime child roots, so the remaining DX problem is raw root creation plus missing editor-only rooted-flow navigation.
• Pass 3 finalized issue accounting: the plan now treats editor-only rooted flow as related architecture pressure only, keeps default void traversal a non-claim, preserves existing fixed floors #3991/#4301/#4984/#4806, and records the proof consequences per issue bucket.
• Pass 3 updated PR/reference sync without inflating claims: added one non-claim PR summary bullet for the 2026-05-25 planning delta and restored existing #4806 to the coverage matrix top fixed list because it already existed in the detailed matrix and PR reference.
• Pass 4 hardened the intent/boundary and decision brief: selected the three-surface split as the planning target, rejected one overloaded editable-island as the default answer, rejected one-editor-per-block for this lane, and clarified that editor-only rooted content should use a root-content/navigation axis rather than another void kind.
• Pass 5 refreshed ecosystem/live-source evidence: React supports root-scoped external-store subscriptions; Lexical warns against independent nested-editor inheritance/collab/copy-paste assumptions; ProseMirror/Tiptap validate the host-shell plus editor-owned-content-hole mechanism; Plate confirms mixed app-control island pressure; slate-yjs confirms that current collaboration assumptions are single-root and must become root-qualified before any multi-root collab claim.
• Pass 6 pressure-tested the decision: kept one-runtime/many-root with root/runtime-scoped selector budgets, rejected auto-root-per-void/block, rejected a hardcoded "editable node type", narrowed the target to a root-content spec axis plus a small editor-only helper, required public tx.roots.*-style helpers, and kept migration/research below closure until maintainer objections and high-risk proof rows close.
• Pass 7 ran the maintainer objection ledger. The objections did not overturn the architecture, but they removed the vague "editor-only node type" phrasing: the target is a contentRoot-style spec axis for app-defined elements, public tx root lifecycle helpers, and a minimal React helper. Claims remain gated for high-risk browser/navigation/collab proof.
• Pass 8 ran high-risk deliberate mode. The architecture still stands, but the plan now names the hard gates: root lifecycle, contentRoot API shape, projected caret movement, insertBreak, delete/backspace, clipboard/drop, history/collab, mobile/native focus, repeated-root performance, and render API minimalism. Existing editable-voids proof is only an isolation/lifecycle floor, not sibling-flow proof.
• Pass 9 ran the ecosystem maintainer pass. It confirms the long-term target: steal ProseMirror/Tiptap's shell plus editor-owned content hole, React's external-store selector discipline, and Lexical's isolation/keyboard policy vocabulary; reject nested independent editors, ProseMirror/Tiptap engine leakage, product UI in raw Slate, and any current slate-yjs support claim.
• Pass 10 ran the revision pass. It froze the target shape as object-only contentRoot: { slot: string }, persisted root ids in element.childRoots[slot], public tx.roots.create/replace/delete, and a minimal useSlateContentRoot helper. It also froze boundary navigation rules and kept all related issues as no-new-fixed-claim until implementation proof.
• Pass 11 ran issue-sync accounting against the frozen revision. It updated the manual sync ledger, fork dossier, issue coverage matrix, and PR reference so each artifact names contentRoot: { slot: string } only as planned architecture. Unique fixed issue IDs still match between the coverage matrix and PR reference; the 2026-05-25 delta adds zero fixed and zero improved claims.
• Pass 12 ran closure score and final gates. It closed the lane at score 0.92, verified every pass row is complete, marked TDD/browser proof as planning-only N/A with execution gates named, recorded final handoff/reboot status/open risks, and left no runnable planning pass.

Open questions and decision-changing evidence:

Implementation phases with owners:

Fast driver gates:

Final user-review handoff outline:

• accepted plan items:
  • default void remains atomic and legacy-like;
  • editable-island remains the mixed native/app-control island surface with optional same-runtime child roots;
  • editor-only rooted flow uses planned object-only contentRoot: { slot: string } on app-defined element specs;
  • root lifecycle authoring should use public tx.roots.create, tx.roots.replace, and tx.roots.delete;
  • React DX should expose useSlateContentRoot(element, options?) as a small helper over useSlateChildRoot and useSlateRootChrome.
• before / after API shape:
  • before: same-runtime child roots exist, but the example still leaks raw root-level replace_children replay and there is no editor-only rooted-flow schema axis;
  • after target: root ids persist in element.childRoots[slot], the schema names the content slot through contentRoot: { slot: string }, and public tx/root helpers own create/replace/delete.
• hard cuts:
  • no traversable default voids;
  • no rich content under normal void children;
  • no one overloaded editable-island contract for both native controls and pure editor flow;
  • no one-editor-per-block default substrate for raw Slate;
  • no widened renderVoid prop bag.
• issue claims and non-claims:
  • no new fixed issue claims;
  • no new improved issue claims;
  • existing fixed floors #3991, #4301, #4984, and #4806 stay exact;
  • #2072, #5212, #3482, #3367, navigation/delete/clipboard/mobile, and focus rows stay related/proof-gate pressure.
• proof gates:
  • API/type tests for EditorElementSpec.contentRoot and tx.roots.*;
  • core navigation tests for the projection bridge while generic cross-root ranges still reject;
  • root lifecycle delete/history/collab tests;
  • React runtime/root-selector tests;
  • browser rows for arrows, Enter, delete, copy/cut/paste/drop, undo/redo, and mobile where relevant;
  • bun check:full before release-quality browser/collab claims.
• accepted-plan execution handoff:
  • implementation starts only after explicit user acceptance and a new execution-shaped slate-plan invocation naming this plan.

Final completion gates:

Verification evidence:

• Active goal: get_goal returned the matching Slate Plan objective for this long-term void/editable-island architecture lane.
• Skill gate: .agents/skills/slate-plan/SKILL.md was read in this closure pass; closure is legal only because rows 1-11 were already complete before this activation.
• Memory grounding: MEMORY.md:543-579 confirmed same-runtime child-root contracts, content-only renderVoid, root lifecycle metadata, and the one-runtime-editor comparison caveat; live source rows in this plan remain authoritative for current API claims.
• Planned-only API gap: in .tmp/slate-v2, rg -n 'contentRoot|useSlateContentRoot|tx\.roots' packages/slate packages/slate-react site/examples/ts/editable-voids.tsx returned no matches, confirming the frozen API is a plan target, not current implementation.
• Issue claim parity: in plate-2, comm -3 <(rg -o '^- Fixes #[0-9]+' docs/slate-v2/ledgers/issue-coverage-matrix.md | sed 's/.*#//' | sort -n | uniq) <(rg -o '^- Fixes #[0-9]+' docs/slate-v2/references/pr-description.md | sed 's/.*#//' | sort -n | uniq) returned no output, confirming the fixed issue ID set matches between the coverage matrix and PR reference.
• Issue/reference wording: rg over the sync ledger, fork dossier, coverage matrix, and PR reference found the planned contentRoot wording and the explicit 0 new fixed/improved claim summary.
• Final checker: node .agents/rules/autogoal/scripts/check-complete.mjs docs/plans/2026-05-25-slate-v2-void-roots-and-editable-islands.md returned [autogoal] complete: docs/plans/2026-05-25-slate-v2-void-roots-and-editable-islands.md.

Reboot status:

Open risks:

• Implementation still needs proof for contentRoot, tx.roots.*, useSlateContentRoot, cross-root keyboard projection, delete/history/collab, clipboard/drop, repeated-root performance, and browser/mobile behavior.
• slate-yjs support remains a migration gate, not a current support claim.
• These are execution risks, not open planning blockers; no runnable planning pass remains.

Execution state:

• execution_lane_status: active
• current_execution_slice: public-api-lifecycle-and-react-helper
• current_execution_slice_status: complete
• next_execution_slice: editor-only-rooted-flow-keyboard-navigation
• next_execution_action: implement and test the projection bridge for arrow, Enter, Backspace/Delete, owner/root lifecycle, and browser proof; do not make issue closure claims until those focused gates pass.

Execution slice 1 summary:

• .tmp/slate-v2/packages/slate/src/interfaces/editor.ts: added EditorElementContentRootSpec, EditorElementSpec.contentRoot, and EditorTransactionRootsApi.
• .tmp/slate-v2/packages/slate/src/core/public-state.ts: added tx.roots.create/replace/delete over root-level replace_children with explicit rootWasPresent / rootIsPresent metadata and main-root guards.
• .tmp/slate-v2/packages/slate-react/src/hooks/use-slate-content-root.ts: added useSlateContentRoot(element, options?) over schema contentRoot.slot, useSlateChildRoot, and useSlateRootChrome.
• .tmp/slate-v2/site/examples/ts/editable-voids.tsx: replaced raw tx.operations.replay([{ type: 'replace_children', ... }]) root creation with tx.roots.create.
• Issue/reference sync updated the manual v2 sync ledger, fork dossier, issue coverage matrix, and PR reference. New fixed/improved issue claims remain 0.

Execution slice 1 verification:

• .tmp/slate-v2: bun test ./packages/slate/test/rooted-operation-contract.ts ./packages/slate/test/public-element-void-kind-contract.ts passed, 24 tests.
• .tmp/slate-v2: bun --filter ./packages/slate-react test:vitest -- slate-runtime-provider-contract passed, 35 tests.
• .tmp/slate-v2: bun --filter ./packages/slate typecheck passed.
• .tmp/slate-v2: bun --filter ./packages/slate-react typecheck passed.
• .tmp/slate-v2: bun typecheck:site passed.
• .tmp/slate-v2: bun lint passed after targeted Biome formatting.

Execution slice 1 open risks:

• Keyboard projection across parent root and child root is not implemented.
• Browser proof for editor-only rooted flow is not captured.
• Root payload copy/cut/drop/remap and slate-yjs mapping remain gated.
• The execution goal remains active.