@symbiote-native/engine 1.3.0 → 1.4.0

package/build/mutation-buffer.js

@@ -1,70 +1,29 @@
-// THE CONTRACT. Native owns the tree; JS emits nothing but a command buffer.
-//
-// This file is the spec and `core/engine/cpp/SymbioteTree.cpp` must agree with it, for the reason a
-// wire format is written as code at all: described in prose it gets reimplemented, written as code
-// it gets exercised.
-//
-// ── WHAT CHANGED, AND WHY IT IS SMALLER THAN IT SOUNDS ───────────────────────────────────────────
-//
-// The adapter used to mutate a JS tree, `commit.ts` walked it to work out what changed, and the
-// batch that crossed carried FABRIC operations — `createNode` / `cloneNode` / `appendChild`. The
-// walk is
-// 2 041 lines because it re-derives a diff.
-//
-// The framework already had that diff. A reconciler's entire job is knowing what changed, and every
-// adapter hands us the answer call by call before we throw it away and recompute it. So the buffer
-// carries the ADAPTER's alphabet instead, and the derivation disappears rather than moving:
-//
-//   the walk over dirty subtrees      gone — the framework names the nodes
-//   desired-vs-committed diffing      gone — the framework names the operations
-//   IMirror                           gone — it was a JS re-implementation of `ShadowNode`, which
-//                                     already carries children and props (ShadowNode.h:133-134),
-//                                     duplicated only because reading it from JS costs a crossing
-//   the parent table, the edit log    gone — native holds parent and children itself
-//   clone-on-write                    STAYS, in C++, along the paths the ops marked
-//
-// ── THE ALPHABET ─────────────────────────────────────────────────────────────────────────────────
-//
-// Nine operations. It is the mutation API `node.ts` already exports, minus the four that were never
-// primitive:
-//
-//   setNodeHidden / setNodePressed    resolve a CSS class to a style IN JS and then call setProp.
-//                                     The class registry stays in JS, so what crosses is the result.
-//   setEventListener /                a listener is a closure and cannot be `folly::dynamic`. It
-//     setBehaviorListener             stays in a JS registry; what crosses is the boolean gate flag
-//                                     (`GATED_EVENT_PROPS`), which is an ordinary setProp.
-//
-// ── WHAT STAYS IN JS, AND IT IS NOT A TREE ───────────────────────────────────────────────────────
-//
-//   the handle per node     a bare `{}` carrying native's node on `NativeState`. No parent, no
-//                           children, no order — an address. Its lifetime IS the node's lifetime,
-//                           which is how `nativeFabricUIManager` and a browser both work.
-//   listeners               Map<handle, Map<name, fn>>. Flat.
-//   the CSS class registry  class -> style, resolved before any op is written. Native never sees a
-//                           class name.
-//   host behaviors          the press / text-input / switch machines. They read props back over
-//                           JSI at GESTURE rate — ~10 reads per touch, not 19 009 per commit.
-//
-// ── WHY PROPS GO NATIVE, WHICH WAS DECIDED THE OTHER WAY FIRST ───────────────────────────────────
-//
-// The first draft of this contract kept prop VALUES in JS and gave native only the structure, on
-// the reasoning that `RawProps` is lazy so handing Fabric a JS object costs nothing. That is wrong.
-// `RawProps` is lazy only until `parse()`, and `ConcreteComponentDescriptor::cloneProps` calls it
-// UNCONDITIONALLY. In `Mode::JSI` the preparse walks every key of every node —
-// `getPropertyNames`, then per key `getValueAtIndex` + `getString` + `utf8()` (a `std::string`
-// allocation) + `getProperty` — and `enableCppPropsIteratorSetter()` defaults to FALSE in 0.86, so
-// that is the live path. `Mode::Dynamic` does the identical work with zero JSI.
-//
-// So a 1 000-row create already pays ~44 001 JSI property reads and as many string allocations
-// INSIDE `createNode`. Props held natively as `folly::dynamic`, built incrementally as `setProp`
-// ops arrive, are cheaper than what ships today, not more expensive.
-/**
- * The opcodes. These numbers ARE the contract: renumbering here without renumbering the C++ commits
- * a different tree, silently, and no test in either language can see across the boundary.
- *
- * Stride is fixed so the ops array is addressable as memory rather than parsed. Operands are either
- * a SLOT (an index into the batch's `handles` array — see below) or an index into a side table.
- */
+// The contract: native owns the tree, JS emits nothing but a command buffer. This file is the
+// spec — core/engine/cpp/SymbioteTree.cpp must agree with it, since a wire format described in
+// prose gets reimplemented, written as code gets exercised.
+// ── what changed, and why it is smaller than it sounds ───────────────────────────────────────────
+// The adapter used to mutate a JS tree that commit.ts walked to re-derive a diff the framework
+// already knew. The buffer now carries the adapter's alphabet directly: the walk, the diffing,
+// and the JS shadow tree (IMirror) all disappear rather than move.
+// ── the alphabet ─────────────────────────────────────────────────────────────────────────────────
+// Nine operations — the mutation API node.ts already exports, minus what was never primitive:
+// setNodeHidden/setNodePressed resolve a CSS class to a style in JS then call setProp; a listener
+// can't be folly::dynamic, so setEventListener crosses only its boolean gate flag as a setProp.
+// ── what stays in JS, and it is not a tree ──────────────────────────────────────────────────────
+// The handle per node: a bare {} carrying native's node on NativeState — no parent/children/order,
+// just an address. Listeners and the CSS class registry stay flat maps; host behaviors read props
+// back over JSI at gesture rate, not commit rate.
+// ── why props go native, decided the other way first ────────────────────────────────────────────
+// Keeping prop values in JS assumed RawProps is lazy so handing Fabric a JS object costs nothing —
+// wrong: ConcreteComponentDescriptor::cloneProps calls parse() unconditionally, and the preparse
+// walks every key of every node through JSI regardless of mode.
+// So a create already pays a JSI property read and a string allocation per prop, per node, inside
+// createNode. Props held natively as folly::dynamic, built incrementally as setProp ops arrive,
+// are cheaper than what shipped before, not more expensive.
+// The opcodes. These numbers ARE the contract: renumbering here without renumbering the C++ side
+// commits a different tree, silently, and no test in either language can see across the boundary.
+// Stride is fixed so the ops array is addressable as memory rather than parsed. Operands are
+// either a slot (an index into the batch's handles array) or an index into a side table.
 export const OP_STRIDE = 6;
 export const OP_CREATE_ELEMENT = 0; // [slot, viewName, isText, tag, instanceHandle]
 export const OP_CREATE_RAW_TEXT = 1; // [slot, text]
@@ -76,107 +35,54 @@ export const OP_SET_PROP = 6; // [slot, key, value] — value = NO_VALUE deletes
 export const OP_SET_TEXT = 7; // [slot, text]
 export const OP_COMMIT = 8; // [rootTag, surface]
 export const OP_SET_COMPONENT = 9; // [slot, viewName]
-/**
- * The INTRINSIC TAG this node came from — `pressable`, not `RCTView`. `[slot, tag]`.
- *
- * Emitted only for a node a host behavior actually attached to, from `attachHostBehavior`, which is
- * where the tag is already in hand and already matched. Every other node pays nothing.
- *
- * WHY THE TAG HAS TO CROSS AT ALL. A tag's platform props are resolved natively now, and the native
- * side keys them off what it knows the node IS. For `<text-input>` the Fabric view name answers
- * that by itself (`RCTSinglelineTextInputView` names nothing else); for `<pressable>` it does not —
- * it commits as `RCTView`, byte-identical to a plain view. The tag is the only fact that separates
- * them, and it is the same fact a browser keys user-agent behavior off.
- */
+// The intrinsic tag this node came from — pressable, not RCTView. [slot, tag]. Emitted only for a
+// node a host behavior actually attached to; every other node pays nothing.
+// Native's platform-prop rules key off what the node IS, and the Fabric view name alone doesn't
+// always answer that — pressable commits as RCTView, byte-identical to a plain view, so the tag
+// is the only fact that separates them.
 export const OP_SET_TAG = 10; // [slot, tag]
-/**
- * An app callback appeared on, or disappeared from, an event name the behavior OWNS.
- * `[slot, name, present]`. See `recordSetOwnedListener` for why the bit crosses and the closure
- * does not.
- */
+// An app callback appeared on, or disappeared from, an event name the behavior owns.
+// [slot, name, present]. See recordSetOwnedListener for why the bit crosses, not the closure.
 export const OP_SET_OWNED_LISTENER = 11; // [slot, name, present]
-/**
- * A behavior's FEEDBACK state flipped — TouchableHighlight's underlay is showing, or stopped.
- * `[slot, shown]`.
- *
- * The second bit to cross for the same reason the first did. `OP_SET_OWNED_LISTENER` carries whether
- * the app wired a handler; this carries whether the control is currently giving feedback, which is
- * the platform's own `:active` in everything but the timing. `setNodePressed`'s header already calls
- * the press state "the engine-owned half of what `:active` is on the web", and this is its twin for
- * the one control whose feedback does NOT track the press exactly: RN holds the underlay past
- * release so a fast tap still flashes (`TouchableHighlight.js:270-293`).
- *
- * THE TIMER STAYS IN JS and that is the boundary, not an omission. WHEN the bit flips is Pressability
- * plus a `delayPressOut` hold, running at gesture rate and calling back into app code
- * (`onShowUnderlay` / `onHideUnderlay`). WHAT a showing underlay looks like — a background colour and
- * a dimmed child, from two props no ViewConfig declares — is the platform's, and it is
- * `foldTouchableHighlightUnderlay` now.
- *
- * A flip is a GESTURE-rate event rather than a per-render one: twice a tap, against a `payloadFold`
- * that was charged on every commit the node was dirty in for the life of the screen.
- */
+// A behavior's feedback state flipped — TouchableHighlight's underlay is showing, or stopped.
+// [slot, shown]. The second bit to cross for the same reason the first did: OP_SET_OWNED_LISTENER
+// carries whether the app wired a handler, this carries whether the control is giving feedback.
+// The timer stays in JS, and that's the boundary, not an omission: WHEN the bit flips is
+// Pressability plus a delayPressOut hold at gesture rate; WHAT a showing underlay looks like is
+// the platform's (foldTouchableHighlightUnderlay).
+// A flip is a gesture-rate event rather than a per-render one — twice a tap, against a payloadFold
+// that used to be charged on every commit the node was dirty in for the life of the screen.
 export const OP_SET_UNDERLAY_SHOWN = 12; // [slot, shown]
-/**
- * A VOID node: commits nothing of its own AND does not hoist its children into Fabric either —
- * unlike an anchor, which hoists. `[slot]`.
- *
- * `InputAccessoryView.js` renders `null` on Android: the whole component, children included,
- * contributes nothing to the host tree. An anchor cannot express that — it exists precisely to hand
- * its children up in its own place — so a node whose entire subtree must vanish from Fabric needs
- * its own kind. Everything else about it (the retained JS tree, `appendChild`, adapter bookkeeping)
- * is unaffected; only the commit walk treats it as contributing zero Fabric nodes, recursively.
- */
+// A void node: commits nothing of its own and does not hoist its children into Fabric either —
+// unlike an anchor, which hoists. [slot]. InputAccessoryView.js renders null on Android, so the
+// whole component (children included) must vanish, which an anchor can't express.
+// Everything else about it (the retained JS tree, appendChild, adapter bookkeeping) is unaffected;
+// only the commit walk treats it as contributing zero Fabric nodes, recursively.
 export const OP_CREATE_VOID = 13; // [slot]
-/**
- * A `setProp` whose value slot is this DELETES the key.
- *
- * `undefined` cannot carry it: `null` is a legitimate Fabric prop value meaning "reset to the
- * default", and the two must stay distinguishable — `cloneNodeWithNewProps` merges, so a removed
- * key has to be sent as an explicit `null` while a key that was never there must not be sent at
- * all. The JS `setProp` already collapses `undefined` to a delete before anything is encoded.
- */
+// A setProp whose value slot is this deletes the key. undefined can't carry it: null is a
+// legitimate Fabric prop value meaning "reset to default", and the two must stay distinguishable
+// since cloneNodeWithNewProps merges — a removed key must be sent as explicit null, never omitted.
 export const NO_VALUE = -1;
-/**
- * A node kind. Native needs it because two of the three never become a Fabric node the same way,
- * and both rules are decided at INSERT or at child-set build — never by a walk:
- *
- *   ELEMENT   an ordinary view. Its Fabric view name is fixed at creation, with ONE exception:
- *             a text element inside another text element commits as `RCTVirtualText` instead of
- *             `RCTText`. Native resolves that when the node acquires a parent, because that is when
- *             it first knows the answer, and re-resolves it on a reparent.
- *   RAW_TEXT  an `RCTRawText` leaf. Skipped from its parent's child set when its text is empty —
- *             an empty one would paint.
- *   ANCHOR    a position marker the frameworks insert (`{#if}`, a fragment, a `{@render}` slot).
- *             It never becomes a Fabric node at all: native keeps it in ITS OWN structure so
- *             `insertBefore(parent, node, anchor)` resolves, and hoists its children into its
- *             parent's child list when building the child set. This is why our own store cannot BE
- *             the Fabric tree — there is no Fabric node to hold an anchor, which is the one thing
- *             `IMirror` was genuinely for.
- *
- * A SURFACE is an anchor too, and that is not a trick: an anchor is a node whose children belong to
- * its parent's list, and a surface is a node whose children belong to the root's child set. Same
- * shape, so `OP_COMMIT` names one and the native side needs no `rootTag -> node` map — which keeps
- * the applier stateless, the property the whole lifetime design rests on.
- */
+// A node kind. Native needs it because two of the three never become a Fabric node the same way,
+// decided at insert or child-set build, never by a walk. ELEMENT is an ordinary view, except a
+// text inside another text commits as RCTVirtualText, resolved when it acquires a parent.
+// RAW_TEXT is an RCTRawText leaf, skipped from its parent's child set when empty. ANCHOR never
+// becomes a Fabric node: native hoists its children into its parent's child set instead, which is
+// why our own store cannot BE the Fabric tree.
+// A surface is an anchor too: its children belong to the root's child set the same way an
+// anchor's belong to its parent's list, so OP_COMMIT names one and native needs no rootTag -> node
+// map — keeping the applier stateless.
 export const KIND_ELEMENT = 0;
 export const KIND_RAW_TEXT = 1;
 export const KIND_ANCHOR = 2;
-// ── THE RECORDER ─────────────────────────────────────────────────────────────────────────────────
-//
-// One buffer per process, drained by `takeBatch()` at commit. Not per surface: a node belongs to
-// exactly one surface, so ops for another surface are inert until that surface commits — the same
-// argument `edit-buffer.ts` made for not threading a surface through every mutation site, and the
-// same conclusion.
-// TYPED FROM THE START, because the alternative is to walk the whole thing once per commit.
-//
-// This was a `number[]` and `takeBatch` ended in `Int32Array.from(ops)`. Measured on a 1 000-row
-// create through the work ledger: **210 042 slots**, every one of them converted element by element
-// through the ITERATOR PROTOCOL on every commit. `new Int32Array(array)` is not the escape — it
-// takes the same path, checked rather than assumed (F-55). The escape is not building an Array.
-//
-// Capacity DOUBLES and is never given back: a commit that needed 210 042 slots once will need them
-// again, and re-growing from a small start would pay the same copies every commit for the memory of
-// a single benchmark row list.
+// ── the recorder ─────────────────────────────────────────────────────────────────────────────────
+// One buffer per process, drained by takeBatch() at commit. Not per surface: a node belongs to
+// exactly one surface, so ops for another surface are inert until that surface commits.
+// Typed from the start, not a number[] converted at drain time — a plain array walks every element
+// through the iterator protocol on every commit, and Int32Array.from takes the same path. The
+// escape is not building an Array at all.
+// Capacity doubles and is never given back: a commit that once needed this many slots will need
+// them again, and re-growing from a small start would pay the same copies every commit.
 const INITIAL_OP_CAPACITY = 1_024;
 let ops = new Int32Array(INITIAL_OP_CAPACITY);
 let opCount = 0;
@@ -187,16 +93,14 @@ let handles = [];
 // Interning matters more here than it looks: a 1 000-row create emits about a dozen distinct view
 // names across 10 000 elements, and every prop KEY is drawn from a set of a few hundred.
 const stringIds = new Map();
-// Which batch the `slot` standing on a handle belongs to. Bumped by `takeBatch`, which is what
-// invalidates every slot at once without walking the handles that hold them.
-//
-// It starts at 1 because a fresh node's `slotBatch` is 0, so an untouched handle can never match a
-// live batch and needs no separate "is it in this batch" flag.
+// Which batch the slot standing on a handle belongs to. Bumped by takeBatch, which invalidates
+// every slot at once without walking the handles that hold them.
+// Starts at 1 because a fresh node's slotBatch is 0, so an untouched handle can never match a live
+// batch and needs no separate "is it in this batch" flag.
 let batchId = 1;
-// The same table for prop VALUES, and the reason it pays is the far side rather than this one: the
-// host turns each entry into a `folly::dynamic` when the op is applied, so a style object reused
-// across a thousand rows was a thousand conversions of one object. Measured on `build-release`,
-// 12 005 `setProp` ops spent 20-29 ms converting inside a 35 ms `applyOps`.
+// The same table for prop values, and it pays off on the far side: the host converts each entry
+// to folly::dynamic when the op is applied, so a style object reused across many rows was many
+// conversions of the same object without it.
 const valueIds = new Map();
 // Booleans skip that table entirely — see `internValue`. Two slots, reset with the batch alongside
 // everything else the tables hold.
@@ -211,31 +115,17 @@ function intern(text) {
     stringIds.set(text, strings.length - 1);
     return strings.length - 1;
 }
-/**
- * The index the ops address this value by — deduplicated when it is worth deduplicating.
- *
- * Objects, functions and strings go through the `Map`: they are the ones that repeat (one
- * `StyleSheet.create` object per screen, `ellipsizeMode: 'tail'` on every text node) and the ones
- * whose conversion costs something.
- *
- * BOOLEANS ARE FOLDED WITHOUT THE MAP, because there are two of them. A dedicated slot each is a
- * branch rather than a hash, so the argument that once excluded them — a lookup costs what the
- * conversion costs — does not reach this shape. And the conversion was never the whole cost:
- * `values` is a JSI array the host reads entry by entry, so a duplicate is a crossing whatever it
- * holds. Measured on the create fixture, three adapters seed `allowFontScaling: true` at
- * `createElement`, which alone wrote one entry per text node on the screen.
- *
- * NUMBERS STAY OUT. They would need the `Map`, whose keys compare by SameValueZero — that folds
- * `-0` into `0` and `NaN` into itself, and a value this cheap to convert is not worth opening the
- * question for.
- *
- * Identity, never structural equality: comparing deeply would make the buffer's cost depend on the
- * size of what it is handed, which is the opposite of the point.
- *
- * Reusing an index is safe against MUTATION of the value between two ops, and not by luck — the host
- * converts at apply time, after the batch has closed, so both ops already saw the object's final
- * state whether they shared an index or not.
- */
+// The index the ops address this value by — deduplicated when it is worth deduplicating. Objects,
+// functions and strings go through the Map: they repeat (one StyleSheet.create object per screen)
+// and their conversion costs something.
+// Booleans are folded without the Map, since there are only two of them — a dedicated slot each is
+// a branch rather than a hash. The conversion was never the whole cost either: values is a JSI
+// array the host reads entry by entry, so a duplicate is a crossing whatever it holds.
+// Numbers stay out: they'd need the Map, whose keys compare by SameValueZero (folding -0 into 0,
+// NaN into itself), and a value this cheap to convert isn't worth opening that question for.
+// Identity, never structural equality — comparing deeply would make the buffer's cost depend on
+// the size of what it's handed. Reusing an index is safe against mutation between two ops since
+// the host converts at apply time, after the batch closes, when both already reflect final state.
 function internValue(value) {
     if (value === true) {
         if (trueId === NOT_INTERNED)
@@ -264,41 +154,22 @@ function pushValue(value) {
     values.push(value);
     return values.length - 1;
 }
-/**
- * The index the ops address this handle by, for the duration of THIS batch.
- *
- * Assigned on first mention rather than at creation, so a batch carries exactly the nodes it names.
- * A handle created by an earlier batch arrives already owning its native node, which is what lets a
- * clone source three commits old resolve with no bookkeeping on either side.
- *
- * THE SLOT LIVES ON THE HANDLE, not in a `Map` keyed by it, and that is a measured decision. This
- * function runs once per handle OPERAND — every `setProp` names its node and every append names
- * two, so a thousand-row create mentions handles about forty thousand times — and a `Map<object,
- * number>` charges a hash for each one, plus a second for the `set` on a miss. Two fields on a shape
- * the node already carries turn that into a compare.
- *
- * Measured on `build-release` by `mutation-api-fill-cost.itest.ts`, both arms in one sitting, three
- * runs each: `createRawText` 0.70 -> 0.51 us, `appendChild` 0.65 -> 0.58, `recordSetProp` 0.34 ->
- * 0.30, and the whole `fill` phase of a 10 001-node create 25.0 -> 23.2 ms. `createElement` barely
- * moved (0.72 -> 0.70), which is the control: it does enough else that one lookup is noise in it.
- *
- * WHY AN EPOCH RATHER THAN CLEARING: a slot is meaningless outside its batch (see `IMutationBatch`),
- * so every slot must die when the batch drains. Walking the handles to reset them would cost exactly
- * what the `Map.clear` cost; bumping one counter invalidates all of them at once, and a handle that
- * is never mentioned again is never touched.
- */
+// The index the ops address this handle by, for the duration of THIS batch. Assigned on first
+// mention rather than at creation, so a batch carries exactly the nodes it names — a handle from
+// an earlier batch arrives already owning its native node.
+// The slot lives on the handle, not in a Map keyed by it, a measured decision: this runs once per
+// handle operand, and a Map<object, number> charges a hash per lookup plus a set on a miss. Two
+// fields on a shape the node already carries turn that into a compare.
+// An epoch rather than clearing: a slot is meaningless outside its batch, so every slot must die
+// on drain. Walking handles to reset them costs what Map.clear costs; bumping one counter
+// invalidates all of them at once, and an unmentioned handle is never touched.
 function slotOf(handle) {
-    // The retained tree used to ABSORB a handle that was not a node: `children.indexOf(x)` returned
-    // -1 and the mutation was a silent no-op. A buffer cannot — the op is recorded, and the failure
-    // surfaces in the HOST, on a later op, in another batch, as a node whose create it appears never
-    // to have seen. Both of the real cases found this way were framework spellings the old tree had
-    // been swallowing for months: solid-js passing `null` as "insert at the end", and Angular asking
-    // to remove the SURFACE at teardown.
-    //
-    // Deliberately only "an object", not "one of OUR nodes": a handle is an identity to this file and
-    // nothing more, and the applier's own fixtures address bare `{}`. The wrong-KIND-of-object case
-    // (Angular handing over a `SymbioteSurface` at teardown) is caught one layer on, where the host
-    // fails to resolve it and can name the opcode.
+    // A buffer cannot silently absorb a handle that isn't a node the way the old retained tree did
+    // (children.indexOf(x) === -1, no-op) — the op is recorded, and the failure surfaces in the
+    // host, on a later op, as a node whose create it never saw.
+    // Deliberately only "an object", not "one of our nodes": a handle is an identity to this file and
+    // nothing more. The wrong-kind-of-object case is caught one layer on, where the host fails to
+    // resolve it and can name the opcode.
     if (typeof handle !== 'object' || handle === null) {
         throw new Error(`symbiote engine: a mutation named ${String(handle)}, which is not a node. An adapter is ` +
             `passing a framework sentinel straight through — an absent insert anchor is spelled by ` +
@@ -311,18 +182,13 @@ function slotOf(handle) {
     handle.slotBatch = batchId;
     return handle.slot;
 }
-// Has anything changed the TREE since the last commit drained?
-//
-// NOT the same question as `hasPendingOps()`, and the difference is the whole reason this exists:
-// every structural READ calls `flushOps`, so a reconciler that navigates the tree it is building
-// empties the buffer many times between commits. `hasPendingOps()` then answers "no" for a surface
-// with a screen's worth of unpublished work. This survives the drain and is cleared only by a
-// commit, which is what "is there anything to publish" actually means.
-//
-// `OP_COMMIT` is excluded deliberately: recording a commit is not a change to the tree, and counting
+// Has anything changed the tree since the last commit drained? Not the same question as
+// hasPendingOps(): every structural read calls flushOps, which empties the buffer many times
+// between commits, so hasPendingOps() alone would answer "no" for unpublished work.
+// OP_COMMIT is excluded deliberately: recording a commit is not a change to the tree, and counting
 // it would make every commit look like it had work.
 let changedSinceCommit = false;
-function push(op, a = 0, b = 0, c = 0, d = 0, e = 0) {
+function push(op, a = 0, b = 0, c = 0) {
     if (op !== OP_COMMIT)
         changedSinceCommit = true;
     if (opCount + OP_STRIDE > ops.length) {
@@ -334,68 +200,73 @@ function push(op, a = 0, b = 0, c = 0, d = 0, e = 0) {
     ops[opCount + 1] = a;
     ops[opCount + 2] = b;
     ops[opCount + 3] = c;
-    ops[opCount + 4] = d;
-    ops[opCount + 5] = e;
+    ops[opCount + 4] = 0;
+    ops[opCount + 5] = 0;
     opCount += OP_STRIDE;
 }
-/** Whether a commit would publish anything. See `changedSinceCommit`. */
+// `OP_CREATE_ELEMENT` is the only op with a FOURTH operand, and it writes it itself rather than
+// widening `push` for one call site. A rest parameter or an options bag would allocate per op,
+// which is the one thing this buffer exists to avoid
+function pushFourth(value) {
+    ops[opCount - OP_STRIDE + 4] = value;
+}
+// Whether a commit would publish anything. See changedSinceCommit.
 export function hasChangedSinceCommit() {
     return changedSinceCommit;
 }
-/**
- * Called by `commitSurfaceOps` once it has drained. Separate from `takeBatch` because a READ drains
- * too, and a read is not a commit — clearing there would make the next commit believe its work had
- * already been published.
- */
+// Called by commitSurfaceOps once it has drained. Separate from takeBatch because a read drains
+// too, and a read is not a commit — clearing there would make the next commit believe its work had
+// already been published.
 export function noteCommitDrained() {
     changedSinceCommit = false;
 }
-/**
- * The one dirtying route that writes no op: a behavior with a DERIVED payload asks the host to
- * rebuild a node the buffer never named. Without this the commit that follows would look idle and
- * be skipped, and the derived payload would sit unpublished until something unrelated changed.
- */
+// The one dirtying route that writes no op: a behavior with a derived payload asks the host to
+// rebuild a node the buffer never named. Without this the commit that follows would look idle and
+// be skipped, and the derived payload would sit unpublished until something unrelated changed.
 export function noteHostSideChange() {
     changedSinceCommit = true;
 }
-// Nodes whose PLACEMENT this batch has not published yet — created, or named as the child of a
-// structural op.
-//
-// It exists so a read does not have to drain. `parentOf` is unconditional otherwise, and Angular's
-// 1 000-row create measured 1 002 drains for 1 000 reads of which ONE asked about a node the pending
-// batch had touched (`adapters/angular/src/read-fragmentation.probe.test.ts`).
-//
-// THE CLAIM THAT MAKES IT SOUND: a node's parent link changes only through an op that names that
-// node AS THE CHILD. `before` on an insert is a position reference and moves nothing; a parent
-// argument moves the parent's list, not the parent's own link. So a handle absent from here has the
-// same parent in the host as it has here.
-//
-// Creation is in it because the host cannot answer about a node it has never been told exists, which
-// is the other half — and the half a "was it re-parented" set alone would get wrong.
-//
-// NOT A TREE, and that is the line this has to stay on the right side of (`node.ts:2` — no parent,
-// no children, no mirror). It answers about the BUFFER: is this node's placement unpublished. It is
-// emptied by `takeBatch`, so it never outlives one batch and can never disagree with the host.
+// Nodes whose placement this batch has not published yet — created, or named as the child of a
+// structural op. Exists so a read doesn't have to drain: parentOf is unconditional otherwise, and
+// most reads never touch a node the pending batch has.
+// Sound because a node's parent link changes only through an op that names that node as the child
+// — `before` on an insert is a position reference and moves nothing, so a handle absent from here
+// has the same parent in the host as it has here.
+// Creation is in it too, since the host can't answer about a node it's never been told exists — the
+// half a "was it re-parented" set alone would get wrong.
+// Not a tree: it answers about the buffer, whether this node's placement is unpublished. Emptied
+// by takeBatch, so it never outlives one batch and can never disagree with the host.
 let placementPending = new Set();
 /** Does the pending batch hold anything that could change what the host says this node's parent is? */
 export function hasPendingPlacement(handle) {
     return placementPending.has(handle);
 }
+// A field rather than a second Set, т.к. this is read on the create path and a `Set.add` per node
+// would charge the thing it saves. `createdBatch` starts at 0, which no live batch carries
+function noteCreated(handle) {
+    placementPending.add(handle);
+    handle.createdBatch = batchId;
+}
+/** Has the host never heard of this node, т.к. the op that creates it is still in the buffer? */
+export function isPendingCreate(handle) {
+    return handle.createdBatch === batchId;
+}
 export function recordCreateElement(handle, viewName, isText, instanceHandle) {
     instanceHandles.push(instanceHandle);
-    placementPending.add(handle);
-    push(OP_CREATE_ELEMENT, slotOf(handle), intern(viewName), isText ? 1 : 0, instanceHandles.length - 1);
+    noteCreated(handle);
+    push(OP_CREATE_ELEMENT, slotOf(handle), intern(viewName), isText ? 1 : 0);
+    pushFourth(instanceHandles.length - 1);
 }
 export function recordCreateRawText(handle, text) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_RAW_TEXT, slotOf(handle), intern(text));
 }
 export function recordCreateAnchor(handle) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_ANCHOR, slotOf(handle));
 }
 export function recordCreateVoid(handle) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_VOID, slotOf(handle));
 }
 export function recordAppendChild(parent, child) {
@@ -421,42 +292,24 @@ export function recordSetProp(handle, key, value) {
 export function recordSetText(handle, text) {
     push(OP_SET_TEXT, slotOf(handle), intern(text));
 }
-/**
- * Change a node's Fabric view name after creation.
- *
- * It exists for exactly one thing and would not otherwise: `TextInput`'s `multiline` decides between
- * `RCTSinglelineTextInputView` and `RCTMultilineTextInputView`, and an app can flip it. No prop write
- * moves a node between native views, so the host has to RE-CREATE the node under the new name and
- * re-parent its children — which is the same path a reparent already takes, and why this needs no
- * new machinery on the far side beyond honouring the name.
- *
- * A JS-only workaround was the alternative and it is the one thing this design rules out: to know
- * what to rebuild, JS would have to hold the tree.
- */
+// Change a node's Fabric view name after creation. Exists for one thing: TextInput's multiline
+// decides between RCTSinglelineTextInputView and RCTMultilineTextInputView, and an app can flip it.
+// No prop write moves a node between native views, so the host re-creates it under the new name
+// and re-parents its children. A JS-only workaround would need JS to hold the tree — the one thing
+// this design rules out.
 export function recordSetComponent(handle, viewName) {
     push(OP_SET_COMPONENT, slotOf(handle), intern(viewName));
 }
 export function recordSetTag(handle, tag) {
     push(OP_SET_TAG, slotOf(handle), intern(tag));
 }
-/**
- * Whether an app callback is currently wired to an event name the BEHAVIOR owns. `[slot, name,
- * present]`, `present` being 1 or 0.
- *
- * The EXISTENCE, never the function. A name a behavior owns is diverted into a JS stash by
- * `setEventListener` and never becomes a prop, so the payload builder sees no trace of it — and
- * `focusable` on a touchable is `focusable !== false && onPress !== undefined && !disabled`
- * (`TouchableOpacity.js:336-339`), two props and one thing only JS knew. This is the one bit that
- * closes that gap.
- *
- * The browser is the argument rather than convenience: a UA computes focusability itself and CAN,
- * because `addEventListener` is its own API — it knows which elements carry a click handler, while
- * the handler's body stays the application's. Same split.
- *
- * Emitted on a FLIP only, from `setEventListener`, which already refuses to notify on listener
- * identity because a framework hands a fresh closure nearly every render. So this is a mount-time
- * op, not a per-render one — against the per-commit fold it replaces.
- */
+// Whether an app callback is currently wired to an event name the behavior owns. [slot, name,
+// present]. The existence, never the function — a name a behavior owns is diverted into a JS
+// stash and never becomes a prop, so native needs this bit to compute focusable itself.
+// The browser is the precedent: a UA computes focusability itself because addEventListener is its
+// own API, so it knows which elements carry a handler while the handler's body stays the app's.
+// Emitted on a flip only, from setEventListener, which already ignores listener identity since a
+// framework hands a fresh closure nearly every render — a mount-time op, not a per-render one.
 export function recordSetOwnedListener(handle, name, isPresent) {
     push(OP_SET_OWNED_LISTENER, slotOf(handle), intern(name), isPresent ? 1 : 0);
 }
@@ -471,18 +324,11 @@ export function recordCommit(rootTag, surface) {
 export function hasPendingOps() {
     return opCount > 0;
 }
-/**
- * Drain the buffer.
- *
- * Fresh arrays rather than reused ones: the batch outlives this call on the native path (`applyOps`
- * reads `handles` while attaching state), and a recycled array would be mutated under it by the next
- * mutation the adapter makes.
- *
- * `slice` for the ops and not `subarray` for exactly that reason — a subarray would share the
- * backing store the very next `push` writes into. It is a typed-array copy rather than the
- * element-by-element iterator walk this used to be, and the ops buffer itself is KEPT so its
- * capacity survives the drain.
- */
+// Drain the buffer. Fresh arrays rather than reused ones: the batch outlives this call on the
+// native path (applyOps reads handles while attaching state), and a recycled array would be
+// mutated under it by the next mutation the adapter makes.
+// slice for the ops, not subarray, for the same reason — subarray would share the backing store
+// the very next push writes into. The ops buffer itself is kept so its capacity survives the drain.
 export function takeBatch() {
     const batch = {
         ops: ops.slice(0, opCount),