@symbiote-native/engine 0.4.0 → 1.0.0

package/build/node.js

@@ -1,22 +1,35 @@
-// The retained shadow-tree. Adapters mutate this cheap in-memory tree through a
-// tiny API; the commit engine (commit.ts) later walks it and translates the
-// whole thing into Fabric's clone-on-write child sets. Keeping the retained
-// tree mutable while the Fabric mirror stays persistent lets every adapter mutate
-// freely without touching Fabric's clone-on-write protocol directly, and it
-// lives here in shared so no adapter re-implements it.
-import { isAriaAliasKey } from './accessibility-props.js';
+// The mutation API. Adapters call it; every call appends an OPCODE to `mutation-buffer.ts` and
+// nothing else. There is no tree here — no parent, no children, no props, no mirror. Turning the
+// buffer into a tree is the HOST's job (`tree-host.ts`): native on device, the TypeScript applier in
+// `@symbiote-native/test-utils` headlessly.
+//
+// What a node still legitimately owns is what the framework, not Fabric, put on it: the Fabric view
+// name it was created as, whether it is a text container, its JS listener map, the declarative
+// class/style halves the engine merges, and the two bookkeeping flags. An ADDRESS plus the state
+// that never crosses.
+import { recordAppendChild, recordCreateAnchor, recordCreateVoid, noteHostSideChange, recordCreateElement, recordCreateRawText, recordInsertBefore, recordRemoveChild, recordSetComponent, recordSetOwnedListener, recordSetUnderlayShown, recordSetProp, recordSetText, } from './mutation-buffer.js';
 import { isEventFor } from './view-config.js';
-import { canonicalClassName, isClassNameValue, resolveActiveClassName, resolveClassName, } from './style-registry/index.js';
-import { dlog } from './debug.js';
-import { attachHostBehavior, hasHostBehaviors, markDetachCandidate, ownsListener, reattachHostBehaviors, stashAppListener, } from './host-behavior.js';
-// A cycle, deliberately: commit.ts imports this module for the node shape, and the imperative
-// methods below call back into it. Neither side touches the other at module-evaluation time -
-// only inside a function body - so every loader (tsc, vitest, Metro) resolves it fine. The
-// alternative was a load-time `SymbioteNode.prototype.measure = ...` installed from elsewhere,
-// which is exactly the registration-side-effect shape Metro's inlineRequires silently drops in
-// release builds (see CLAUDE.md, "Never make correctness depend on a module's load-time side
-// effect").
-import { measure as engineMeasure, measureInWindow as engineMeasureInWindow, measureLayout as engineMeasureLayout, setNativeProps as engineSetNativeProps, dispatchViewCommand, } from './commit.js';
+import { canonicalClassName, EMPTY_STYLE, isClassNameValue, resolveActiveClassName, resolveClassName, } from './style-registry/index.js';
+import { dlog, isDebug } from './debug.js';
+import { appListenerFor, attachHostBehavior, claimModeFor, hasAttachedBehaviors, hasHostBehaviors, markDetachCandidate, notifyChildInserted, notifyOwnedListenerChange, noteCommitHookNodeChanged, ownsListener, reattachHostBehaviors, derivedNodesOf, slotDerivesFrom, slotPropNameFor, slotTakesChildren, stashAppListener, } from './host-behavior.js';
+import { configPayloadFold } from './registry.js';
+import { resolveStructuredStyle } from './structured-style.js';
+import { IMAGE_SOURCE_PROPS, IMAGE_LOAD_EVENT_NAMES, anyImageLoadEventListenerWired, resolveImageSourceProp, } from './image-source-write.js';
+// A cycle, deliberately: `imperative.ts` imports this module for the node shape, and the prototype
+// methods below call back into it. Neither side touches the other at module-evaluation time - only
+// inside a function body - so every loader (tsc, vitest, Metro) resolves it fine. The alternative
+// was a load-time `SymbioteNode.prototype.measure = ...` installed from elsewhere, which is exactly
+// the registration-side-effect shape Metro's inlineRequires silently drops in release builds (see
+// CLAUDE.md, "Never make correctness depend on a module's load-time side effect").
+import { measure as engineMeasure, measureInWindow as engineMeasureInWindow, measureLayout as engineMeasureLayout, setNativeProps as engineSetNativeProps, dispatchViewCommand, } from './imperative.js';
+// The same deliberate cycle, for the same reason: `tree-host.ts` imports `takePropStats` from here
+// and `censusRetainedTree` below asks it for the census. Function bodies only, on both sides.
+import { EMPTY_CENSUS, flushOps, treeHost, } from './tree-host.js';
+// The same deliberate cycle, for the same reason: `routeProp` resolves an AnimatedNode written
+// into a prop, and the module that owns that resolution reaches back here for `setProp`. See
+// `animated/host-binding.ts`'s header.
+import { hasAnimatedNodes } from './animated/graph.js';
+import { bindAnimatedEvent, bindAnimatedValue, hasAnimatedBindings, reattachAnimatedProps, } from './animated/host-binding.js';
 const BRAND = Symbol('symbiote.node');
 // A node carries the Fabric view name directly, so adding a primitive (Image,
 // ScrollView, TextInput) is just a new string from the adapter, no core change.
@@ -37,6 +50,10 @@ export function isSymbioteEvent(value) {
 }
 const FOCUS_COMMAND = 'focus';
 const BLUR_COMMAND = 'blur';
+// Names and arg order mirror RN's ScrollViewCommands.
+const SCROLL_TO_COMMAND = 'scrollTo';
+const SCROLL_TO_END_COMMAND = 'scrollToEnd';
+const FLASH_SCROLL_INDICATORS_COMMAND = 'flashScrollIndicators';
 // The one shape every retained node has. A class, not an object literal, for two reasons: the six
 // imperative methods live on the shared prototype instead of being allocated per node (see
 // ISymbioteNode above), and both factories below mint the same hidden class.
@@ -46,35 +63,36 @@ const BLUR_COMMAND = 'blur';
 // constructor assignment is the shape every engine (V8 and Hermes both) handles without a
 // define-per-field.
 class SymbioteNode {
-    constructor(component, isText, props) {
+    constructor(component, isText) {
         this[BRAND] = true;
         this.component = component;
         this.isText = isText;
-        this.props = props;
         this.listeners = undefined;
-        this.children = [];
-        this.parent = undefined;
-        // A node that has never committed must never take a fast path built on "the mirror already
-        // agrees with me", so all three flags start raised - including for createRawText, whose props
-        // are assigned here rather than through setText.
-        this.dirty = true;
-        this.propsDirty = true;
         // Assigned here, not lazily on first use: every slot present from the constructor keeps one
-        // hidden class for every node. Adding it on demand buys a shape transition per aria-bearing
-        // node, which is the opposite of what this field is for.
+        // hidden class for every node. Adding one on demand buys a shape transition per node that needs
+        // it, which is the opposite of what these fields are for.
         //
-        // Starts false, and that is COMPLETE rather than optimistic: the only two constructions are
-        // `createElement`'s `{}` and `createRawText`'s `{ text }`, so no aria key can arrive here. It
-        // was first written as `hasAriaAliases(props)` — a probe that reads as a safeguard and can
-        // never fire, which the break-test caught by staying green with it removed. If a construction
-        // path is ever added that passes real props, this line owes that probe back.
-        this.hasAriaAlias = false;
-        this.structureDirty = true;
-        this.committed = undefined;
+        // `attachHostBehavior` raises this a few lines later for the rare node whose behavior declares
+        // the recurring hook.
+        this.hasCommitHook = false;
+        // Same again; `attachHostBehavior` raises it for the one behavior that declares it, Image's.
+        this.resolvesImageSources = false;
+        // Same again; `attachHostBehavior` raises it for the one behavior that declares it,
+        // TouchableWithoutFeedback's.
+        this.nativeIdWinsOverId = false;
         this.styleParts = undefined;
         // Assigned here for the same hidden-class reason as `hasAriaAlias` above; `attachHostBehavior`
         // overwrites it a few lines later for the rare node that has a behavior.
         this.payloadFold = undefined;
+        // Same reason again, and here it is load-bearing rather than tidy: the redirect below is read
+        // on every append, so the slot must be a stable slot on one hidden class, not a property added
+        // to a few nodes after the fact.
+        this.childHost = undefined;
+        this.wrapper = undefined;
+        // Same hidden-class reason as the two above, and here it is the whole point: the fast path it
+        // guards is read on every `childrenOf`, so it must be a stable slot rather than a property that
+        // appears on some nodes later.
+        this.mayHaveChildren = false;
     }
     measure(callback) {
         engineMeasure(this, callback);
@@ -98,53 +116,113 @@ class SymbioteNode {
     blur() {
         dispatchViewCommand(this, BLUR_COMMAND, []);
     }
+    // The defaults live HERE and nowhere else. `buildScrollViewHandle`
+    // (`@symbiote-native/components`) delegates here, so a built handle and a node cannot drift on
+    // what `scrollTo()` with no argument means.
+    scrollTo(options) {
+        const x = options?.x ?? 0;
+        const y = options?.y ?? 0;
+        const animated = options?.animated ?? true;
+        dlog(`ScrollView.scrollTo x=${x} y=${y} animated=${animated}`);
+        dispatchViewCommand(this, SCROLL_TO_COMMAND, [x, y, animated]);
+    }
+    scrollToEnd(options) {
+        const animated = options?.animated ?? true;
+        dlog(`ScrollView.scrollToEnd animated=${animated}`);
+        dispatchViewCommand(this, SCROLL_TO_END_COMMAND, [animated]);
+    }
+    flashScrollIndicators() {
+        dlog('ScrollView.flashScrollIndicators');
+        dispatchViewCommand(this, FLASH_SCROLL_INDICATORS_COMMAND, []);
+    }
 }
+// The committed record — handle, tag, rootTag — is the host's to keep, and `committedRecordOf`
+// (tree-host.ts) is how the imperative APIs ask for it. `IMirror` and `IContribution` were the JS
+// re-implementations of `ShadowNode` and of the one thing `ShadowNode` cannot hold, an anchor. Both
+// are gone with the tree; the host answers about both.
+//
+// The identity check `committedOf` used to make is gone with them, and it was worth something: a Vue
+// `reactive()` / deep-`ref()` Proxy around a host element forwards a field read to its target, so a
+// wrapped node used to hand back a real record. It cannot now — the host keys on the handle OBJECT,
+// so a Proxy misses and every imperative call degrades to its "node not committed" log, which is
+// the WeakMap's old behaviour restored. Hold host nodes with `shallowRef` (vue-adapter-reactivity).
 /**
- * The committed record for `node`, or `undefined` if it has never been committed - or if `node` is
- * not the raw retained node at all.
- *
- * That second case is the reason this is a function rather than a bare `node.committed` read. The
- * engine identifies a node BY IDENTITY, and the classic way to break that is to hand the engine a
- * wrapper instead of the node: a Vue `reactive()`/deep-`ref()` Proxy around a host element is the
- * one that actually happens (see the vue-adapter-reactivity skill; `shallowRef` is the fix).
- *
- * The old WeakMap caught this for free - a Proxy is a different object, so `mirror.get(proxy)` missed
- * and every imperative API bailed with a clear "node not committed". A plain property read does NOT:
- * a Proxy forwards `proxy.committed` straight to the target and hands back a real record, whose
- * `handle` Vue would then deep-wrap on the way out. That handle is a JSI host object; a Proxy around
- * it reaches `cloneNodeWithNewProps` and fails somewhere deep in native, far from the cause.
- *
- * So the identity check that was implicit in the WeakMap is explicit here: a record written on the
- * raw node names it, and `record.owner !== node` means whatever we were handed is not that node.
- * One reference comparison, and the wrap now fails LOUDER than it used to rather than quieter.
+ * Mint an element and record its creation.
+ *
+ * The node object IS the handle: it is what the ops address, what the host attaches its native node
+ * to, and what Fabric hands back as an event target. Nothing else is allocated.
  */
-export function committedOf(node) {
-    const record = node.committed;
-    if (record === undefined)
-        return undefined;
-    if (record.owner !== node) {
-        dlog(`node identity mismatch: committed record belongs to node=${debugNodeId(record.owner)}, ` +
-            `not to the object handed in. A wrapped/proxied node (Vue reactive() or deep ref() around ` +
-            `a host element) is the usual cause - hold host nodes with shallowRef.`);
-        return undefined;
-    }
-    return record;
-}
 export function createElement(component, isText = false, 
 // The intrinsic tag this node came from, when it differs from the Fabric view name above. The
 // behavior registry is keyed by tag and the node only ever carries the resolved name, so an
-// adapter lowering `<Pressable>` has to hand the tag over here or the registration cannot fire
+// adapter creating a `<pressable>` has to hand the tag over here or the registration cannot fire
 // (host-behavior.ts, `attached`). Nothing is stored — the lookup happens once, right below.
 tag = component) {
-    const node = new SymbioteNode(component, isText, {});
+    const node = new SymbioteNode(component, isText);
+    // A primitive that commits NO VIEW resolves to the anchor component through `descriptorFor`
+    // (`touchable-without-feedback`, `touchable-native-feedback`), and reaches this function rather
+    // than `createAnchor` because the caller only knows it has a descriptor. The kind is an OPCODE
+    // now, not a name the commit walk reads, so the name alone would give the host an ordinary
+    // element called `#anchor` — one that really paints.
+    if (component === ANCHOR_COMPONENT)
+        recordCreateAnchor(node);
+    // A primitive whose ENTIRE subtree must vanish on this platform (`input-accessory-view` on
+    // Android, `InputAccessoryView.js`'s `return null`) resolves to the void component the same way —
+    // through `descriptorFor`'s per-platform component-name table, never a per-call branch here. An
+    // anchor hoists its children into Fabric in its place; a void node contributes neither itself nor
+    // them.
+    else if (component === VOID_COMPONENT)
+        recordCreateVoid(node);
+    // `instanceHandle` is the node itself: it round-trips through Fabric unchanged and comes back as
+    // the event target, and the BRAND below is how the event handler confirms it is one of ours.
+    else
+        recordCreateElement(node, component, isText, node);
     // Gated on the boolean, not on the Map: this runs ~9 000 times per benchmark create, and an app
     // that registers nothing must pay one boolean read rather than a hash lookup per node.
     if (hasHostBehaviors())
         attachHostBehavior(node, tag);
+    // A third-party view's own ViewConfig processors, as a fold. AFTER the behavior's, because that
+    // is the order the reference ran them in — the behavior rewrites the wrapper-body props, and
+    // `validAttributes[*].process` then converts what it produced. Composed rather than replaced:
+    // one component can legitimately have both.
+    //
+    // Costs a `Set.has` per node for a built-in, which is where `resolve` bails, and nothing else:
+    // the answer is cached per component name, not computed per node.
+    const configFold = configPayloadFold(component);
+    if (configFold !== undefined) {
+        const behaviorFold = node.payloadFold;
+        node.payloadFold =
+            behaviorFold === undefined
+                ? configFold
+                : props => configFold(behaviorFold(props));
+    }
     return node;
 }
-export function createRawText(text) {
-    return new SymbioteNode(RAW_TEXT_COMPONENT, false, { text });
+/**
+ * `tag` mirrors `createElement`'s, and a raw text needs it for the same reason an element does: the
+ * behavior registry is keyed by tag, so a node that does not hand one over cannot have a rule.
+ *
+ * A raw text carrying a tag looks odd and is not. It has no props an app can write — its whole
+ * payload is `text` — but its CONTENT can still be a function of the platform rather than of the
+ * app: Button renders its title uppercased on Android (`Button.js:352-353`), which is a user-agent
+ * decision about a control, not anything the app asked for. That rule needs the node to be
+ * identifiable, and a tag is how this codebase identifies one.
+ *
+ * Defaulted to the raw-text component, so every existing caller is unchanged and pays the same
+ * lookup miss `createElement` already pays for a node nobody registered.
+ */
+export function createRawText(text, tag = RAW_TEXT_COMPONENT) {
+    const node = new SymbioteNode(RAW_TEXT_COMPONENT, false);
+    recordCreateRawText(node, text);
+    // The TAG check comes first, and it is not the same guard `createElement` uses. There it asks
+    // `hasHostBehaviors()` because every element legitimately might have a behavior. Here almost none
+    // do — a raw text is the leaf under every `<Text>` on a screen, thousands of them, and exactly one
+    // kind is tagged. So an untagged raw text must pay a reference comparison against the default and
+    // not a registry lookup: `tag` is the same string literal in that case, so the compare is pointer
+    // equality and the intern, the op and the miss are all skipped.
+    if (tag !== RAW_TEXT_COMPONENT && hasHostBehaviors())
+        attachHostBehavior(node, tag);
+    return node;
 }
 // `instanceHandle` round-trips through Fabric unchanged: the object we pass to
 // createNode comes back as the event target. We brand our nodes so the event
@@ -174,165 +252,279 @@ export function debugNodeId(node) {
 // not a new field, so the hot SymbioteNode shape is untouched.
 export const ANCHOR_COMPONENT = '#anchor';
 export function createAnchor() {
-    return createElement(ANCHOR_COMPONENT);
+    const node = new SymbioteNode(ANCHOR_COMPONENT, false);
+    recordCreateAnchor(node);
+    return node;
+}
+// The sentinel a primitive resolves to when its ENTIRE subtree must vanish from Fabric on this
+// platform — `input-accessory-view` on Android, mirroring `InputAccessoryView.js`'s `return null`.
+// Unlike `ANCHOR_COMPONENT`, whose node hoists its children up in its own place, a void node's
+// children never reach Fabric either: the commit walk stops at it, recursively.
+export const VOID_COMPONENT = '#void';
+export function createVoid() {
+    const node = new SymbioteNode(VOID_COMPONENT, false);
+    recordCreateVoid(node);
+    return node;
+}
+/**
+ * The sentinel a SURFACE's own root node carries, so `parentOf` can stop there.
+ *
+ * A top-level node must answer `undefined` for its parent, and adapters depend on the exact miss:
+ * Angular reads `null` as "defer, `<ng-content>` will place this" (answering the surface once
+ * mounted every FlatList cell at top level), while Vue and Solid spell `?? surface` at their call
+ * sites and would be handed an object that is not the `SymbioteSurface` they compare against. One
+ * component name, read in JS, keeps all three right without a second structure.
+ *
+ * It is a JS-side name only. What goes over the wire is `RCTView`, because this node is REAL.
+ */
+export const SURFACE_COMPONENT = '#surface';
+/**
+ * One persistent root view per surface, mirroring RN's own AppContainer — `renderApplication` wraps
+ * the app in `<View style={{flex:1}} pointerEvents="box-none">`.
+ *
+ * It is not decoration. Without `flex: 1` a non-flex root collapses to content height, and without
+ * `box-none` a touch landing outside the app's own children has no escape. Living here rather than
+ * in each adapter's `mount()` gives every framework a full-screen root for free and keeps layout in
+ * the shared layer (`<adapters_stay_thin>`).
+ *
+ * The surface therefore commits as ONE node rather than hoisting its children into the child set —
+ * which is why the host materializes the node `OP_COMMIT` names instead of walking its children. An
+ * anchor in that position still hoists, so the host handles both without a special case.
+ */
+export function createSurfaceRoot() {
+    const node = new SymbioteNode(SURFACE_COMPONENT, false);
+    recordCreateElement(node, 'RCTView', false, node);
+    // Recorded straight, not through `routeProp`: these are literal Fabric props, not props an app
+    // authored, so they want none of the class merging or event routing that path exists for.
+    recordSetProp(node, 'style', { flex: 1 });
+    recordSetProp(node, 'pointerEvents', 'box-none');
+    return node;
 }
 export function isAnchor(node) {
     return node.component === ANCHOR_COMPONENT;
 }
-// A raw text with no characters must not reach Fabric. Its fragment is dropped by
-// AttributedString::appendFragment, but the text walk has already flagged "the last child was raw
-// text", so the NEXT raw sibling merges into `fragments.back()` of an empty vector and the process
-// aborts. The commit walk skips such a node exactly as it skips an anchor (commit.ts,
-// renderableChildren); an empty string paints nothing either way, so nothing is lost. `''` only —
-// a whitespace-only string is real content inside a <Text>.
-export function isEmptyRawText(node) {
-    return node.component === RAW_TEXT_COMPONENT && node.props.text === '';
-}
-// Dirty-marking: lets reconcile return an untouched subtree by reference instead of rebuilding
-// every node's Fabric props and deep-comparing them against the mirror. That walk costs ~13 us per
-// node on device (Hermes, iOS Debug, examples/react benchmark screen), so without the flag a
-// 1200-node tree burns a whole 16.6 ms frame no matter how small the change - the cost tracks TREE
-// SIZE, not change size.
-//
-// Marking walks up to the first ALREADY-dirty ancestor and stops, so a burst of mutations under one
-// subtree pays for one chain walk rather than one per mutation. Reconcile clears every node it
-// visits, which keeps the invariant "an ancestor of a dirty node is dirty" across commits.
-//
-// Listener changes deliberately do NOT mark. `node.listeners` never reaches Fabric (event dispatch
-// reads it straight off the retained node) and React hands us a fresh handler closure on nearly
-// every render, so marking there would re-dirty the whole tree every commit and hand the win back.
-// The one listener that DOES change a Fabric prop, `layout`, raises `onLayout` through setProp
-// below and is marked that way.
+// `isEmptyRawText` was here and is GONE: it read `node.props.text`, which JS no longer holds. The
+// rule it expressed — a raw text with no characters must not reach Fabric, because
+// AttributedString::appendFragment drops the fragment while the text walk has already flagged "the
+// last child was raw text", so the NEXT raw sibling merges into `fragments.back()` of an empty
+// vector and the process aborts — is now the host's, applied where the child set is built.
+// Dirty-marking is GONE, along with the walk it existed to skip. An op names the node it changed,
+// so the host marks exactly that node and its own ancestors; nothing on this side has to guess.
+// Listener changes still record nothing, for the reason they always did: `node.listeners` never
+// reaches Fabric, and the one listener that DOES change a Fabric prop, `layout`, raises `onLayout`
+// through `setProp` below.
 /**
  * Change which Fabric view a node commits as, keeping the node's identity.
  *
- * The commit walk already re-creates a node whose `viewName` no longer matches its committed one —
- * that is how a `<Text>` moving in or out of another `<Text>` flips between RCTText and
- * RCTVirtualText (`commit.ts`, reason `view-kind`). This exposes the same door for a prop-driven
- * view choice, so `intrinsicWhen` is honoured on UPDATE and not only at create.
- *
  * The POLICY stays out of the engine: which prop decides, and which view it decides between, lives
  * in `HOST_PRIMITIVES` and is read by `resolveIntrinsicTag` in `@symbiote-native/components`. The
  * engine only knows how to swap the name — the same split every other spec-driven fold has here.
  *
  * A no-op when the name is unchanged, so a renderer may call it on every update without comparing
  * first.
+ *
+ * The JS field and the op BOTH move, and both are load-bearing. `node.component` is what the aria
+ * fold, the behavior registry and `fabricProps` key on; the op is what makes the host re-create the
+ * node under the new name, since no prop write moves a node between native views.
  */
 export function setNodeComponent(node, component) {
     if (node.component === component)
         return;
     node.component = component;
-    // `dirty` alone is not enough: the walk's reuse test also requires the node be visited at all,
-    // and a node whose own props did not change this tick is exactly the case that would be skipped.
-    markDirty(node);
-    markPropsDirty(node);
-}
-export function markDirty(node) {
-    let current = node;
-    while (current !== undefined && !current.dirty) {
-        current.dirty = true;
-        current = current.parent;
-    }
-}
-// The prop-write twin of markDirty: raises this node's OWN props flag and then bubbles the subtree
-// flag as usual. Every path that writes `node.props` must come through here - setProp and setText
-// below, setNativeProps in commit.ts (which writes the record directly and so owes its own mark).
-//
-// Note the two flags are raised INDEPENDENTLY rather than one implying the other. markDirty stops
-// at the first already-dirty ancestor, so a node dirtied a moment ago by a child's change would
-// otherwise have its own prop write silently dropped: the walk would exit before setting anything
-// here. Setting propsDirty first, unconditionally, is what makes that ordering safe.
-export function markPropsDirty(node) {
-    node.propsDirty = true;
-    markDirty(node);
-}
-// The structural twin. Raised on the PARENT whose child list changed - never on the moved child,
-// for the same reason markDirty is not (see the structural ops below).
-//
-// Every caller must reach here BEFORE mutating `parent.children`, and that ordering is now
-// load-bearing rather than stylistic. reconcile stores the reconciled child list in the committed
-// record BY REFERENCE, so for a parent holding no anchors the record ALIASES `parent.children`;
-// this call is the last moment the committed list can still be read. Taking the copy here means it
-// is taken once per parent per commit->mutation cycle, and only for parents that actually change,
-// instead of once per node per commit - 9 002 arrays on a 1 000-row create, all but a handful
-// allocated only to be discarded unread.
-//
-// The identity test is what keeps it honest: a record whose `children` is NOT `parent.children`
-// either already holds a copy (this cycle's first structural op ran) or holds the private array
-// renderableChildren built to flatten anchors away, which nobody mutates. Neither needs saving.
-export function markStructureDirty(parent) {
-    const record = parent.committed;
-    if (record !== undefined && record.children === parent.children) {
-        record.children = parent.children.slice();
-    }
-    parent.structureDirty = true;
-    markDirty(parent);
-}
-// How many prop writes actually landed, and how many the no-op guard below turned away.
-// Read-and-zeroed through readCommitProfile() (commit.ts), which folds them into the same window
-// as the walk numbers so one read prices both halves: `propNoops` is the waste an adapter is
-// generating above the engine, `nodesVisited` is what that waste costs below it.
+    recordSetComponent(node, component);
+}
+// `isSkippedAtCommit`, `markPresenceIfFlipped`, `markDirty`, `markPropsDirty`, `markStructureDirty`,
+// `markRenderableAncestor`, `markChildOp`, `markChildRemoved` and `markChildAppended` all lived here
+// and are all GONE. Every one of them answered a question about a tree — which ancestor went stale,
+// whether a node's PRESENCE in its parent's renderable list flipped, which anchor to climb past —
+// and the host is the only thing that can answer those now. It marks from the ops themselves.
+// How many prop writes an adapter pushed at the engine. Read-and-zeroed through
+// readCommitProfile() (tree-host.ts), which prices the layer ABOVE the host.
+//
+// `noops` used to sit beside it and counted the writes the `Object.is` guard turned away — the
+// Angular Pressable bag that pushed 104 000 setProp calls for a screen Solid built in 12 000, 90 000
+// of them writing `undefined` over a key that was not there. The guard moved into the host, because
+// keeping it here would mean reading the previous value BACK over the wire — ~44 001 reads on a
+// 1 000-row create, exactly the crossings this design removes. So the number is no longer visible
+// from JS, and it is not faked as a zero it would have to keep re-earning.
 //
 // Not gated behind isDebug(), for the same reason the commit profile is not: an integer increment
 // is noise next to the prop write it counts, and the figure is only meaningful from a release
-// build. A per-call dlog was the obvious alternative and is deliberately NOT here - the Angular
-// screen that motivated the guard emitted 90 000 no-op writes on one press, and a log line each
-// would measure the logging rather than the code (see the `perf-claims-need-numbers` rule).
-const propStats = { writes: 0, noops: 0 };
+// build. A per-call dlog was the obvious alternative and is deliberately NOT here - a log line per
+// write would measure the logging rather than the code (see the `perf-claims-need-numbers` rule).
+const propStats = { writes: 0 };
 export function takePropStats() {
-    const snapshot = { writes: propStats.writes, noops: propStats.noops };
+    const snapshot = { writes: propStats.writes };
     propStats.writes = 0;
-    propStats.noops = 0;
+    return snapshot;
+}
+// `<component>.<key>` -> write count, gated behind `isDebug()` (a Map lookup per write is not the
+// "log line per write" the comment above rules out, but it is still real cost on the hottest path,
+// so it only runs when someone asked). Answers F-79's own recommended next step — "instrument
+// recordSetProp call sites directly, not just before/after counts" — by naming exactly which
+// (view, key) pair an adapter comparison's aggregate delta is hiding, the same ledger shape F-75's
+// payload census already uses (`RCTView.accessible 2000`).
+let propKeyTally;
+export function takePropKeyTally() {
+    const snapshot = propKeyTally ?? new Map();
+    propKeyTally = undefined;
     return snapshot;
 }
 // A pure prop set: no event inference. `onTintColor` is a Switch prop and reaches
 // Fabric like any other; the event-vs-prop decision is made by routeProp, never by
 // the key's name.
 //
-// Writing a value the node already holds is a NO-OP and returns before markDirty. Fabric never saw
-// a difference either way - reconcile rebuilds the node's Fabric props and `propsEqual` finds them
-// identical, so no clone is emitted - but the mark itself is not free: it walks to the first
-// already-dirty ancestor and strips every one of them of the commit walk's early exit, so an
-// otherwise untouched subtree gets re-walked purely to prove it is untouched. The guard makes that
-// whole bug class free for every adapter instead of each one having to remember to diff first
-// (measured: Angular's Pressable host bag pushed 104 000 setProp calls for a screen Solid built in
-// 12 000, 90 000 of them writing `undefined` over a key that was not there).
-//
-// Three deliberate choices:
-//
-// - `Object.hasOwn`, not `node.props[key] === undefined`. A key explicitly present holding
-//   `undefined` is not an absent key: `delete` genuinely changes the record's shape, and
-//   `setNativeProps` writes node.props directly and can leave exactly such a key behind. Fabric
-//   itself cannot tell the two apart (fabricProps skips undefined values), but node.props is also
-//   read outside the commit path, so the retained tree keeps the shape callers asked for.
-// - `Object.is`, not a deep compare. A style object, an array, or a handler closure is a fresh
-//   reference on nearly every render, so the guard simply never fires for them - correct, since an
-//   adapter is free to hand back the SAME reference with mutated contents and identity cannot see
-//   that. A deep compare on every prop write would cost more than the walk it saves.
-// - The in-place-mutation hazard that leaves is already instrumented: a node skipped as clean whose
-//   props have drifted is exactly what `warnIfStale` reports as DIRTY-MISS under DEBUG (commit.ts).
+// `undefined` DELETES the key, which is the collapse this function has always performed and which
+// the wire now spells (`NO_VALUE`, mutation-buffer.ts). `null` is NOT the same thing: it is a
+// legitimate Fabric value meaning "reset to the default", and a merge-on-clone host has to be able
+// to tell a removed key from one that was never there.
+//
+// THE `Object.is` DEDUPE IS NOT HERE ANY MORE, and that is the one behaviour change in this file.
+// It needed the value the node already holds, and JS no longer holds it — reading it back would be
+// ~44 001 crossings on a 1 000-row create, which is the cost this whole design exists to remove. The
+// guard lives in the host's `OP_SET_PROP` instead, where the previous value is a local field: same
+// comparison, same `Object.is` reasoning (a style object or a handler closure is a fresh reference
+// on nearly every render, so it simply never fires for them, which is correct because an adapter may
+// hand back the SAME reference with mutated contents and identity cannot see that).
 export function setProp(node, key, value) {
-    if (value === undefined) {
-        if (!Object.hasOwn(node.props, key)) {
-            propStats.noops += 1;
-            return;
-        }
-        delete node.props[key];
+    // THE ARIA GATE WAS THIS LINE AND IT IS GONE (2026-09-18). `node.hasAriaAlias` existed to let the
+    // headless payload builder skip `foldAriaProps` on the ~99% of nodes carrying no alias; that
+    // builder no longer folds aria at all — the rule is the device's, in `SymbioteFabricProps.cpp`,
+    // which recomputes the gate from the bag it already holds. So the flag became write-only, and its
+    // write ran `isAriaAliasKey` on EVERY prop write in the engine to maintain something nothing read.
+    //
+    // A composed primitive's slot — and its wrapper, where it has one — can carry a value DERIVED
+    // from an owner prop, and `markPropsDirty` bubbles up, so neither ever learns. Here rather than
+    // in `routeProp` because this is the one choke point every writer passes (a structural adapter's
+    // `setProperty` does not go through routeProp), and past the identity guard so a re-render
+    // writing an unchanged value costs them nothing. See `IHostBehavior.slotDerived`.
+    if (node.childHost !== undefined && slotDerivesFrom(node, key)) {
+        markPropsDirty(node.childHost);
+        // Past the slot: a `buildStructure` that builds a CHAIN registers the deeper nodes here, and
+        // each keeps its own pure fold reading the owner. See `addDerivedNode`.
+        const derived = derivedNodesOf(node);
+        if (derived !== undefined)
+            for (const each of derived)
+                markPropsDirty(each);
+        if (node.wrapper !== undefined)
+            markPropsDirty(node.wrapper);
     }
-    else {
-        if (Object.is(node.props[key], value)) {
-            propStats.noops += 1;
-            return;
+    propStats.writes += 1;
+    if (isDebug()) {
+        propKeyTally ??= new Map();
+        const tallyKey = `${node.component}.${key}`;
+        propKeyTally.set(tallyKey, (propKeyTally.get(tallyKey) ?? 0) + 1);
+    }
+    writeProp(node, key, value);
+}
+// Function props that never left JS, keyed by node.
+//
+// A function CANNOT cross this wire. The host stores props as a `folly::dynamic` and
+// `jsi::dynamicFromValue` THROWS on a callable — "JS Functions are not convertible to dynamic" —
+// so a single function prop kills the whole batch, and with it the commit that carried it.
+//
+// It has always been unsendable and it used to be unreachable, because `routeProp` diverts every
+// REGISTERED `on*` name into the listener stash before this point. Two paths get past that and both
+// are real: an unregistered `on*` that is an ordinary prop by design (`onValueChange`, which
+// `fabricProps` drops on the way to native and a behavior reads back), and `setNativeProps`, which
+// bypasses `routeProp` entirely. Device-found 2026-09-08 through the second: an `Animated.View`
+// spread with `panResponder.panHandlers` hands `AnimatedProps.__getValue()` a bag of callbacks, and
+// it copies every key it holds.
+//
+// So they live here, exactly as listeners already do — and `propOf` looks here first, which is what
+// keeps `onValueChange` readable. Nothing is lost on the native side: `fabricProps` dropped function
+// props on both hosts anyway, so the payload is byte-identical either way.
+const functionProps = new WeakMap();
+/**
+ * The one place a prop reaches the wire, and the only place that can keep a function off it.
+ *
+ * `setNativeProps` calls this rather than `recordSetProp` for that reason — it is the path that has
+ * no `routeProp` in front of it.
+ */
+export function writeProp(node, key, value) {
+    // The same strip `routeProp` does, repeated because THIS is the path with no `routeProp` in
+    // front of it (`imperative.ts` says so). One filter on the declarative path was never enough:
+    // `AnimatedProps` is built from a RAW prop bag and re-sends every key it holds on every frame,
+    // so on a JSX adapter `__self` rode straight past the strip into the host. See
+    // REACT_JSX_DEV_PROPS for what that costs on each platform.
+    if (REACT_JSX_DEV_PROPS.has(key))
+        return;
+    // Arms the node's recurring post-commit hook, for the rare node that has one. HERE rather than in
+    // `setProp`, because this is where both paths meet: `setNativeProps` reaches the wire through
+    // this function and not through that one, and a hook armed only by the declarative path missed
+    // the imperative write entirely (`__tests__/after-commit-lifecycle.test.ts` said so). The field
+    // read is the same shape as `hasAriaAlias` and for the same reason — this is the hottest path in
+    // the engine, and a Set lookup per write is not something it can carry.
+    if (node.hasCommitHook)
+        noteCommitHookNodeChanged(node);
+    // Resolved on the way IN, for the same reason the strip above lives here: this is where both
+    // paths meet. `boxShadow` / `filter` / `transform` and the four beside them are parsed in JS,
+    // and the C++ payload builder has no JS — so a value resolved at payload-build time is resolved
+    // headless only, and the device commits the raw CSS string, which Fabric drops in silence. See
+    // `structured-style.ts`; it hands the same object back when nothing needed resolving, which is
+    // what keeps the host's identity guard and `pushClassStyle` working.
+    // Image's three source props, resolved on the way in for the same reason and at the same seam —
+    // the asset lookup is Metro's registry, which exists only in JS. See `image-source-write.ts`.
+    // Gated on the node: the resolution normalises to Image's ARRAY shape, and a `WebView` spells
+    // `source` too.
+    let written = value;
+    if (key === 'style' || key === 'activeStyle') {
+        written = resolveStructuredStyle(value);
+    }
+    else if (node.resolvesImageSources && IMAGE_SOURCE_PROPS.has(key)) {
+        written = resolveImageSourceProp(value);
+    }
+    if (typeof written === 'function') {
+        let bag = functionProps.get(node);
+        if (bag === undefined) {
+            bag = new Map();
+            functionProps.set(node, bag);
         }
-        node.props[key] = value;
+        bag.set(key, value);
+        // The host must not be left holding whatever stood under this key before — a stale value read
+        // back through `propOf` would beat the function this write just stashed.
+        recordSetProp(node, key, undefined);
+        return;
     }
-    // The single choke point for the aria gate. `routeProp`'s other branches — class, style,
-    // activeStyle, on* — return before reaching here and none of them can carry an alias, so every
-    // `role` / `aria-*` write in the engine passes through this line.
-    if (!node.hasAriaAlias && isAriaAliasKey(key))
-        node.hasAriaAlias = true;
-    propStats.writes += 1;
-    markPropsDirty(node);
+    // Written over with a non-function: the stash must let go, or it keeps answering.
+    const bag = functionProps.get(node);
+    if (bag !== undefined)
+        bag.delete(key);
+    recordSetProp(node, key, written);
+}
+/** What `propOf` consults before asking the host. `undefined` when nothing was stashed. */
+export function functionPropOf(node, key) {
+    return functionProps.get(node)?.get(key);
+}
+/**
+ * The same stash, whole — what `propsOf` layers over the host's answer.
+ *
+ * `undefined` rather than an empty Map for a node that stashed nothing, which is nearly every node:
+ * the caller then hands back the host's own object instead of copying it.
+ */
+export function functionPropsOf(node) {
+    return functionProps.get(node);
+}
+/**
+ * "Rebuild this node's payload — the fold reads state I just changed."
+ *
+ * A behavior whose payload is DERIVED has no prop to write: the sticky header's debounced
+ * translateY lives in its own runtime, not on the node, so nothing names the node and the host
+ * never marks it. This is the one route that says so directly.
+ *
+ * Dirtying is not publishing — pair it with `requestCommitFor` (imperative.ts).
+ */
+export function markPropsDirty(node) {
+    flushOps();
+    // Announced to the buffer even though it writes no op: this is the one route that dirties a node
+    // without one, and a commit that cannot see it would skip itself as idle.
+    noteHostSideChange();
+    // The other way a node's payload is rebuilt, and the beat's population must cover both or a
+    // behavior whose payload is DERIVED — the sticky header's debounced translateY has no prop to
+    // write — would be armed by nothing.
+    if (node.hasCommitHook)
+        noteCommitHookNodeChanged(node);
+    treeHost()?.markPropsDirty(node);
 }
 // Fabric gates a handful of events behind a BOOLEAN prop: unlike scroll / touch / change, which
 // the native component emits unconditionally, these fire only when the shadow node carries the
@@ -371,12 +563,20 @@ const GATED_EVENT_PROPS = new Map([
  * `setEventListener` diverts an owned name into the stash, which is right for an app listener and
  * circular for the behavior's own dispatcher — it would stash itself and never occupy the slot it
  * exists to hold. This is the one writer allowed past that gate.
+ *
+ * `undefined` removes it, gate flag included. A behavior whose dispatcher is conditional needs
+ * that as much as it needs the install: ScrollView takes the owner's `layout` only while the app
+ * or an inverted sticky header wants it, and a one-way installer leaves `onLayout: true` standing
+ * in the payload of a ScrollView that no longer reads the event.
  */
 export function setBehaviorListener(node, name, listener) {
-    (node.listeners ??= new Map()).set(name, listener);
+    if (listener === undefined)
+        node.listeners?.delete(name);
+    else
+        (node.listeners ??= new Map()).set(name, listener);
     const flagProp = GATED_EVENT_PROPS.get(name);
     if (flagProp !== undefined)
-        setProp(node, flagProp, true);
+        setProp(node, flagProp, listener === undefined ? undefined : true);
 }
 export function setEventListener(node, name, value) {
     const isHandler = typeof value === 'function';
@@ -385,10 +585,22 @@ export function setEventListener(node, name, value) {
     // without this the two evict each other and the last writer wins with no diagnostic; and the
     // keys at stake are the ones a gesture STARTS on, so the loser is silently pressless. The
     // component wrapper used to mediate this by destructuring the app's callbacks out before they
-    // reached the node; lowering removes the mediator. Gated on the boolean first, so an app with no
-    // behavior registered pays one read.
+    // reached the node; a tag has no mediator. Gated on the boolean first, so an app with no behavior
+    // registered pays one read.
     if (hasHostBehaviors() && ownsListener(node, name)) {
+        // The PRESENCE only, never the identity: listeners deliberately do not notify (a framework
+        // hands a fresh closure nearly every render — see `markDirty`'s note on why that must stay
+        // free). A flip is a mount-time event, not a per-render one.
+        const wasWired = appListenerFor(node, name) !== undefined;
         stashAppListener(node, name, isHandler ? value : undefined);
+        if (wasWired !== isHandler) {
+            // The BIT, on the flip only. A platform rule can then resolve a key that depends on whether
+            // the app wired anything — `focusable` on a touchable is the case that needed it — without
+            // the closure ever leaving JS. Ordered before the notify so a behavior that re-commits from
+            // that callback finds the host already holding the new answer.
+            recordSetOwnedListener(node, name, isHandler);
+            notifyOwnedListenerChange(node, name, isHandler);
+        }
         const flagged = GATED_EVENT_PROPS.get(name);
         if (flagged !== undefined)
             setProp(node, flagged, isHandler ? true : undefined);
@@ -405,8 +617,28 @@ export function setEventListener(node, name, value) {
     const flagProp = GATED_EVENT_PROPS.get(name);
     if (flagProp !== undefined)
         setProp(node, flagProp, isHandler ? true : undefined);
+    // `onLoad`/`onLoadStart`/`onLoadEnd`/`onError` are real Fabric events on `RCTImageView`
+    // (`view-config.ts`), so they land here rather than in `writeProp` — see
+    // `image-source-write.ts` for why Android's `shouldNotifyLoadEvents` has to be synthesized
+    // from the listener map instead of from a stashed function value.
+    if (node.resolvesImageSources && IMAGE_LOAD_EVENT_NAMES.has(name)) {
+        setProp(node, 'shouldNotifyLoadEvents', anyImageLoadEventListenerWired(node.listeners) ? true : undefined);
+    }
+}
+// `/^on[A-Z]/` spelled out, because this runs on EVERY prop write and a regex is the one guard in
+// that sequence that is not obviously cheap. Priced on `build-release`
+// (`mutation-api-fill-cost.itest.ts`): 0.09 us for the regex against 0.03 for the character reads,
+// on a prop write that costs 0.88 us end to end — so ~7% of a write, ~1% of a create. Small, and it
+// is free: the boundary is pinned by its own tests in `node.test.ts`.
+//
+// 111 is 'o', 110 is 'n', and 65-90 is A-Z. `charCodeAt` past the end answers NaN, which fails every
+// comparison — so a two-character `on` needs no length check.
+function isOnEventName(key) {
+    if (key.charCodeAt(0) !== 111 || key.charCodeAt(1) !== 110)
+        return false;
+    const third = key.charCodeAt(2);
+    return third >= 65 && third <= 90;
 }
-const ON_PREFIX = /^on[A-Z]/;
 // onChange -> change
 function listenerName(propName) {
     return propName.charAt(2).toLowerCase() + propName.slice(3);
@@ -436,9 +668,17 @@ const RESPONDER_EVENTS = new Set([
 // consumes both and never forwards them. A JSX-based adapter (Vue JSX, Solid JSX) instead
 // carries them onto the vnode as ordinary props, so they reach setProp and then Fabric,
 // where Android's folly::dynamic rejects __self with "JS Functions are not convertible to
-// dynamic" (the instance holds functions) and the surface paints black, while iOS silently
-// drops it. SFC/template authoring never produces them. Strip them here, once, so no
-// adapter leaks React JSX dev metadata to the host, mirroring React's host config.
+// dynamic" (the instance holds functions) and the surface paints black.
+//
+// "WHILE IOS SILENTLY DROPS IT" IS WHAT THIS COMMENT USED TO SAY, AND IT IS WRONG. iOS converts
+// the same value with `jsi::dynamicFromValue`, whose walk keeps no visited set, and `__self` is a
+// module `this` — cyclic. That is not a drop, it is an endless walk inside `applyOps` that never
+// returns and allocates as it goes: measured 2026-09-09 on examples/solid, one press on an
+// Animated control, RAM to 15 GB and a dead JS thread. Android's loud rejection is the FRIENDLIER
+// of the two platforms here.
+//
+// SFC/template authoring never produces them. Strip them here, once, so no adapter leaks React
+// JSX dev metadata to the host, mirroring React's host config.
 const REACT_JSX_DEV_PROPS = new Set([
     '__self',
     '__source',
@@ -460,6 +700,7 @@ function stylePartsOf(node) {
         isPressed: false,
         activeStyle: undefined,
         activeStyleFromCallback: false,
+        published: undefined,
     });
 }
 // What belongs in slot 0 right now. The pressed variant is a complete REPLACEMENT rather than an
@@ -530,19 +771,149 @@ function baseStyleOf(parts) {
 // constant - StyleSheet.create, a module-level object - would then re-push an identity-equal half,
 // get skipped by setProp's Object.is guard, and never restore the declarative style the animation
 // overwrote. The re-push IS the restore path.
-// Would `pushClassStyle` republish an array byte-identical to the one already standing? Reads the
-// last published array back out of `node.props.style` rather than remembering it in a field: that
-// array IS the record of what was published, so there is nothing to keep in sync, and no shape
-// change to the node or to IClassStyleParts.
-//
-// Sound because `pushClassStyle` is the ONLY writer of an array into that slot — both routeProp
-// branches and setNodeHidden funnel through it — so a foreign array cannot be mistaken for ours,
-// and a node whose props are still empty holds `undefined`, which is not an array, so the first
-// write can never be swallowed.
-function isAlreadyPublished(node, parts) {
-    const published = node.props.style;
-    if (!Array.isArray(published))
+// Would `pushClassStyle` republish an array byte-identical to the one already standing?
+//
+// Sound because `pushClassStyle` is the ONLY writer of `parts.published` — both routeProp branches
+// and setNodeHidden funnel through it — so a node that has published nothing holds `undefined` and
+// the first write can never be swallowed.
+// What a node publishes when NOTHING resolves — an unstyled node, or the benchmark row's
+// `style={isSelected ? {…} : undefined}` on the 999 rows that are not selected. Length 0 is the
+// marker and needs no second field: `pushClassStyle` never publishes an empty array otherwise, so
+// the state is unambiguous, and it is distinct from `undefined`, which means "nothing published
+// yet" and must never be turned away.
+const PUBLISHED_NOTHING = Object.freeze([]);
+// ── ONE ARRAY PER DISTINCT PAIR, SHARED ACROSS NODES ─────────────────────────────────────────────
+//
+// The array above is per-node and identical for every node styled the same way, which is the normal
+// case for a list: one `StyleSheet.create` object, or one resolved CSS class, across a thousand rows.
+// `mutation-buffer.ts` interns the values it is handed BY IDENTITY, so a thousand distinct-but-equal
+// arrays are a thousand entries and a thousand JS -> `folly::dynamic` conversions on the far side.
+// Measured on `build-release`: 4 000 of 12 005 `setProp` ops refused to fold, and they were exactly
+// these.
+//
+// `WeakMap`, and both levels of it, so nothing here can grow without bound: a caller that builds a
+// fresh style object per render gets a fresh cache entry that dies with the object. That caller also
+// gets no sharing, which is correct — two structurally equal objects are two values to whoever reads
+// them, and a deep compare would make every prop write cost the size of the style.
+//
+// The three-slot (hidden) form is deliberately NOT cached. `display: 'none'` is a state almost no
+// node is ever in, so a third map would be paid for on every write to serve a case that is rare by
+// construction.
+const sharedPairByExplicit = new WeakMap();
+const sharedPairByBase = new WeakMap();
+/**
+ * The published array for this pair — the same object every time the same two parts are handed in.
+ *
+ * `undefined` when the pair cannot be keyed (a primitive half, or the hidden form), and the caller
+ * then builds its own array exactly as before. Sharing is an optimization here, never a requirement:
+ * every reader of `published` compares its SLOTS by identity, never the array itself.
+ */
+function sharedStylePair(base, explicit) {
+    const baseIsKeyable = typeof base === 'object' && base !== null;
+    const explicitIsKeyable = typeof explicit === 'object' && explicit !== null;
+    if (base === undefined && explicitIsKeyable) {
+        const cached = sharedPairByExplicit.get(explicit);
+        if (cached !== undefined)
+            return cached;
+        const made = [base, explicit];
+        sharedPairByExplicit.set(explicit, made);
+        return made;
+    }
+    if (!baseIsKeyable)
+        return undefined;
+    if (explicit === undefined) {
+        const cached = sharedPairByBase.get(base);
+        if (Array.isArray(cached))
+            return cached;
+        if (cached === undefined) {
+            const made = [base, explicit];
+            sharedPairByBase.set(base, made);
+            return made;
+        }
+        // A base that has already been seen WITH an explicit half holds the second-level map here, and
+        // the base-only array has nowhere to live beside it. Rare enough not to earn a third map.
+        return undefined;
+    }
+    if (!explicitIsKeyable)
+        return undefined;
+    const existing = sharedPairByBase.get(base);
+    const byExplicit = existing instanceof WeakMap ? existing : new WeakMap();
+    if (existing === undefined)
+        sharedPairByBase.set(base, byExplicit);
+    // Same clash as above, the other way round: this base is holding its base-only array. Leave it.
+    if (Array.isArray(existing))
+        return undefined;
+    const cached = byExplicit.get(explicit);
+    if (cached !== undefined)
+        return cached;
+    const made = [base, explicit];
+    byExplicit.set(explicit, made);
+    return made;
+}
+// A slot that contributes no keys to the payload: absent, or the registry's shared "this class
+// styles nothing" object. An IDENTITY compare rather than a key count — `Object.keys(x).length`
+// allocates an array, and this runs on every class and style write, ~14 000 times on one benchmark
+// create. That is the F-12 shape: an expensive guard in front of cheap work.
+/** A plain style bag — not an array of styles, not a callback, not null. */
+function isStyleRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Is this rebuilt style the same style, key for key?
+ *
+ * A component body that writes its style inline hands over a FRESH object every render, equal to
+ * the one already standing — the commonest shape any app produces, and one `Object.is` cannot see.
+ * Without this the write crosses into the host, becomes a `folly::dynamic`, and is only THEN found
+ * to be unchanged. Measured on `build-release` (`no-op-rerender-cost.itest.ts`), 1 000 rows
+ * re-rendered with nothing changed: 9.7 ms against 0.3 ms for the same app with its style hoisted,
+ * and 5.2 ms of that was the conversion. The cheapest place to refuse a write is the earliest place
+ * that can see it is a no-op.
+ *
+ * SHALLOW AND CONSERVATIVE, both deliberately. A nested value (a transform list, a shadow, a style
+ * array) reports "not the same" rather than being compared deeply, because a deep compare makes this
+ * guard cost the size of the style — which is the cost it exists to avoid. Those keep crossing and
+ * the host's own `diffProps` refuses them exactly as before, so being wrong here is slow, never
+ * incorrect.
+ *
+ * `undefined` on either side also reports "not the same", which is what lets the key COUNT stand in
+ * for a key-set comparison: equal counts plus every key of `next` matching a defined value in
+ * `standing` cannot leave a key unaccounted for.
+ */
+export function isSameShallowStyle(next, standing) {
+    if (!isStyleRecord(next) || !isStyleRecord(standing))
+        return false;
+    const keys = Object.keys(next);
+    if (keys.length !== Object.keys(standing).length)
         return false;
+    for (const key of keys) {
+        const value = next[key];
+        if (value === undefined || isStyleRecord(value) || Array.isArray(value)) {
+            return false;
+        }
+        if (!Object.is(value, standing[key]))
+            return false;
+    }
+    return true;
+}
+function contributesNothing(slot) {
+    return slot === undefined || slot === EMPTY_STYLE;
+}
+// Does this node have a style at all? Read through the same two resolvers as the publication, for
+// the reason the guard below states: guard and publication disagreeing is a silent wrong screen.
+function hasNothingToPublish(parts) {
+    return (parts.hiddenStyle === undefined &&
+        contributesNothing(baseStyleOf(parts)) &&
+        contributesNothing(explicitStyleOf(parts)));
+}
+function isAlreadyPublished(parts) {
+    const published = parts.published;
+    if (published === undefined)
+        return false;
+    // The delete is already standing. Asked before the slot comparisons because an empty array would
+    // otherwise pass both of them on `undefined` and then fail the length check, republishing a
+    // delete the host already performed.
+    if (published.length === 0)
+        return hasNothingToPublish(parts);
     // `baseStyleOf`, not `parts.classStyle` — the guard and the publication must read slot 0 the
     // same way or a press is turned away as already-published and silently does nothing on device
     // while the behavior fires correctly and nothing goes red.
@@ -561,31 +932,49 @@ function pushClassStyle(node, parts) {
     // an UNCHANGED class still lands as a write AND marks the node dirty. Costs React / Vue / Svelte
     // nothing — each diffs props before calling the engine — but Solid has no diff: a fine-grained
     // effect re-runs whenever any signal it reads changes, so a list-wide signal makes every row
-    // re-push its own unchanged class. Measured on device 2026-08-23 (examples/solid, after
-    // host-primitive lowering): selecting one row of 1 000 read WRITES 1001 and a 10.3 ms reconcile
+    // re-push its own unchanged class. Measured on device 2026-08-23 (examples/solid, once its
+    // primitives were tags): selecting one row of 1 000 read WRITES 1001 and a 10.3 ms reconcile
     // window against Fabric's unmoved 0/0/10 — a thousand-node dirty walk for two nodes of change.
-    // Before lowering, the View component's splitProps/mergeProps memos had been absorbing it.
     //
-    // This is NOT the naive skip the paragraph above forbids, and the array check is the difference.
-    // Skipping on "the parts are unchanged" alone would break the restore path, because
-    // setNativeProps writes node.props.style directly and a hoisted style constant would then never
-    // be restored. But setNativeProps writes an OBJECT (commit.ts: `{...flattenStyle(prev),
-    // ...flattenStyle(value)}`), never an array — so after any bypass isAlreadyPublished is false,
-    // the re-push happens exactly as before, and the restore path is untouched.
+    // This is NOT the naive skip the paragraph above forbids, and the published marker is the
+    // difference. Skipping on "the parts are unchanged" alone would break the restore path, because
+    // setNativeProps writes the style slot past this function and a hoisted style constant would then
+    // never be restored. But setNativeProps CLEARS `parts.published` — so after any bypass
+    // isAlreadyPublished is false, the re-push happens exactly as before, and the restore path is
+    // untouched.
     //
     // Exact rather than approximate: resolveClassName memoizes a class STRING to the same object, so
     // an unchanged class yields an identity-equal classStyle. It deliberately does not fire for an
-    // object/array class value, which resolves fresh every call — the same place setProp's Object.is
-    // already gives up on a style object, so no new asymmetry appears.
-    if (isAlreadyPublished(node, parts))
+    // object/array class value, which resolves fresh every call — the same place the host's own
+    // Object.is guard gives up on a style object, so no new asymmetry appears.
+    if (isAlreadyPublished(parts))
         return;
+    // NOTHING RESOLVED, so say nothing. The buffer spells an absent prop as `NO_VALUE` and the host
+    // then takes a path that costs it literally one branch — `if (props.get_ptr(key) == nullptr)
+    // break` — while `[undefined, undefined]` is a real value it must convert into a `folly::dynamic`
+    // array, store, and re-compare on every later commit. Both are behaviourally "no style": the
+    // payload builder flattens the pair of undefineds into no keys at all.
+    //
+    // This is NOT the naive skip the note above forbids, and the distinction is the same one the
+    // published marker makes. A restore after `setNativeProps` arrives here with `published` cleared
+    // to `undefined`, so it is never turned away — and when the authored style is nothing, restoring
+    // it means DELETING the slot the imperative write put there, which is what this emits.
+    if (hasNothingToPublish(parts)) {
+        parts.published = PUBLISHED_NOTHING;
+        setProp(node, 'style', undefined);
+        return;
+    }
     // The third slot is APPENDED ONLY WHILE HIDDEN. Writing a permanent three-element array would
     // change the style payload of every node in every app for a state almost none of them are ever
     // in — and this project spent a day removing per-frame allocations, so a slot that is undefined
     // 99.9% of the time does not get to ride along on every style write.
-    setProp(node, 'style', parts.hiddenStyle === undefined
-        ? [baseStyleOf(parts), explicitStyleOf(parts)]
-        : [baseStyleOf(parts), explicitStyleOf(parts), parts.hiddenStyle]);
+    const base = baseStyleOf(parts);
+    const explicit = explicitStyleOf(parts);
+    const published = parts.hiddenStyle === undefined
+        ? (sharedStylePair(base, explicit) ?? [base, explicit])
+        : [base, explicit, parts.hiddenStyle];
+    parts.published = published;
+    setProp(node, 'style', published);
 }
 // `display: 'none'` is a real RN style value (Yoga's DisplayNone), so a hidden node keeps its
 // place in the tree, its state and its children — it just stops laying out and painting.
@@ -620,6 +1009,35 @@ export function setNodePressed(node, pressed) {
     parts.isPressed = pressed;
     pushClassStyle(node, parts);
 }
+/**
+ * Tell the host a behavior's FEEDBACK is showing — TouchableHighlight's underlay, and only that.
+ *
+ * The sibling of `setNodePressed` and deliberately NOT the same bit. Press state drives `:active`
+ * class resolution, which happens in JS because a class name resolves against a JS registry; this
+ * drives a rule that lives in C++ (`foldTouchableHighlightUnderlay`), so it crosses as one op rather
+ * than resolving to a style here. And the two are genuinely different facts: RN holds the underlay
+ * past release so a fast tap still flashes, so `shown` LAGS `pressed` by a `delayPressOut` timer.
+ *
+ * No style is computed on this side at all, which is the whole point — the two props the rule reads
+ * (`underlayColor`, `activeOpacity`) are ones the engine already strips from the payload, so the
+ * values and their defaults live in one place instead of being erased in C++ and reached around for
+ * in JS.
+ */
+export function setNodeUnderlayShown(node, shown) {
+    recordSetUnderlayShown(node, shown);
+}
+/**
+ * Forget what was last published, so the next `pushClassStyle` cannot be turned away.
+ *
+ * The one caller is `setNativeProps` (imperative.ts), which writes the style slot past this file —
+ * see the note on `IClassStyleParts.published` for why the restore path depends on this. A no-op for
+ * a node nobody has styled, which is why it is not `stylePartsOf(node).published = undefined`: that
+ * would allocate the parts on a node that has none.
+ */
+export function clearPublishedStyle(node) {
+    if (node.styleParts !== undefined)
+        node.styleParts.published = undefined;
+}
 // The explicit (non-class-derived) style half, for an adapter that builds its style prop up
 // key-by-key (Angular's Ivy ɵɵstyleProp/setStyle) instead of handing over one whole object —
 // it must merge onto this, not onto node.props.style directly, which may be the
@@ -627,20 +1045,129 @@ export function setNodePressed(node, pressed) {
 export function getExplicitStyle(node) {
     return node.styleParts?.explicitStyle;
 }
+/**
+ * The `[classStyle, explicitStyle]` pair the node currently PUBLISHES — the same value
+ * `commitClassStyle` writes, in the same order, so `flattenStyle` collapses it the way Fabric will.
+ *
+ * For a caller that wants the merged answer without a host: the pair reaches the payload as an op,
+ * and only a host holds ops. A test that has not installed one — `core/css-parser` reaches into the
+ * engine by relative path and depends on neither package — can read it here instead of reaching
+ * into `styleParts`, which is engine-owned and not a shape anything outside may bind to.
+ */
+export function getPublishedStyle(node) {
+    const parts = node.styleParts;
+    if (parts === undefined)
+        return [];
+    return [parts.classStyle, parts.explicitStyle];
+}
 const CLASS_PROP_KEYS = new Set(['class', 'className']);
 // The flat-bag split (React / Vue / Solid): an `onX` prop becomes an event listener
 // ONLY when the node's component actually declares `x` as an event (per the shared
 // ViewConfig). Otherwise it is a plain prop, so `onTintColor` on a Switch, whose
 // only event is `change`, routes to setProp and reaches Fabric.
+// `id` is RN's W3C-named alias for `nativeID` and it WINS when both are set
+// (`View.js:77-79` — `processedProps.nativeID = id`). A raw `id` is declared by no ViewConfig, so
+// Fabric drops it in SILENCE: a rename that half-works loses the nativeID with nothing red anywhere.
+const ID_ALIAS_FROM = 'id';
+const ID_ALIAS_TO = 'nativeID';
+/**
+ * The ONE place this rename happens, as of 2026-09-18. It used to happen in SEVEN.
+ *
+ * `foldHostBag` did it for React, Svelte and Angular off `HOST_PRIMITIVES[*].aliases` (seventeen
+ * identical entries); Vue's `patchProp`, Solid's renderer and Angular's own `PROP_ALIASES` each did
+ * it again per key; and `foldIdAlias` did it a seventh time in C++. Three different coverage sets,
+ * so the answer depended on which adapter you were on and whether the node's tag happened to carry a
+ * registered behavior — `core/engine/cpp/tests/js/id-alias-coverage.itest.ts` measured that split
+ * before this collapsed it.
+ *
+ * HERE because this is the funnel: every adapter's prop write ends at `routeProp`, whatever shape it
+ * starts in. A bag fold cannot serve the per-key renderers and a per-key fold cannot serve the bag
+ * ones; the seam they SHARE can serve both.
+ *
+ * PRECEDENCE IS WHY THIS NEEDS STATE. Upstream reads both props at once, so `id ?? nativeID` is
+ * decided in one expression. A per-key writer never sees both, so precedence would otherwise fall
+ * out of write ORDER — `<view id nativeID>` keeping the stale legacy value while `<view nativeID id>`
+ * did not. Solid had already built exactly this memory for exactly this reason; it is one copy now.
+ *
+ * The authored `nativeID` is REMEMBERED rather than discarded, so clearing the `id` hands the slot
+ * back instead of latching. A framework that unsets a prop between renders must get the other
+ * source back.
+ *
+ * PRECEDENCE ITSELF IS PER-COMPONENT. `View.js`'s `id ?? nativeID` is the default (`idWins` below),
+ * but `TouchableWithoutFeedback.js`'s clone composes that and then runs a `PASSTHROUGH_PROPS` loop
+ * that unconditionally overwrites `nativeID` with the raw authored value when set (`:279-282`) — an
+ * app authoring both ends up with `nativeID` winning there. `node.nativeIdWinsOverId`, set by
+ * `attachHostBehavior` for the one behavior that declares it, flips which side wins.
+ */
+const idAliased = new WeakMap();
+function routeIdAlias(node, key, value) {
+    const state = idAliased.get(node) ?? {
+        idValue: undefined,
+        nativeIdValue: undefined,
+    };
+    if (key === ID_ALIAS_FROM)
+        state.idValue = value;
+    else
+        state.nativeIdValue = value;
+    idAliased.set(node, state);
+    const published = node.nativeIdWinsOverId
+        ? (state.nativeIdValue ?? state.idValue)
+        : (state.idValue ?? state.nativeIdValue);
+    setProp(node, ID_ALIAS_TO, published);
+}
 export function routeProp(node, key, value) {
     if (REACT_JSX_DEV_PROPS.has(key))
         return;
+    // The prop twin of the child redirect in `appendChild`. A composed primitive's owner is written
+    // with props that belong to its internal slot — `contentContainerStyle` on a ScrollView styles
+    // the content view — and the adapter names the OWNER for a prop for the same reason it names the
+    // owner for a child: that is where the app wrote it.
+    //
+    // Gated on the FIELD, so a node with no slot pays one load and one branch and never touches the
+    // registry. The redirected write recurses into the slot's own `routeProp`, which is single-hop
+    // by construction: a slot has no slot of its own (`childHost` is documented single-hop, and
+    // `buildStructure` is what would have to nest one).
+    if (node.childHost !== undefined) {
+        const slotKey = slotPropNameFor(node, key);
+        if (slotKey !== undefined) {
+            // A class NAME is a legal spelling of `contentContainerStyle` — every canary writes
+            // `contentContainerStyle="scroll-content"` — so a string has to land on the slot as a
+            // CLASS. Only the class branch consults the registry; renaming it verbatim would publish a
+            // `style` holding a string, which is not a style and is dropped with nothing red. React's
+            // wrapper resolves the name itself (components/scroll-view/shared.ts), so this gap could
+            // only ever show on the tag path.
+            routeProp(node.childHost, slotKey === 'style' && typeof value === 'string' ? 'class' : slotKey, value);
+            return;
+        }
+    }
+    // AFTER the slot redirect, and that order is load-bearing rather than tidy. A composed primitive
+    // forwards most of its bag to an internal node — ImageBackground spreads everything but `style`
+    // onto its image, exactly as RN does — so an `id` written on the OWNER belongs to the node the
+    // redirect sends it to. Resolved before the redirect, the alias would publish a `nativeID` on the
+    // wrapper and the inner node would never see it: the owner would answer to a testID the app
+    // pointed at the image.
+    if (key === ID_ALIAS_FROM || key === ID_ALIAS_TO) {
+        routeIdAlias(node, key, value);
+        return;
+    }
+    // An AnimatedNode written straight into a prop — `<view style={{opacity: value}}/>` — is
+    // resolved here into the value to PUBLISH, with the engine holding the subscription. Same
+    // shape as the `style` callback below: a value the engine interprets rather than forwards.
+    // Returns its input by identity when nothing is animated, so every branch under this line is
+    // unchanged. See `animated/host-binding.ts`; the gate is one boolean for an app that animates
+    // nothing.
+    //
+    // AFTER the slot redirect, so an animated `contentContainerStyle` binds on the node that
+    // actually carries the style.
+    const resolved = hasAnimatedNodes()
+        ? bindAnimatedValue(node, key, value)
+        : value;
     if (CLASS_PROP_KEYS.has(key)) {
         const parts = stylePartsOf(node);
         // Canonicalised HERE so the stored value is what everything downstream keys on: an all-string
         // array becomes one string, and then the pressed variant and isAlreadyPublished work on it
         // exactly as on an authored string. One `typeof` for the common case.
-        parts.className = canonicalClassName(isClassNameValue(value) ? value : undefined);
+        parts.className = canonicalClassName(isClassNameValue(resolved) ? resolved : undefined);
         parts.classStyle = resolveClassName(parts.className);
         pushClassStyle(node, parts);
         return;
@@ -648,11 +1175,9 @@ export function routeProp(node, key, value) {
     if (key === 'style') {
         const parts = stylePartsOf(node);
         // A FUNCTION `style` is `style={({pressed}) => …}`, the idiom this ecosystem actually writes.
-        // A lowering transform normally splits it at build time into `style` + `activeStyle`, so the
-        // engine never sees the callback — but a PUBLIC primitive tag has no transform in front of it
-        // on three adapters, and there the callback arrives here intact. Resolving it makes the
-        // compile-time split an OPTIMIZATION rather than the mechanism, the same relationship
-        // `foldHostBag` has with the compile-time prop folds.
+        // Nothing stands between an app and the tag, so the callback arrives here intact and is
+        // resolved at both states — writing `style` + `activeStyle` as an explicit pair is the same
+        // thing said by hand, and cheaper by one call per recompute.
         //
         // Without this the failure is silent and total: a function is not an `on*` name, so it misses
         // `setEventListener`, lands in `setProp` as a function value, and `fabricProps` drops function
@@ -660,17 +1185,31 @@ export function routeProp(node, key, value) {
         //
         // The callback must be PURE in `pressed`: its result is read once per state, here and under
         // every transform's emission (`core/components/src/state-style.ts` carries the same contract).
-        if (isStyleCallback(value)) {
-            parts.explicitStyle = value({ pressed: false });
-            parts.activeStyle = value({ pressed: true });
+        if (isStyleCallback(resolved)) {
+            parts.explicitStyle = resolved({ pressed: false });
+            parts.activeStyle = resolved({ pressed: true });
             parts.activeStyleFromCallback = true;
         }
         else {
-            parts.explicitStyle = value;
+            // A REBUILT LITERAL EQUAL TO WHAT IS STANDING IS NOT A CHANGE — see `isSameShallowStyle`.
+            //
+            // Gated on something being PUBLISHED, which is what keeps the restore path intact: a
+            // `setNativeProps` write bypasses the parts and clears `parts.published`, and after that this
+            // must never turn a write away — the re-push IS the restore. Same mechanism `isAlreadyPublished`
+            // relies on, and the same reason.
+            //
+            // Gated on the previous write NOT having come from a callback, because that one owns
+            // `parts.activeStyle` and the branch below has to clear it. Returning early would leave the old
+            // pressed look standing under a plain style.
+            if (parts.published !== undefined &&
+                !parts.activeStyleFromCallback &&
+                isSameShallowStyle(resolved, parts.explicitStyle)) {
+                return;
+            }
+            parts.explicitStyle = resolved;
             // Only a variant WE derived is stale now. `style` switching from a callback to a plain value
-            // must not leave the old pressed look standing, and an `activeStyle` the transform wrote must
-            // survive a `style` write, because the two arrive as independent props in an unspecified
-            // order.
+            // must not leave the old pressed look standing, and an AUTHORED `activeStyle` must survive a
+            // `style` write, because the two arrive as independent props in an unspecified order.
             if (parts.activeStyleFromCallback) {
                 parts.activeStyle = undefined;
                 parts.activeStyleFromCallback = false;
@@ -683,18 +1222,45 @@ export function routeProp(node, key, value) {
     // in the app carries an unknown key to native.
     if (key === 'activeStyle') {
         const parts = stylePartsOf(node);
-        parts.activeStyle = value;
+        parts.activeStyle = resolved;
         // Slot 1 is no longer ours, by definition — whatever a callback derived earlier has just been
         // replaced. Without this the flag outlives the value it describes: a callback sets it, this
         // branch overwrites the slot silently, and a later plain `style` then clears a variant the
-        // engine never derived. Not reachable from a lowering transform (it emits either a callback or
-        // an explicit pair, never both for one node), but a flat-bag adapter routes a bag key by key
-        // and can deliver exactly that sequence.
+        // engine never derived. An author writes either a callback or an explicit pair, never both for
+        // one node — but a flat-bag adapter routes a bag key by key and can deliver that sequence.
         parts.activeStyleFromCallback = false;
         pushClassStyle(node, parts);
         return;
     }
-    if (ON_PREFIX.test(key)) {
+    // RN's snapshot affordance (`Pressable.js:222` seeds `usePressState` with it): render the control
+    // pressed with no gesture. It selects `activeStyle` and any `:active` class, which is exactly what
+    // `isPressed` already decides — so it belongs beside `activeStyle` rather than in a behavior.
+    //
+    // HERE RATHER THAN IN `attachAfterCommit`, and the census caught the difference. A behavior hook
+    // reading this prop costs a post-commit WAITER on every pressable in the app — a real boundary
+    // crossing per node, which `adapters/solid/src/crossing-and-payload-census.probe.test.tsx` budgets
+    // at two and which went to six. This branch crosses nothing: it is one string compare on a write
+    // that already reached the tail of `routeProp`, and it lands on the FIRST commit rather than the
+    // second. A JS compare is not a crossing, and weighing it as one is what sent the first attempt to
+    // the wrong seam.
+    //
+    // TouchableHighlight's half of the same prop is NOT here: it PAINTS an underlay, so it is a rule
+    // in `SymbioteFabricProps.cpp`. Two mechanisms, one prop name, because that is what upstream has.
+    // A SIDE EFFECT AND A PASSTHROUGH, not a consume, and the difference is load-bearing in both
+    // directions. The pressed state is set here; the prop ALSO goes on to `node.props`, because
+    // TouchableHighlight's rule reads it off the authored bag to paint its underlay
+    // (`foldTouchableHighlightUnderlay`). Returning early — the first spelling — left that rule blind
+    // and turned three of its cases red. Keeping it out of the PAYLOAD is a separate job and already
+    // done, by `kPressableMachineKeys` in `SymbioteFabricProps.cpp`.
+    //
+    // The same shape `GATED_EVENT_PROPS` uses above: act, then let the write continue.
+    if (key === 'testOnly_pressed')
+        setNodePressed(node, resolved === true);
+    if (isOnEventName(key)) {
+        // A native-driven `Animated.event` needs the native module as well as the listener map, and
+        // registers under the PROP name — see `bindAnimatedEvent`, which no-ops for anything else.
+        if (hasAnimatedNodes())
+            bindAnimatedEvent(node, key, resolved);
         const name = listenerName(key);
         const isRegisteredEvent = RESPONDER_EVENTS.has(name) || isEventFor(node.component, name);
         // Investigation instrumentation (HeaderOptionsScreen unresponsive-buttons bug): RNS* views
@@ -707,106 +1273,247 @@ export function routeProp(node, key, value) {
                 `registered=${isRegisteredEvent} at t=${Date.now()}`);
         }
         if (isRegisteredEvent) {
-            setEventListener(node, name, value);
+            setEventListener(node, name, resolved);
             return;
         }
     }
-    setProp(node, key, value);
+    setProp(node, key, resolved);
 }
-// The same no-op guard as setProp, and here it is strictly stronger: `text` is a string, so
-// `Object.is` is a real value comparison rather than the reference check it degrades to for a style
-// object or a handler. A framework that re-renders a subtree and hands back an unchanged label -
-// every list row whose text did not move, on every update - stops stripping its ancestors of the
-// commit walk's early exit. Counted in the same propStats, because a text write IS a prop write:
-// it lands in node.props.text and reaches Fabric as RCTRawText's only prop.
+// Counted in the same propStats, because a text write IS a prop write: it reaches Fabric as
+// RCTRawText's only prop.
 //
-// Safe against the one ordering hazard worth naming: a raw-text node REPARENTED under a <Text>
-// commits as RCTVirtualText instead of RCTText (viewNameFor, commit.ts). That flip is not driven
-// from here - a structural op marks the parent chain, and reconcile re-checks `committed.parent` on
-// its early-exit path - so a same-text write not marking cannot hide it.
+// Unguarded, unlike the old version, and for the same reason `setProp` is: comparing against the
+// standing text would mean reading it back from the host. The host holds it as a local field and
+// dedupes there. Two consequences it also absorbs, both of which used to be spelled here — a write
+// to or from `''` takes this node out of its parent's renderable child list or puts it back, and a
+// raw text REPARENTED under a `<Text>` commits as RCTVirtualText instead of RCTText.
 export function setText(node, text) {
-    if (Object.is(node.props.text, text)) {
-        propStats.noops += 1;
-        return;
-    }
-    node.props.text = text;
     propStats.writes += 1;
-    markPropsDirty(node);
+    recordSetText(node, text);
 }
-// Structural ops mark the PARENT chain (both the old and the new one), never the moved child:
-// a child that only changed position may legitimately still be clean, and reconcile re-checks
-// `committed.parent` on its early-exit path, so a reparent is caught there rather than by a flag.
+// The structural ops. Each is one op and nothing else: the host detaches the child from whatever
+// parent it currently has before linking it, which is the truth even when an adapter names a stale
+// one — frameworks spell a MOVE as remove-then-insert and can arrive after the insert already
+// re-parented the node. That is why there is no `detach` here any more; JS does not know the old
+// parent and does not need to.
 //
-// Each marks BEFORE touching `parent.children`, never after: the committed record may be aliasing
-// that array, and markStructureDirty is what copies it out of the way. See there.
-function detach(child) {
-    const parent = child.parent;
-    if (!parent)
-        return;
-    markStructureDirty(parent);
-    const index = parent.children.indexOf(child);
-    if (index >= 0)
-        parent.children.splice(index, 1);
-    child.parent = undefined;
+// What they DO still decide in JS is which node an op names, and there are two such redirects — a
+// composed primitive's slot and a wrap claim. Both are read off a field on the node, so a tree with
+// neither pays one load and one branch per op.
+// The host's raw answer, surface INCLUDED — unlike `parentOf` (host-access.ts), which reports a
+// top-level node as parentless by design. The two swaps below have to NAME the holder in an op, and
+// for a wrapped node sitting directly under a surface that holder is the surface node.
+function holderOf(node) {
+    flushOps();
+    const parent = treeHost()?.parentOf(node);
+    return isSymbioteNode(parent) ? parent : undefined;
+}
+// Which node a child actually lands on. See `ISymbioteNode.childHost`: the adapter always names the
+// OWNER, and a node whose behavior built an internal subtree redirects the app's children into it —
+// unless the behavior CLAIMS this particular child, which keeps it on the owner (`claimedChildren`).
+//
+// SINGLE HOP, not a loop, and the field's own comment says why — a chain would put a walk on the
+// engine's hottest path to express a depth no primitive has. A behavior needing depth points
+// `childHost` at the innermost node itself.
+//
+// Reads a field that is `undefined` on every node in every app that registers no composed
+// primitive, so the cost is one load and one branch — deliberately NOT behind `hasHostBehaviors()`,
+// which would be a second read to save nothing. The claim check sits BEHIND that branch, so only a
+// slot-bearing node ever pays the registry probe.
+function hostFor(parent, child) {
+    const slot = parent.childHost;
+    if (slot === undefined)
+        return parent;
+    // A slot that is a built SIBLING rather than a container — ImageBackground's absolutely-filled
+    // image — keeps the app's children on the owner. See `IHostBehavior.slotTakesNoChildren`.
+    if (!slotTakesChildren(parent))
+        return parent;
+    return claimModeFor(parent, child.component) === undefined ? slot : parent;
+}
+// The node a child must be inserted BEFORE, or `undefined` for an ordinary append.
+//
+// A host that STILL has a slot at this point is an owner taking a CLAIMED child, and that child
+// goes before the slot whatever the framework asked for. RN renders `{refreshControl}{content}` in
+// that order, and the node a framework names as `beforeChild` lives inside the slot, so the host
+// could not place against it here anyway.
+//
+// A SIBLING slot is the opposite placement: RN paints the background image first and the app's
+// children over it (ImageBackground.js:80-102), so they append past it rather than in front of it —
+// which is what `undefined` here leaves alone.
+function slotAnchorOf(host) {
+    const slot = host.childHost;
+    if (slot === undefined || !slotTakesChildren(host))
+        return undefined;
+    return slot;
+}
+// ── the two structural recorders, and why nothing here calls the raw ones ───────────────────────
+//
+// `mayHaveChildren` is only sound if EVERY op that gives a node a child raises it. There are five
+// such call sites in this file and a sixth is a plausible future edit, so the bit is raised here
+// rather than at each of them: a site that forgets would make `childrenOf` answer "empty" for a node
+// that has children, which is a wrong ANSWER rather than a slow one. `node.ts` is the only module
+// that records a structural op, so these two are a complete funnel.
+/**
+ * Arm a parent's recurring post-commit hook for a STRUCTURAL change.
+ *
+ * A prop write is not the only thing a behavior can be waiting for, and the ScrollView sticky-header
+ * machine is the case that proves it: it drops a wrapper when the framework takes the wrapped child
+ * away, which writes no prop on the wrapper's owner at all. Narrowing the beat to prop writes alone
+ * left it holding a wrapper around nothing, and its own test said so — the third behavior needing
+ * the beat, and the only one whose source comment does not say why.
+ */
+function armCommitHookForChildChange(parent) {
+    if (parent.hasCommitHook)
+        noteCommitHookNodeChanged(parent);
+}
+function recordAppendInto(parent, child) {
+    parent.mayHaveChildren = true;
+    armCommitHookForChildChange(parent);
+    recordAppendChild(parent, child);
+}
+function recordInsertInto(parent, child, beforeChild) {
+    parent.mayHaveChildren = true;
+    armCommitHookForChildChange(parent);
+    recordInsertBefore(parent, child, beforeChild);
+}
+// What actually occupies this node's place in its parent's child list. See `ISymbioteNode.wrapper`:
+// a wrapped owner is what the adapter names and the wrapper is what the tree holds, so every
+// structural op takes the owner and moves the wrapper.
+function placedNode(node) {
+    return node.wrapper ?? node;
 }
-export function appendChild(parent, child) {
+// Make `child` the owner's parent, in place. Returns false when this is not a wrap claim, so the
+// two inserts fall through to the ordinary path on one call.
+//
+// The owner being UNATTACHED is the normal case rather than the edge one: every adapter fills a
+// node's children before appending it to its own parent, so the wrap usually happens while the
+// owner has no holder and only the second op runs. The later `appendChild(root, owner)` then
+// inserts the wrapper instead, because `placedNode` says so.
+function wrapsOwner(owner, child) {
+    if (owner.childHost === undefined)
+        return false;
+    if (claimModeFor(owner, child.component) !== 'wrap')
+        return false;
+    if (hasHostBehaviors())
+        reattachHostBehaviors(child);
+    if (hasAnimatedBindings())
+        reattachAnimatedProps(child);
+    const holder = holderOf(owner);
+    // Wrapper takes the owner's place first, then the owner moves under it — the host's own detach
+    // on link is what unlinks the owner from `holder`, so no removal op is needed.
+    if (holder !== undefined)
+        recordInsertInto(holder, child, owner);
+    owner.wrapper = child;
+    recordAppendInto(child, owner);
+    return true;
+}
+// Put the owner back where its wrapper stood — the mirror of `wrapsOwner`. It must leave the owner
+// ATTACHED: the framework is removing the RefreshControl, not the ScrollView.
+function unwrapsOwner(owner, child) {
+    if (owner.wrapper !== child)
+        return false;
+    owner.wrapper = undefined;
+    const holder = holderOf(child);
+    if (holder === undefined) {
+        // The wrapper never reached a parent, so there is no place to take back — the owner simply
+        // stops hanging off it.
+        recordRemoveChild(child, owner);
+    }
+    else {
+        recordInsertInto(holder, owner, child);
+        recordRemoveChild(holder, child);
+    }
+    return true;
+}
+export function appendChild(requestedParent, child) {
+    if (wrapsOwner(requestedParent, child))
+        return;
+    const parent = hostFor(requestedParent, child);
     // A node the sweep tore down can be put back — Svelte parks live subtrees offscreen across
     // commits. A WeakSet miss for anything freshly built, so the create path pays nothing.
     if (hasHostBehaviors())
         reattachHostBehaviors(child);
-    detach(child);
-    markStructureDirty(parent);
-    child.parent = parent;
-    parent.children.push(child);
+    if (hasAnimatedBindings())
+        reattachAnimatedProps(child);
+    const placed = placedNode(child);
+    const anchor = slotAnchorOf(parent);
+    if (anchor === undefined)
+        recordAppendInto(parent, placed);
+    else
+        recordInsertInto(parent, placed, anchor);
+    if (hasHostBehaviors())
+        notifyChildInserted(parent, placed);
 }
-export function insertBefore(parent, child, beforeChild) {
+// NO ANCHOR MEANS APPEND, and it is a real call rather than a defensive guard: solid-js/universal
+// spells "insert at the end" as `insertNode(parent, node, null)` and Vue's runtime-core passes
+// `anchor` straight through as `null`. The old retained tree collapsed it silently — `indexOf(null)`
+// is -1, and the insert fell through to a push. On the wire it cannot: a slot has to name a node, so
+// an unanchored insert IS an append and is recorded as one.
+export function insertBefore(requestedParent, child, beforeChild) {
+    if (wrapsOwner(requestedParent, child))
+        return;
+    const parent = hostFor(requestedParent, child);
     if (hasHostBehaviors())
         reattachHostBehaviors(child);
-    detach(child);
-    markStructureDirty(parent);
-    child.parent = parent;
-    const index = parent.children.indexOf(beforeChild);
-    parent.children.splice(index < 0 ? parent.children.length : index, 0, child);
+    if (hasAnimatedBindings())
+        reattachAnimatedProps(child);
+    const placed = placedNode(child);
+    const anchor = slotAnchorOf(parent) ??
+        (beforeChild === null || beforeChild === undefined
+            ? undefined
+            : placedNode(beforeChild));
+    if (anchor === undefined)
+        recordAppendInto(parent, placed);
+    else
+        recordInsertInto(parent, placed, anchor);
+    if (hasHostBehaviors())
+        notifyChildInserted(parent, placed);
 }
 // Removal only NOMINATES a behavior for teardown; the commit sweep decides. A framework may spell
 // a move as remove-then-reinsert (Solid does), so tearing down here kills the machine of a node
 // that comes back alive in the same batch — see host-behavior.ts's markDetachCandidate.
-export function removeChild(parent, child) {
-    if (hasHostBehaviors())
+export function removeChild(requestedParent, child) {
+    // A wrap claim leaving: the owner takes its own place back and stays in the tree. Nominated for
+    // teardown like any other removed node, because the wrapper IS leaving.
+    if (unwrapsOwner(requestedParent, child)) {
+        if (hasAttachedBehaviors() || hasAnimatedBindings())
+            markDetachCandidate(child);
+        return;
+    }
+    // A slot that IS the child being removed stops being one. Only a behavior that adopts an APP
+    // child as its slot can reach this (`onChildInserted`); a `buildStructure` slot is internal and
+    // no framework removes it. Without the clear, `hostFor` below redirects the removal INTO the very
+    // node being removed, and the child stays committed under a parent the framework believes it
+    // left — and the NEXT child appended nests inside the orphan.
+    if (requestedParent.childHost === child)
+        requestedParent.childHost = undefined;
+    // Redirected for the same reason the two inserts are: the adapter removes from the node it
+    // appended to, which is the OWNER, while the child actually lives in the slot.
+    const parent = hostFor(requestedParent, child);
+    // `hasAttachedBehaviors`, NOT `hasHostBehaviors`: the second is on from module load in every app,
+    // because registering `Pressable` as a TYPE arms it. Nominating a candidate makes the commit sweep
+    // cross every removed node into JS — 10 000 handles on a 1 000-row clear, measured at 3.2x the
+    // whole teardown — and none of it can matter before a behavior has actually attached to something.
+    if (hasAttachedBehaviors() || hasAnimatedBindings())
         markDetachCandidate(child);
-    markStructureDirty(parent);
-    const index = parent.children.indexOf(child);
-    if (index >= 0)
-        parent.children.splice(index, 1);
-    child.parent = undefined;
+    // BOTH, and the owner is the one that matters: a composed primitive's behavior lives on the node
+    // the adapter named, while `hostFor` redirects the mutation into its internal slot. Arming only
+    // the slot arms a node that has no behavior at all.
+    armCommitHookForChildChange(requestedParent);
+    armCommitHookForChildChange(parent);
+    recordRemoveChild(parent, placedNode(child));
 }
+/**
+ * A structural census of the tree the HOST holds — see `ITreeCensus` (tree-host.ts) for what each
+ * number is for and why the anchor count says more about the adapter than about the app.
+ *
+ * It walks nothing here: the walk needs `props.text` to tell an empty raw text from a real one, and
+ * a child list to measure a flatten width, and JS has neither. `undefined` from `treeHost()` means
+ * nothing is installed, and the empty census is the honest answer — every probe that reads this
+ * asserts against a mounted tree, so a zero from an uninstalled host cannot be mistaken for one from
+ * an empty one.
+ */
 export function censusRetainedTree(roots) {
-    const census = {
-        nodes: 0,
-        anchors: 0,
-        emptyRawTexts: 0,
-        renderable: 0,
-        flattenWidths: [],
-    };
-    // Explicit stack, not recursion: a deep list under a benchmark screen would blow the JS stack
-    // on the very tree this is meant to measure.
-    const stack = [...roots];
-    while (stack.length > 0) {
-        const node = stack.pop();
-        if (node === undefined)
-            break;
-        census.nodes += 1;
-        if (isAnchor(node))
-            census.anchors += 1;
-        else if (isEmptyRawText(node))
-            census.emptyRawTexts += 1;
-        else
-            census.renderable += 1;
-        if (node.children.some(child => isAnchor(child) || isEmptyRawText(child)))
-            census.flattenWidths.push(node.children.length);
-        for (const child of node.children)
-            stack.push(child);
-    }
-    census.flattenWidths.sort((left, right) => right - left);
-    return census;
+    flushOps();
+    return treeHost()?.census(roots) ?? EMPTY_CENSUS;
 }