…s unchanged

Two-layer fast path in $reconcileChildren for the common case where a
parent is in the dirty set only because some descendant changed, not
because the parent's own children list moved.

Layer 1 — skip the prev/next children array rebuild when:
  - prevSize === nextSize
  - prev.__first === next.__first
  - prev.__last === next.__last
  - parent is not in editor._cloneNotNeeded

The cloneNotNeeded check is the right structural-change signal:
splice / append / remove all call parent.getWritable(), which adds the
parent to _cloneNotNeeded. The intentionallyMarkedAsDirty flag in
dirtyElements is unreliable for this purpose because $applyAllTransforms
force-marks root with `true` for its "transform finalizer" semantic
(LexicalUpdates.ts:315), even when no children moved.

Layer 2 — for each child in the walk, skip the $reconcileNode call when
the child key is in neither dirtyLeaves nor dirtyElements. dirtyElements
propagation guarantees that a clean child has no dirty descendants, so
the child's existing DOM and cached __lexicalTextContent are still valid;
just accumulate the cached text into subTreeTextContent.

Measured on a 5000-paragraph doc, typing 1 char per cycle (50 cycles,
3-run average, jsdom):

  baseline                        mean 1.566ms / median 1.395ms
  + Layer 1 fast path             mean 1.136ms / median 0.972ms  (-27%)
  + Layer 2 (skip non-dirty)      mean 1.057ms / median 0.902ms  (-32%)
  + GenMap (other PR)             mean 0.523ms / median 0.460ms  (-67%)

… + safer narrowing

Replace the recursive `$prevSubtreeTextLength` walk with a node-keyed cache
of `getTextContentSize()` (a `WeakMap<LexicalNode, number>` so the entry
survives `Object.freeze` in dev). The reconciler sets the entry on every
node it reconciles or creates, so the previous-state instance always
carries a current label and the suffix-incremental fast path can read it
in O(1) without ever falling back to a recursive walk that would resolve
through `getLatest()` -> next state.

This also collapses the `getTextContent()` fallback in the suffix newSuffix
loop's quadratic-risk surface — once the cache invariant holds, there's no
recursion to repeat.

Other review items addressed in the same pass:

- `activePrevKeyToDOMMap` is now typed `Map<NodeKey, HTMLElement &
  LexicalPrivateDOM>` so the suffix path doesn't need to cast every
  `__lexicalTextContent` read.
- Tests and the editorCycle bench narrow via `invariant($isParagraphNode)`
  / `invariant($isTextNode)` instead of `<NodeType>` generics or `as`
  casts.

…ion test

Style fixes (etrepum's three suggestion comments):
- Type the local `dom` in $createNode as `HTMLElement & LexicalPrivateDOM`
  so the empty-element write and the $computeCachedTextSize call don't
  need casts.
- Drop the `as` cast at the $reconcileNode-side $computeCachedTextSize
  call site (now redundant with the local type).

Test addition:
- "sustained typing on the same paragraph stays correct (cache freshness)"
  exercises the multi-cycle propagated-dirty same-instance case. With a
  multi-paragraph layout (so the root-level suffix path actually fires),
  it types into the same paragraph across 4 cycles and verifies the cached
  text stays correct each round. This is the scenario where a Symbol-keyed
  property + skip-if-frozen alternative cache implementation silently
  produces wrong splices in dev (verified empirically); the WeakMap
  approach passes by re-setting through Object.freeze.

…property + ctor pre-init

Addresses etrepum's review on PR facebook#8482 (cache implementation).

- LexicalNode constructor: pre-allocate the cached-text-size slot as a
  non-enumerable property so all node instances share the same V8 hidden-
  class shape and the setter is a stable inline-cache hit instead of a
  per-instance shape transition.
- LexicalReconciler: replace the WeakMap-keyed cache with a Symbol-keyed
  property. Leaf-only — ElementNodes already carry their text content in
  dom.__lexicalTextContent (written at the end of $reconcileChildren), so
  $cachedTextSize routes elements to the DOM cache via the $getDOMSlot
  indirection (handles TableNode and similar wrapping the keyed DOM).
- Skip leaf writes when the instance is frozen in DEV. Cross-parent moves
  can pass an already-frozen leaf back through $createNode/$reconcileNode;
  the frozen instance still carries a valid Symbol from its prior cycle,
  and a leaf that genuinely needs a new size went through getWritable()
  -> static clone -> ctor -> fresh undefined slot.
- Drop $computeCachedTextSize (its branches are absorbed into the setter).

Bench (3 runs, vitest): with-children-fast-path
  size=1000:  WeakMap 10,978 hz  ->  Symbol+pre-init 11,338 hz  (+3.3%)
  size=5000:  WeakMap  7,441 hz  ->  Symbol+pre-init  7,587 hz  (+2.0%)

Constructor cost: isolated microbench shows ~70 ns extra per node for the
additional defineProperty (~350 us per 5000-paragraph import — negligible
relative to the typing hot-path gain).

…ext invariant fix

Two changes that surfaced together:

- MIN_FAST_PATH_CHILDREN = 4: gate the suffix-incremental fast path on a
  non-negligible parent size, per etrepum's review note. The bookkeeping
  (cache lookups, suffix walk, splice) doesn't pay for parents with very
  few children. Bench-tuned via editorCycle.bench; size=1000 / size=5000
  typing land within noise of the un-gated baseline.
- Root `__cachedText` invariant fix: `reconcileTextFormat` can call
  `setTextFormat` on the parent during a child reconcile, which clones
  root mid-cycle. The local `nextNode` in `$reconcileNode` then points
  at the stale pre-clone instance — its `__cachedText` matches the
  freshly-computed `subTreeTextContent` and the cache setter no-ops
  while the actual root in the map carries `null` (RootNode constructor's
  default). The fix re-fetches via `nextNode.getLatest()` before the
  comparison so the writable assign lands on the correct instance.

The latent cachedText bug was masked before this PR's change because the
suffix fast path explicitly nulls `subTreeTextFormat` so `reconcileTextFormat`
never runs. The MIN gate routes small parents through the general path,
which is where the cloning happens.

Adds AUDIT-4 demonstrating that the cache reads in $bubbleChildFirstText
(and the parallel read in Layer 2's non-dirty branch at line 1095) go
through the keyed DOM, while the cache writes in $createChildren and
$reconcileChildren go through `slot.element` (the inner DOM returned
by `node.getDOMSlot(dom)`).

For elements without wrapping DOM, keyed DOM === slot.element, and the
read finds the cache. For wrapping elements (TableNode wraps a `<table>`
in a scrollable `<div>`; custom inline wrappers like the test's
`<main><section></section></main>`), keyed DOM !== slot.element and the
read on the keyed DOM returns undefined. The bubble silently skips and
the parent's first-text capture loses this child.

When the wrapper element is a non-dirty prefix child carrying the
canonical first text descendant, the parent's __lexicalFirstTextKey and
__textFormat end up reflecting a later dirty sibling's first text
instead. Test asserts para.__textFormat = BOLD (textA in the wrapper)
but gets ITALIC (textB in linkB) because of the missed bubble.

In production, TableNode is the only wrapping element in Lexical core.
TableNode is block-level and usually sits at root, where __textFormat
propagation is gated by the $isRootOrShadowRoot check, so the symptom
is masked. The bug would surface for custom Lexical extensions that
define inline wrapping elements, or for any future core node with the
same shape.

The empty-element write at $createNode line 413-414 has the inverse
asymmetry: it writes to `dom` (keyed DOM), not the inner slot. For
empty wrapping elements this leaves the slot's cache unset, which
would also break $cachedTextSize if such an empty wrapper participates
in a suffix-path oldSuffixLength computation. The audit-fix-up cycle
didn't reach this site.

Suggested fix shape: route all cache reads/writes through
`activeEditorDOMRenderConfig.$getDOMSlot(node, dom, activeEditor).element`
(the inner slot), symmetric with $reconcileChildren's writes. Or have
$createNode for an empty element route the cache write the same way.
A read-time fallback that tries slot.element if keyed DOM has no cache
would also work but is less principled.

Per etrepum's review (5/12): the `__lexicalTextContent` /
`__lexicalFirstTextKey` cache doesn't need to live on the slot element —
it was there only because that's where the original text cache happened
to be written. Moving it to the outer keyed DOM keeps every read and
write on the same DOM (the one in `_keyToDOMMap`), so wrapping elements
(TableNode etc.) get symmetric cache plumbing without any slot dispatch
on the hot path.

Concretely:

- `$cachedTextSize`, `$bubbleChildFirstText` (signature reverted to
  `(childKeyedDom)`), `$createNode`'s empty-element write,
  `$reconcileNode`'s two non-dirty branches, and the two newSuffix
  rebuild loops (`$tryReconcileSuffixWithSizeDelta` and
  `$reconcileChildren`'s sizeDelta=0 suffix splice) all read/write
  directly off the keyed DOM, no helper.
- `$reconcileChildren` and `$createChildren` look up
  `activeEditor._keyToDOMMap.get(<element>.__key)` once at entry into a
  local `cacheDom`. All cache R/W in those functions goes through
  `cacheDom`. DOM operations (insertBefore, replaceChild, etc.) still
  use `slot.element` directly. `$resolveSuffixPathFormat` and
  `$tryReconcileSuffixWithSizeDelta` receive `cacheDom` (was `slot.element`).
- The `$getElementCacheDom` helper from the previous principled fix is
  removed (no slot dispatch needed anywhere).

The principled (slot.element) fix was correct but added a method
dispatch to every clean-child cache read in the general path. Bench
(`editorCycle`, size=1000-5000, jsdom, Node 20.19) showed the general
path was 6-9% slower than baseline. This version lands within ±3% of
baseline on the general path (most within rme); one scenario
(size=5000 remove general) is +17% faster than baseline. Fast-path
numbers are unchanged within noise (one borderline scenario at
size=1000 -4.7%, within combined rme).

AUDIT-4 test from the prior commit still passes. Full unit suite (113
files / 2505 tests) green.

- AUDIT-5: $tryReconcileSuffixWithSizeDelta now takes `slot` and
  `cacheDom` as separate parameters. DOM ops ($reconcileNode /
  $destroyNode) route through slot.element; cache R/W stays on
  cacheDom. Pre-fix, wrapping ElementNode parents (custom nodes with
  a getDOMSlot returning an inner element, TableNode with the
  scrollable wrapper) leaked DOM on the size-delta=-1 destroy path
  because the child's parentNode was the inner slot, not the outer
  keyed DOM.

- Regression test: BlockWrapperElementNode parent across append
  (sizeDelta=+1, K=2) and remove (sizeDelta=-1, K=1) cycles. Without
  the fix, the remove cycle leaves an orphan child under the inner
  slot.

- Gate cleanup (L570 follow-up): drop the redundant `prevElement.__last
  === nextElement.__last` check from the same-size branch. Any
  structural mutation that keeps size constant routes through
  getWritable() on the parent and lands it in _cloneNotNeeded, so the
  cloned-parent check alone is sufficient.

- Invariant tightening: $bubbleChildFirstText distinguishes
  `undefined` (cache missing - invariant violation, now throws) from
  `null` (legitimately no text descendant - silent return). Matches
  the $cachedTextSize throw-on-miss style for the new cache fields
  this PR introduces.

…Suffix uses current map

Resolves the remaining audit-round findings on the children fast-path
work. Three substantive areas:

- Same-size suffix newSuffix builder was reading each reconciled child's
  cached text from `activePrevKeyToDOMMap` (cycle-start snapshot). After
  $updateDOM=true reconciles the snapshot points at the detached old
  DOM whose __lexicalTextContent is from the previous cycle, producing
  a stale parent cache (silently, since the lazy `node.getTextContent()`
  fallback was removed in the round 2 strict-on-miss tightening). Switch
  the read to `activeEditor._keyToDOMMap.get(cur)`, mirroring the size-
  delta helper which already uses the current map. AUDIT-6 pins this.

- All remaining lazy-fallback cache reads are now strict invariants.
  $reconcileNode's two non-dirty branches were already lazy-filling
  __lexicalTextContent but not __lexicalFirstTextKey; with $bubbleChild
  FirstText now strict, the asymmetric fallback was a latent crash hazard
  (textContent set, firstTextKey undefined → invariant fires one line
  later). The three suffix-builder ElementNode reads in the helper, the
  same-size suffix newSuffix builder, and the structurally-clean walk
  now invariant on miss as well. The `?? ''` defensive read after a
  successful $tryReconcileSuffixWithSizeDelta call is also tightened to
  invariant on the helper's post-condition.

- AUDIT-5b reconcile-arm test added (forces $updateDOM=true via a
  RerenderParagraphNode subclass that overrides static clone so the
  writable clone keeps the subclass identity). The assertion is DOM
  identity survival of the non-dirty prefix; pre-fix the recovery path
  rebuilds every DOM. AUDIT-6 covers the same-size newSuffix L1054
  cache-read fix. AUDIT-7 sets up a K=3 contiguous suffix with size
  delta=+1 to exercise the helper's K-check bail; documented honestly
  as an output sentinel since the helper's splice math happens to be
  generic for valid (k, sizeDelta) combinations.

Also drops the redundant `prevElement.__last === nextElement.__last`
clause from the same-size gate (`_cloneNotNeeded` already covers any
mutation that could shift `__last`), with the comment tightened to call
out the contract boundary (mutations bypassing `getWritable` are out of
scope). The L1393 cloned-non-dirty branch is currently unreachable
under `getWritable()`'s dirty-marking semantics; kept as defense in
depth with a comment.

Test names normalized to AUDIT-1 through AUDIT-7 (with intentional 5b).
Shared `BlockWrapperElementNode` hoisted to the top of the suffix-fast-
path describe block so AUDIT-5 and AUDIT-5b reuse one definition.

…w feedback

Per facebook#8482 (comment):
`BlockWrapperElementNode` and the two `RerenderParagraphNode`s (5b /
6) now use `$config()` so lexical provides default implementations
for `static getType` / `static clone` / `static importJSON` /
`exportJSON` instead of hand-rolled boilerplate. `RerenderParagraphNode`
passes `{extends: ParagraphNode}` so the writable clone keeps the
subclass identity (which was the load-bearing detail behind the
manual `static clone` override).

-17 LOC, no behavior change. AUDIT-5 / 5b / 6 + 7 still pin the same
DOM identity / cache / bail invariants.