@symbiote-native/engine 0.5.0 → 1.1.0

package/build/fabric-props.js

@@ -1,21 +1,37 @@
-// Fabric-prop translation: turn a retained node's logical props into the flat payload
-// Fabric's C++ props expect. Split out of commit.ts (which owns the reconciler/mirror walk
-// + the imperative instance API, neither of which this half touches) so the two
-// responsibilities stop sharing one 300+ line file. Color processing itself lives in
-// ./platform-color (the stable leaf every color-touching module imports from); this file only
-// decides WHICH props are color props and wires the structured CSS-style processors.
-import { foldAriaProps } from './accessibility-props.js';
+// Fabric-prop translation: turn a node's logical props into the flat payload Fabric's C++ props
+// expect. Color processing itself lives in ./platform-color (the stable leaf every color-touching
+// module imports from); this file only decides WHICH props are color props and wires the structured
+// CSS-style processors.
+//
+// IT IS CALLED BY THE HOST, and that is what the `props` parameter is for. The NODE still comes in
+// beside it for its authored component name and for a behavior's own `payloadFold`.
+//
+// **THIS IS THE HEADLESS BUILDER, and the device one is `SymbioteFabricProps.cpp`.** The header used
+// to say the C++ side "does not have this yet", which was true mid-branch and stopped being true
+// when the payload builder was ported; a reader who believed it would go looking for a blank screen.
+//
+// What follows from that, and it is the file's main rule: **no platform rule may live here.** The ten
+// tag rules never got a copy, and RN's two Text defaults lost theirs on 2026-09-18. A rule with a
+// copy on this side is a rule whose only test runs on this side, and the device copy can then break
+// with everything green — not hypothetical: it is how a disabled `touchable-highlight` shipped
+// `focusable: true`.
+//
+// **NONE IS LEFT, as of 2026-09-18.** Three went, one per commit, in that order: RN's Text defaults,
+// `value ?? defaultValue -> text`, and the aria fold. Separately on purpose — they had different test
+// topologies, and one commit removing several could not be attributed to any of them.
+//
+// SO THE HEADLESS PAYLOAD DIVERGES FROM THE DEVICE'S, deliberately and in named places: a text
+// input's carries `value` where the device's carries `text`, a text node's is missing two defaults,
+// and a bare tag's `aria-*` keys arrive unfolded. **That asymmetry is the harness working as
+// designed** — it is what forces a claim about a platform rule to be made where the rule runs. Do
+// not close it by adding a rule back.
+//
+// What is left is the framework-agnostic half: colour processing, the style hoist, and a node's own
+// `payloadFold`.
 import { RAW_TEXT_COMPONENT } from './node.js';
-import { registeredProcessor } from './registry.js';
 import { isProcessableColor, processColor } from './platform-color/index.js';
-import { processBoxShadow } from './process-box-shadow/index.js';
-import { processFilter } from './process-filter.js';
-import { processTransformOrigin } from './process-transform-origin/index.js';
-import { processTransform } from './process-transform/index.js';
-import { processAspectRatio } from './process-aspect-ratio.js';
-import { processFontVariant } from './process-font-variant.js';
-import { processBackgroundImage } from './process-background-image/index.js';
-import { isRecord, isString } from './type-guards.js';
+import { configProcessedKeys } from './registry.js';
+import { isRecord } from './type-guards.js';
 // Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++
 // color parser silently drops strings. The actual conversion (processColor) is
 // RN-platform-specific, so it is injected in platform-color.ts rather than imported,
@@ -63,103 +79,26 @@ const COLOR_PROPS = new Set([
     'trackColorForFalse',
     'trackTintColor',
 ]);
-// Structured CSS-style keys RN parses in JS before native (boxShadow/filter register
-// with enableNativeCSSParsing(), which DEFAULTS TO FALSE, so native CSS parsing is off
-// and the raw string is dropped). Each runs on the hoisted top-level style key, turning
-// a CSS string or structured array into the processed array Fabric's C++ expects.
-const STYLE_PROCESSORS = new Map([
-    ['boxShadow', value => processBoxShadow(asBoxShadowInput(value))],
-    ['filter', value => processFilter(asFilterInput(value))],
-    [
-        'transformOrigin',
-        value => processTransformOrigin(asTransformOriginInput(value)),
-    ],
-    ['transform', processTransformValue],
-    ['aspectRatio', value => processAspectRatio(asAspectRatioInput(value))],
-    ['fontVariant', value => processFontVariant(asFontVariantInput(value))],
-    [
-        'experimental_backgroundImage',
-        value => processBackgroundImage(asBackgroundImageInput(value)),
-    ],
-]);
-// boxShadow accepts a CSS string or an array of shadow objects; anything else is
-// undefined to processBoxShadow (which returns []). Narrowing avoids an `as` cast.
-function asBoxShadowInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// filter accepts a CSS string or an array of single-key filter objects; same narrowing.
-function asFilterInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// experimental_backgroundImage accepts a CSS string (gradient functions) or an array of
-// structured gradient objects; same narrowing as boxShadow/filter.
-function asBackgroundImageInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// transformOrigin accepts a CSS string or a [x, y, z] array of strings/numbers; anything
-// else is undefined to processTransformOrigin (which defaults to center/center/0).
-function asTransformOriginInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isStringOrNumber);
-    return undefined;
-}
-// aspectRatio accepts a number (the common, working form) or a ratio string; otherwise
-// undefined, which processAspectRatio drops.
-function asAspectRatioInput(value) {
-    if (typeof value === 'number' || typeof value === 'string')
-        return value;
-    return undefined;
-}
-// fontVariant accepts an array of variant strings (the common, working form) or a
-// space-separated string; anything else becomes an empty string, which yields [].
-function asFontVariantInput(value) {
-    if (typeof value === 'string')
+// Convert a prop to the shape Fabric's C++ expects: a CSS-string color runs through the injected
+// platform processor, because Fabric's C++ color parser silently drops strings.
+//
+// TWO FAMILIES OF PROCESSOR USED TO BE HERE AND BOTH MOVED, for one reason: on a device the payload
+// is built in C++ and this function does not run, so anything resolved only here is resolved only
+// headless. A third-party view's own `validAttributes[*].process` now runs in `configPayloadFold`
+// (installed on the node, called by the C++ through `payloadFold`); the structured style keys
+// — boxShadow, filter, transform, transformOrigin, aspectRatio, fontVariant,
+// experimental_backgroundImage — now run at WRITE time in `structured-style.ts`, so `node.props`
+// already holds the structured value whichever builder reads it.
+//
+// Neither may come back here. Applying a processor twice is not a no-op: a color already converted
+// to a platform int, run through processColor again, is a DIFFERENT color.
+function processValue(key, value, alreadyProcessed) {
+    // A key the component's own config already converted is DONE. Running the engine's colour pass
+    // over it as well is not a no-op: processColor rotates, so a second rotation is a different
+    // colour. This used to be prevented by accident — a processed colour is a number, and numbers
+    // were not processable — until a numeric colour became an author's own rrggbbaa literal.
+    if (alreadyProcessed?.has(key) === true)
         return value;
-    if (Array.isArray(value))
-        return value.filter(isString);
-    return '';
-}
-// transform accepts a CSS string (processTransform parses it) or an array of single-key
-// transform records (the hot animated / sticky-header path, passed through unchanged).
-// A non-string non-array value is NOT dropped: it may already be processed, so it passes
-// through verbatim rather than being coerced to [] (which would erase a valid transform).
-function processTransformValue(value) {
-    if (typeof value === 'string')
-        return processTransform(value);
-    if (Array.isArray(value))
-        return processTransform(value.filter(isRecord));
-    return value;
-}
-function isStringOrNumber(value) {
-    return typeof value === 'string' || typeof value === 'number';
-}
-// Convert a prop to the shape Fabric's C++ expects. A third-party view contributes
-// its own processors, auto-derived from its ViewConfig (validAttributes[*].process,
-// e.g. processColor for a slider's track tints); those run first. Then the structured
-// CSS-style processors (boxShadow/filter). Built-ins are never in the registry, so they
-// fall through to the global color path, where any CSS-string color is run through the
-// injected platform processor (Fabric's C++ color parser silently drops strings).
-function processValue(component, key, value) {
-    const processor = registeredProcessor(component, key);
-    if (processor !== undefined)
-        return processor(value);
-    const styleProcessor = STYLE_PROCESSORS.get(key);
-    if (styleProcessor !== undefined)
-        return styleProcessor(value);
     if (COLOR_PROPS.has(key) && isProcessableColor(value))
         return processColor(value);
     return value;
@@ -170,8 +109,10 @@ function processValue(component, key, value) {
 // of style objects, and resolving each one per node costs O(nodes x styleKeys) to compute an
 // answer that only varies with O(distinct styles). Cache it on the style object's identity.
 //
-// Keyed by component as well: processValue consults that component's ViewConfig processors, so one
-// style object can legitimately resolve differently under two view names.
+// Keyed by the style object ALONE. It used to carry a per-component dimension because processValue
+// consulted that component's ViewConfig processors and one style object could resolve differently
+// under two view names; those processors moved to `configPayloadFold`, which runs on the top-level
+// bag before this, so what is left here is component-independent.
 //
 // The cache assumes a style object is not MUTATED IN PLACE, which is already the engine's contract:
 // setProp compares with Object.is and skips a same-identity write, so an in-place style edit never
@@ -183,23 +124,22 @@ function processValue(component, key, value) {
 // style entry, and addStyle below needs to see an explicit `undefined` to let a later entry clear
 // an earlier one. Dropping them here would silently turn `[{flex:1},{flex:undefined}]` into
 // `flex: 1`.
-const styleCache = new Map();
-function processedStyle(component, style) {
-    let perComponent = styleCache.get(component);
-    if (perComponent === undefined) {
-        perComponent = new WeakMap();
-        styleCache.set(component, perComponent);
-    }
-    const cached = perComponent.get(style);
+const styleCache = new WeakMap();
+function processedStyle(style) {
+    const cached = styleCache.get(style);
     if (cached !== undefined)
         return cached;
     const resolved = {};
     for (const key of Object.keys(style)) {
         const value = style[key];
+        // `undefined` for the already-processed set, and it must stay that way: this cache is keyed on
+        // the style object ALONE (see the note above), so anything component-dependent read here would
+        // be shared with every other component using the same style object. A config's processors are
+        // keyed on top-level prop names and never reach inside a style anyway.
         resolved[key] =
-            value === undefined ? undefined : processValue(component, key, value);
+            value === undefined ? undefined : processValue(key, value, undefined);
     }
-    perComponent.set(style, resolved);
+    styleCache.set(style, resolved);
     return resolved;
 }
 /**
@@ -229,15 +169,15 @@ function processedStyle(component, style) {
  * overlap in practice (one is Yoga/visual, the other is testID/accessibility/source), so this is
  * theoretical - but it is a difference, and `fabric-props.test.ts` pins both halves.
  */
-function addStyle(out, component, style) {
+function addStyle(out, style) {
     if (Array.isArray(style)) {
         for (const entry of style)
-            addStyle(out, component, entry);
+            addStyle(out, entry);
         return;
     }
     if (!isRecord(style))
         return;
-    const resolved = processedStyle(component, style);
+    const resolved = processedStyle(style);
     for (const key of Object.keys(resolved)) {
         const value = resolved[key];
         if (value === undefined)
@@ -250,51 +190,24 @@ function addStyle(out, component, style) {
 // props expect: `style` keys are hoisted to the top level, event handlers and
 // undefined values are dropped.
 // RN HAS NO `value` FABRIC PROP. A TextInput's controlled value rides as the private `text` prop,
-// and the fold that produces it — `value ?? defaultValue` — lives in the component wrapper
-// (`core/components/src/view/render-text-input.ts`, whose own comment says "There is no `value`
-// Fabric prop; this is the whole controlled surface"). A LOWERED element has no wrapper, so a
-// transform printing the author's `value={x}` yields a key no ViewConfig declares: silently dropped,
-// `text` never set, and the field renders EMPTY. Nothing red anywhere — found 2026-08-31 by an agent
-// reading what the render function actually emits rather than trusting a header comment.
+// and the fold that produces it — `value ?? defaultValue` — used to live in the component wrapper.
+// A tag has no wrapper, so an author's `value={x}` would reach Fabric as a key no ViewConfig
+// declares: silently dropped, `text` never set, and the field renders EMPTY. Nothing red anywhere —
+// found 2026-08-31 by an agent reading what the render function actually emitted rather than
+// trusting a header comment.
 //
-// So the fold moves to the layer every path goes through, exactly like the aria fold above it. This
-// is the third instance of one rule: a lowered element inherits NOTHING its wrapper did, and the
-// repair belongs below the fork, never in the transform.
+// So the fold lives in the layer every path goes through, exactly like the aria fold above it. This
+// is the third instance of one rule: a tag inherits NOTHING a wrapper did, and the repair belongs
+// below the fork.
 //
 // GATED ON THE COMPONENT, NOT ON THE PROP. `value` is also a prop of `Switch` and `Slider`; a fold
 // keyed on the prop name would write a bogus `text` onto both. Two string comparisons rather than a
-// Set lookup — this runs per node per commit, and the set has exactly two members.
-//
-// The engine may hold this because both views are in `BUILTIN_COMPONENTS`, whose hand-tuned tables
-// (`view-config.ts`'s TEXT_INPUT_EVENTS, commit's COLOR_PROPS) already live here for the same
-// reason. Routing it through `registerComponent` was tried first and is WRONG: `resolve()`
-// short-circuits every builtin to EMPTY, so the registration would have been accepted and never
-// applied.
-const SINGLELINE_TEXT_INPUT = 'RCTSinglelineTextInputView';
-const MULTILINE_TEXT_INPUT = 'RCTMultilineTextInputView';
-function foldTextInputValue(props) {
-    const hasValue = props.value !== undefined;
-    const hasDefault = props.defaultValue !== undefined;
-    if (!hasValue && !hasDefault)
-        return props;
-    const folded = { ...props };
-    // `value` WINS over `defaultValue` — `foldText`'s rule, kept identical rather than re-derived.
-    // An explicit `text` is left alone: that is the component path, where the wrapper already folded,
-    // and re-folding there would let a stale `value` overwrite what the wrapper computed.
-    if (folded.text === undefined) {
-        folded.text = hasValue ? props.value : props.defaultValue;
-    }
-    // Blanked, not deleted: `fabricProps` skips undefined, and neither name is a real Fabric prop.
-    folded.value = undefined;
-    folded.defaultValue = undefined;
-    return folded;
-}
-export function fabricProps(node) {
+export function fabricProps(node, nodeProps) {
     if (node.component === RAW_TEXT_COMPONENT) {
         // A raw-text node gets its behavior's fold too — it TRANSFORMS the text that is already there
         // (Button uppercases its label on Android) and may not SUPPLY one, which is narrower than this
         // comment claimed when it landed. `isEmptyRawText` (node.ts) decides whether the node commits
-        // at all from `node.props.text`, before any fold runs, so a text that exists only as a fold
+        // at all from the node's own `text` prop, before any fold runs, so a text that exists only as a fold
         // result is dropped by `renderableChildren` and the fold never executes. Reported by the hook's
         // first consumer, within the hour.
         //
@@ -304,8 +217,8 @@ export function fabricProps(node) {
         // so the skip and the fold read the same source and an empty title still commits nothing.
         return {
             text: node.payloadFold !== undefined
-                ? node.payloadFold(node.props).text
-                : node.props.text,
+                ? node.payloadFold(nodeProps).text
+                : nodeProps.text,
         };
     }
     // This runs once per node per commit - 9 000 times on one benchmark press - so the two loops
@@ -324,26 +237,45 @@ export function fabricProps(node) {
     const out = {};
     // THE ONE POINT WHERE THE WHOLE BAG IS KNOWN ON EVERY PATH, which is what the aria fold needs:
     // `aria-checked` has to be folded against a sibling `accessibilityState`, and `routeProp` sees
-    // one key at a time. Both commit paths — create and update — reach here, so a lowered element
-    // gets the fold it has no wrapper to run.
+    // one key at a time. Both commit paths — create and update — reach here, so a tag gets the fold
+    // it has no wrapper to run.
     //
-    // NOT memoised on `node.props` identity. That object is stable and mutated IN PLACE, so an
-    // identity-keyed cache (the `processedStyle` pattern below) would be stale forever. The gate is
-    // the node's sticky flag instead: one boolean read for a node with no alias, which is nearly all
-    // of them, and the fold's own fast path returns by identity for the rest.
-    const aliasFolded = node.hasAriaAlias
-        ? foldAriaProps(node.props)
-        : node.props;
-    // The behavior's own fold, for a LOWERED element only — the two folds above are keyed on the
-    // component name, which a wrapper and its lowered twin share, so neither could carry a
-    // per-primitive fold without running it twice on the wrapper. See IPayloadFold.
+    // NOT memoised on the bag's identity. The host mutates it IN PLACE, so an identity-keyed cache
+    // (the `processedStyle` pattern below) would be stale forever. The gate is the node's sticky flag
+    // instead: one boolean read for a node with no alias, which is nearly all of them, and the fold's
+    // own fast path returns by identity for the rest.
+    // THE ARIA FOLD IS NOT CALLED HERE ANY MORE (2026-09-18), and it is the last platform rule to
+    // leave this builder. `foldAriaProps` itself STAYS in JS and is not a mirror: `pickAccessibilityProps`
+    // (`@symbiote-native/components`) folds a bag and then picks fields BY NAME, which it cannot do
+    // from a bag holding only `aria-label`. So the function has a real, load-bearing caller — what was
+    // wrong was this CALL, which put a rule the device runs in C++ back into the headless payload and
+    // invited 27 cases to assert it where the device copy is invisible.
+    //
+    // Where the claims live now: `core/engine/cpp/tests/js/aria-payload.itest.ts`, off a real payload.
+    const aliasFolded = nodeProps;
+    // The behavior's own fold, keyed on the TAG — the two folds above are keyed on the resolved
+    // component name, which several tags share (`pressable` and a plain `view` are both `RCTView`),
+    // so neither could carry a per-primitive fold. See IPayloadFold.
+    //
+    // THE FOLD'S RETURN REPLACES THE BAG, and it costs more than it looks — see
+    // `payload-fold-merge.test.ts` for the measurement and for why the obvious fix does not fit yet.
+    // Briefly: every fold returns `{ ...props, ...whatItChanged }`, and on device reading that back is
+    // `jsi::dynamicFromValue`, 13.3 ms of a 17.8 ms fold phase against 1.6 ms to send the bag out and
+    // 1.6 ms to run the fold.
     const behaviorFolded = node.payloadFold !== undefined
         ? node.payloadFold(aliasFolded)
         : aliasFolded;
-    const props = node.component === SINGLELINE_TEXT_INPUT ||
-        node.component === MULTILINE_TEXT_INPUT
-        ? foldTextInputValue(behaviorFolded)
-        : behaviorFolded;
+    // RN'S TWO TEXT DEFAULTS USED TO BE APPLIED HERE AND ARE GONE (2026-09-18) — the rule lives in
+    // `SymbioteFabricProps.cpp` alone, and its claims in `committed-payload.itest.ts`, read off the
+    // payload a commit actually sent. It had FIVE other implementations that day (`resolveTextProps`,
+    // Angular's `TextHost`, Vue's and Solid's renderers, and this one); the engine is the only layer
+    // that can see the authored bag for every adapter at once, so it is the only one that needs to.
+    //
+    // So a text node's payload here is missing two keys the device's carries. That is a PROPERTY of
+    // this harness rather than a gap in it — do not close it by adding the rule back.
+    const props = behaviorFolded;
+    // Hoisted out of the loop: one cached lookup per node per commit, not one per key.
+    const alreadyProcessed = configProcessedKeys(node.component);
     for (const key of Object.keys(props)) {
         if (key === 'style')
             continue;
@@ -352,10 +284,10 @@ export function fabricProps(node) {
             continue;
         if (value === undefined)
             continue;
-        out[key] = processValue(node.component, key, value);
+        out[key] = processValue(key, value, alreadyProcessed);
     }
     // Hoist the style slot (object | array | nested arrays) into the SAME payload object - no
     // intermediate flatten. See addStyle for the shape and for the two things this fixed.
-    addStyle(out, node.component, props.style);
+    addStyle(out, props.style);
     return out;
 }

package/build/fabric.d.ts

@@ -36,5 +36,14 @@ interface IFabricHost extends Omit<IFabricSlot, 'cloneNodeWithNewChildren' | 'cl
 declare global {
     var nativeFabricUIManager: IFabricHost | undefined;
 }
+/**
+ * Test seam: forget the bound slot, so a fixture can install a different host and be believed.
+ *
+ * `getSlot` caches the facade for the life of the module — the live binding re-mints a host function
+ * on every property read, so caching is not an optimisation but the difference between reading each
+ * method once and reading it per call. The cache has no invalidation in production because the
+ * global is installed once, before anything commits.
+ */
+export declare function resetSlot(): void;
 export declare function getSlot(): IFabricSlot;
 export {};

package/build/fabric.js

@@ -5,7 +5,27 @@
 // The live object is a lazy caching proxy: every property access mints a fresh
 // host function, so we read each method once and cache a plain facade.
 import { dlog } from './debug.js';
+import { installNativeTreeHost } from './native-tree-host.js';
 let cached;
+// BATCHING IS GONE, and it is worth one paragraph because the idea recurs. `batching-slot.ts`
+// recorded this slot's calls and replayed them once per commit — three ways, the last handing the
+// bytes to `SymbioteApplier` in C++. It existed to remove per-call JSI crossings from a JS walk that
+// worked out the Fabric operations. That walk no longer exists: adapters record their own mutations
+// and the tree host derives everything, so there are no per-call crossings left to batch. Removed
+// 2026-09-08 along with `setBatchedCommits`, the C++ applier and their differential. Root CLAUDE.md
+// keeps the measurement that made it uninteresting even on the old path — Create 256.8 on / 258.5
+// off, i.e. it demonstrably worked and bought nothing.
+/**
+ * Test seam: forget the bound slot, so a fixture can install a different host and be believed.
+ *
+ * `getSlot` caches the facade for the life of the module — the live binding re-mints a host function
+ * on every property read, so caching is not an optimisation but the difference between reading each
+ * method once and reading it per call. The cache has no invalidation in production because the
+ * global is installed once, before anything commits.
+ */
+export function resetSlot() {
+    cached = undefined;
+}
 export function getSlot() {
     if (cached)
         return cached;
@@ -72,5 +92,17 @@ export function getSlot() {
         measureLayout: (node, relativeToNode, onFail, onSuccess) => measureLayout(node, relativeToNode, onFail, onSuccess),
     };
     dlog('slot bound to nativeFabricUIManager');
+    // Resolve our own native module here, once, for its SIDE EFFECT: `RCTTurboModuleManager` runs
+    // `installJSIBindingsWithRuntime:` when it CREATES a module, so without this call the module is
+    // never created, the hook never runs, and `global.__symbioteEngineNative` is absent on a device
+    // carrying a perfectly working binary. A capability that is unreachable until its first consumer
+    // lands is indistinguishable from one that is broken, and the difference costs a build to find out.
+    //
+    // This is the right seam rather than a convenient one, and now for two reasons: binding the Fabric
+    // slot is the moment the engine has established it is on a native host at all, AND it is the last
+    // moment before a commit can happen — the tree host has to be in before `commitSurfaceOps` runs or
+    // the ops it names stay pending. It cannot throw: with no module `installNativeTreeHost()` is a
+    // no-op, which is most places (see `native-engine.ts`'s header).
+    installNativeTreeHost();
     return cached;
 }

package/build/host-access.d.ts

@@ -0,0 +1,145 @@
+import { type ISymbioteNode } from './node';
+import type { SymbioteSurface } from './surface';
+/**
+ * The node's parent, or `undefined` for a node that sits directly under a surface.
+ *
+ * A top-level node answers `undefined` even though a surface IS a node in the host's tree, and the
+ * three adapters depend on that exact miss: Angular reads `null` as "defer, `<ng-content>` will place
+ * this", while Vue and Solid spell `?? surface` at their call sites and compare the result against
+ * the `SymbioteSurface` object, which the surface's anchor node is not. `SURFACE_COMPONENT` is the
+ * sentinel that stops the answer there.
+ *
+ * So `undefined` is not the same question as "is this node attached".
+ *
+ * IT DOES NOT ALWAYS DRAIN, unlike its neighbours. A node's parent link changes only through an op
+ * that names it as the CHILD, so a node the pending batch has not placed already has its final
+ * answer standing in the host — see `hasPendingPlacement`. Angular's 1 000-row create asks this
+ * 1 000 times (its `addLViewToLContainer` calls `renderer.parentNode` once per embedded view) and
+ * exactly ONE of those reads was about a node the batch had touched.
+ */
+export declare function parentOf(node: ISymbioteNode): ISymbioteNode | undefined;
+/**
+ * The node's children, INCLUDING anchors.
+ *
+ * Anchors are structural bookkeeping — the commit skips them — but they are not invisible to
+ * traversal, and hiding them here would desync a framework runtime from the tree it built:
+ * solid-js/universal keeps its own record of what it inserted and re-derives positions through these
+ * lookups, so a node it placed must be a node it can find.
+ */
+export declare function childrenOf(node: ISymbioteNode): readonly ISymbioteNode[];
+/**
+ * Every node's parent, positionally, in ONE crossing — `parentOf` for a list.
+ *
+ * Engine-internal, like `subtreesOf` below, and for the same reason: what a framework seam needs is
+ * the singular form, one step at a time. These two answer the question only TEARDOWN asks, and
+ * teardown is the one lifecycle event whose size is the tree's (see `ITreeHost`).
+ *
+ * A `SURFACE_COMPONENT` parent reads as `undefined` here exactly as it does in `parentOf`, so the
+ * two agree element for element.
+ */
+export declare function parentsOf(nodes: readonly ISymbioteNode[]): readonly (ISymbioteNode | undefined)[];
+/** Each root and every descendant, pre-order, anchors included — all of it in ONE crossing. */
+export declare function subtreesOf(roots: readonly ISymbioteNode[]): readonly ISymbioteNode[];
+/**
+ * The same walk narrowed to what a teardown must visit — see `ITreeHost.teardownSubtreesOf`.
+ *
+ * The gate is the ANIMATED one, not a behavior one: a binding is per node and carries no tag, so an
+ * app that animates needs every node back and gets the full walk. Nothing else narrows, because
+ * nothing else is charged per node of a removed subtree.
+ */
+export declare function teardownSubtreesOf(roots: readonly ISymbioteNode[]): readonly ISymbioteNode[];
+/**
+ * The node and every ancestor above it, deepest first, in ONE crossing.
+ *
+ * `parentOf` per level is a crossing per level, and the event path needs this chain for every
+ * event — capture reads it reversed, bubble forward — plus again on every frame of a drag, for the
+ * responder's scope. Measured at 18 crossings per event on a depth-8 chain before the two phases
+ * shared a walk, 9 after, and 1 through here.
+ *
+ * Surfaces are dropped the same way `parentOf` drops them, by component, so a caller sees the same
+ * chain it would have built by walking.
+ */
+export declare function ancestorsOf(node: ISymbioteNode): readonly ISymbioteNode[];
+/**
+ * The first child, anchors included, or `undefined` for a leaf.
+ *
+ * ONE HOST CALL, not `childrenOf(node)[0]`, and the difference is a complexity class rather than a
+ * constant. `solid-js/universal`'s `cleanChildren` empties a parent with
+ * `while (removed = getFirstChild(parent)) removeNode(parent, removed)` — so the old spelling read a
+ * list of N, then N-1, then N-2, building and discarding every handle each time. Measured on a
+ * 2 000-row Solid `Clear` (`solid-clear-scaling.itest.tsx`): **2 001 001 handles** crossed to remove
+ * two thousand children, N(N+1)/2 to the unit, against the ~2 000 the work needs.
+ *
+ * The `mayHaveChildren` fast path is kept for the same reason `childrenOf` has it: FALSE is a
+ * certainty, so a leaf answers without a drain and without a crossing.
+ */
+export declare function firstChildOf(node: ISymbioteNode): ISymbioteNode | undefined;
+/**
+ * The next sibling, or `undefined` at the end of the list.
+ *
+ * `surface` is required to answer for a TOP-LEVEL node, which has no parent to read the sibling
+ * list from — the surface owns that list instead. Passing it for a parented node is harmless and
+ * ignored, so a caller with one active surface can pass it unconditionally.
+ */
+export declare function nextSiblingOf(node: ISymbioteNode, surface?: SymbioteSurface): ISymbioteNode | undefined;
+/**
+ * Whether the node is a TEXT CONTAINER (`<Text>`), not whether it holds a string.
+ *
+ * The distinction is load-bearing for adapters that ask "can I write a string into this": a raw
+ * text node answers FALSE here, and an anchor does too. Use `isRawTextNode` for that question.
+ */
+export declare function isTextContainer(node: ISymbioteNode): boolean;
+/**
+ * Whether the node is a RAW TEXT node — one a string can be written into.
+ *
+ * This is the question `solid-js/universal`'s `insertExpression` actually asks before calling
+ * replaceText, and answering it with `isTextContainer` would be wrong in both directions: a
+ * `<Text>` is a container that holds no string of its own, and the empty-string ANCHOR that
+ * cleanChildren leaves to hold a position is not writable either. An anchor is excluded here by
+ * construction, since its component is the `#anchor` sentinel.
+ */
+export declare function isRawTextNode(node: ISymbioteNode): boolean;
+/**
+ * The Fabric view name this node currently resolves to (`RCTView`, `RCTText`, `RCTRawText`, the
+ * `#anchor` sentinel …). Exposed because two seams branch on it — Solid to answer `isTextNode`,
+ * Angular to recognise its own anchor hosts — and both read `node.component` directly today.
+ *
+ * NOT stable across a node's life: a primitive whose native view depends on a prop (`TextInput`'s
+ * `multiline`) changes view without changing identity. Read it, never cache it.
+ */
+export declare function componentOf(node: ISymbioteNode): string;
+/**
+ * The string a raw-text node currently holds, or `undefined` for any other node.
+ *
+ * Exists for the DIAGNOSTIC path rather than the render path: a seam that rejects a bare string
+ * outside a `<Text>` wants to name the offending text in its error, and reading `node.props.text`
+ * to do so is the last thing keeping that seam coupled to the node's shape. Vue's
+ * `setElementText` reads the same value for a real reason, so this is not a one-caller accessor.
+ */
+export declare function textOf(node: ISymbioteNode): string | undefined;
+/**
+ * Every prop standing on the node, function props included.
+ *
+ * The bag a payload fold reads. Two sources, because a function never crossed the wire (`writeProp`,
+ * node.ts): the host holds the values it could take, JS holds the callbacks it could not, and a fold
+ * asking for `onPress` must see the one the app wrote rather than the `undefined` the host was
+ * handed in its place.
+ *
+ * A COPY when anything was stashed, the host's own object when nothing was — which is nearly every
+ * node. Same caveat as `propOf`: `style` after a class merge is the `[classStyle, explicitStyle]`
+ * array, not the author's object.
+ */
+export declare function propsOf(node: ISymbioteNode): Readonly<Record<string, unknown>>;
+/**
+ * A TEST read: the PAYLOAD the last commit handed Fabric for this node, `undefined` before one.
+ *
+ * `propsOf` above is the props AS THE OPS NAMED THEM — what the adapter said. This is what the
+ * payload builder MADE of them, after the aria fold, the behavior's own fold, the component-keyed
+ * folds and the style hoist. The two answer different questions and a test has to pick: "did the
+ * adapter write `inputMode`" is `propsOf`, and "did that reach native as `keyboardType`" is this.
+ *
+ * Only the native host can answer it — see `ITreeHost.committedPayloadOf`. Under the recording host
+ * it throws, on purpose, naming the itest suite as where the question belongs.
+ */
+export declare function committedPayloadOf(node: ISymbioteNode): Readonly<Record<string, unknown>> | undefined;
+export declare function propOf(node: ISymbioteNode, key: string): unknown;