…ent-moved elements

The children fast path's `$cachedTextSize` read an ElementNode's previous text
size from its keyed `dom.__lexicalTextContent`. That DOM node is shared between
the previous and next `keyToDOMMap`s and is mutated in place during
reconciliation. When an inline element moves to a different parent and is
reconciled (growing) under its new parent before its old parent's suffix walk
runs, the old parent read the new, larger size as if it were the previous size
and sliced too much off its cached text. The DOM stayed correct, but
`RootNode.__cachedText` (which backs `getTextContent()`) silently desynced.

Recover the previous-cycle size from the previous node map for an element whose
next-state parent differs from its previous-state parent. This is in the same
family as the full-reconcile hazard fixed in facebook#8564.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01HYqH94pEhCRhymfZsY2J6e

…tate

`editor.read()` flushes pending updates before reading, so it can observe a
different state than the `getRootElement().innerHTML` / `getEditorState().toJSON()`
snapshots it is compared against. Read `getTextContent()` from the same
`getEditorState()` snapshot so all three observations are consistent.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01HYqH94pEhCRhymfZsY2J6e

…ion test

The deterministic regression test built a known structure, so guarding the
move with `if ($isElementNode(...))` would let the test pass vacuously (the
move silently skipped) if that structure ever changed. Use `invariant` so the
test fails loudly instead.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01HYqH94pEhCRhymfZsY2J6e

…tate

The de-optimized cross-parent path previously hand-walked the prev node map and
called `isInline()` on previous-state child instances. For custom nodes whose
`isInline()` routes through `getLatest()`, that resolves against the next state
and throws once a child has been detached — the same hazard fixed in facebook#8548. It
also leaned on the per-instance leaf size cache, which a child changed during
the move can invalidate.

Instead, read the previous size via `prevEditorState.read(() =>
node.getTextContentSize())`. Inside that read `getChildren()` / `isInline()`
resolve against the previous tree, so we neither touch the forward-mutated DOM
cache nor hit the getLatest -> next-state trap, and the size is recomputed from
the prev tree rather than from leaf caches. `ElementNode.getTextContentSize()`
uses the same double-line-break rule as the reconciler cache, so the value
matches `__lexicalTextContent.length`.

Bump the cross-parent differential fuzzer back to a seed range that includes a
case exercising this path.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01HYqH94pEhCRhymfZsY2J6e

The known-problematic cross-parent move is covered deterministically by
FastPathCrossParentTextCache; the differential fuzzer should exist to surface
NEW divergences, not be tuned to regenerate that specific case. Revert its
seed count to a general-coverage value.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01HYqH94pEhCRhymfZsY2J6e

Computing a cross-parent-moved element's previous text size inside
`prevEditorState.read(() => node.getTextContentSize())` fixes that element's
own size, but the surrounding `oldSuffixLength` walk has a second `isInline()`
call — the one deciding the double line break BETWEEN suffix siblings — that
still runs on a previous-state node reference outside any read. That call
cannot throw (a removed sibling is always the last of the suffix, where
`isInline()` is skipped), but when a non-last suffix element's `isInline()` is
state-dependent (routes through `getLatest()`) and flips between the previous
and next states, the walk reads the next-state value, computes the wrong
double-line-break length, and silently desyncs `RootNode.__cachedText`.

Move the whole walk into a single `activePrevEditorState.read(...)`
(`$prevSuffixTextSize`) so every node method — the moved-element
`getTextContentSize()` and the inter-sibling `isInline()` — resolves against
the previous node map. Non-moved elements and leaves still read their O(1)
caches, so an untouched suffix child is not re-walked.

Adds a regression test: flipping a non-last suffix element block<->inline in a
size-0 reconcile must keep `getTextContent()` (backed by the cache) equal to a
fresh tree walk.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01VkVms36ysWg3qxKeUeQPg8

The per-child size helper (`$cachedTextSize`) had a read-context precondition:
its moved-element branch resolves `getTextContentSize()` against the active
editor state, which is only correct while the caller has swapped in the
previous state via `activePrevEditorState.read`. Documented and single-caller
today, but a future caller added outside the read would silently resolve
against the next state. Inline the logic into `$prevSuffixTextSize` so it
physically cannot be called outside the read.

While inlining, replace the unreachable `prevNode === undefined` early `break`
(which would proceed with a partial suffix length) with an `invariant`: callers
validate every suffix key is present in the previous node map, so a miss is a
broken upstream invariant — fail loudly (the reconciler catch recovers via a
full reconcile) rather than splice a wrong length. Consistent with the other
cache-miss invariants in the same walk.

No behavior change on any reachable path; the cross-parent move and the
inter-sibling `isInline()` desync regression tests still pass.

Co-authored-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01VkVms36ysWg3qxKeUeQPg8