@symbiote-native/engine 1.1.0 → 1.2.0

package/build/native-engine.d.ts

@@ -161,6 +161,7 @@ export type INativeEngineBindings = {
         valueEntries: number;
         valueConversions: number;
         applyMs: number;
+        liveNodes: number;
         stringDecodeMs: number;
         structureMs: number;
         holdHandleMs: number;

package/build/node.js

@@ -893,6 +893,22 @@ function isStyleRecord(value) {
  * `standing` cannot leave a key unaccounted for.
  */
 export function isSameShallowStyle(next, standing) {
+    // THE SAME OBJECT IS THE SAME STYLE, and saying so first is worth a line: without it a re-push of
+    // a hoisted constant — the commonest shape there is, and what Solid does on every signal change
+    // because it has no diff — allocates TWO key arrays and walks them to reach the same answer.
+    // Measured on Hermes (`style-write-cost.itest.ts`): the walk to this guard cost 1.12 us
+    // per write against a 0.84 us buffer write, so the compare was dearer than the write it protects.
+    // With this line, 0.32.
+    //
+    // IT CHANGES NOTHING OBSERVABLE, and that was break-tested rather than assumed. Inverting it — an
+    // identical object reporting "changed" — leaves all 1 044 unit tests and all 512 itests green,
+    // because `pushClassStyle`'s own `isAlreadyPublished` catches the republish downstream:
+    // `sharedStylePair` memoizes the pair by the explicit object, so the array it rebuilds is
+    // identity-equal to the one standing. The saving is the two key arrays and the walk, and nothing
+    // else. A speed change with no behaviour signature has to be justified by a measurement alone
+    // (method §8), which is why the number above is in this comment rather than in a commit message.
+    if (next === standing)
+        return isStyleRecord(next);
     if (!isStyleRecord(next) || !isStyleRecord(standing))
         return false;
     const keys = Object.keys(next);

package/build/tree-host.d.ts

@@ -148,7 +148,45 @@ export declare function commitSurfaceOps(rootTag: IRootTag | undefined, surface:
 export interface ICommitProfile {
     commits: number;
     propWrites: number;
+    /**
+     * Fresh Fabric families minted in this window — the SAME quantity a stock React Native app counts
+     * by wrapping `global.nativeFabricUIManager.createNode`, and the only like-for-like census left
+     * between the two stacks: our creates are issued from C++ (`SymbioteTree.cpp`,
+     * `uiManager.createNode`) and never touch that global, so a JS wrapper over it reads zero here by
+     * construction. Two arms whose node counts differ are not one workload, whatever their
+     * milliseconds say, so this belongs next to the writes rather than behind a surface id.
+     */
+    nodesCreated: number;
+    /**
+     * How many times `applyOps` was ENTERED for this window — the number of JSI crossings the buffer
+     * actually cost, as against the one the architecture promises.
+     *
+     * A whole create should read 2. It reads more when something READS the tree while the tree is
+     * being built, because a read is a batch boundary: the buffer has to drain before the answer can
+     * be given, so a framework navigating what it is inserting enters `applyOps` once per mutation.
+     * `small-batch-crossing-cost.itest.ts` prices an empty prologue at 1.5-4.4 us, so ten thousand
+     * boundaries is tens of milliseconds that no node count and no write count can see — which is
+     * exactly the shape of a cost that shows up on a device and not in a fixture.
+     */
+    applyCalls: number;
+    /**
+     * `applyOps` end to end, and the part of it that reads the buffer out of JS.
+     *
+     * THE ONE QUESTION A DEVICE HAS TO ANSWER and a fixture cannot. Our crossing is a single call
+     * carrying a 12 000-entry array that C++ walks element by element through JSI; stock's is ten
+     * thousand calls carrying scalars. On the harness's JavaScriptCore that walk is ~4 ms of a ~48 ms
+     * `applyOps`. Hermes is a different JSI implementation with different array-read costs and nothing
+     * headless can price it, so the number has to be read on a phone — near 4 ms and the buffer is
+     * innocent, tens of milliseconds and it is most of the gap the device reports.
+     */
+    applyMs: number;
+    decodeMs: number;
 }
+/**
+ * NOTE: reading this now DRAINS the surface telemetry too — `nodesCreated` is folded in from
+ * `readSurfaceTelemetry`, which zeroes on read in C++. A sampler polling this on an interval
+ * therefore empties what a later `readSurfaceTelemetry` call would have reported.
+ */
 export declare function readCommitProfile(): ICommitProfile;
 export type ISurfaceTelemetry = {
     layoutMs: number;
@@ -261,6 +299,15 @@ export type ISurfaceTelemetry = {
      * `stringDecodeMs` / `structureMs` is what the op loop itself costs — the books close here.
      */
     applyMs: number;
+    /**
+     * How many nodes the C++ tree is holding right now — a LEVEL, not a total, and the one counter
+     * here that is not drained on read.
+     *
+     * What it is for: JS ownership anchors the C++ side (a node lives while a parent holds it or while
+     * JS names it through `NativeState`), so a heap reading proves the JS half was released and only
+     * infers the other. This is the other half as a reading.
+     */
+    liveNodes: number;
     stringDecodeMs: number;
     /** Every append / insert / remove op together. */
     structureMs: number;

package/build/tree-host.js

@@ -106,6 +106,11 @@ export function flushOps() {
 }
 // Commits this window, for readCommitProfile below.
 let commits = 0;
+// A surface to ask for this window's node counts. They live in C++ and this profile is id-less, so
+// the window has to keep a tag to ask WITH, and exactly one: `walkCost_` is file-scope in
+// `SymbioteTree.cpp`, shared by every surface and drained on read, so asking a second surface in the
+// same window reads zeroes and a sum would be wrong rather than merely redundant.
+let lastCommittedTag;
 /**
  * Record a surface's commit and drain the buffer into the host.
  *
@@ -158,13 +163,38 @@ export function commitSurfaceOps(rootTag, surface, others = []) {
     // `undefined` means this surface no longer OWNS its root — a re-mount on the same rootTag took
     // it. Its ops still drain, because a teardown is what carries the removals; completing the root
     // would hand Fabric the dead surface's emptied tree over the live one's.
-    if (rootTag !== undefined)
+    if (rootTag !== undefined) {
         recordCommit(rootTag, surface);
+        lastCommittedTag = rootTag;
+    }
     host.applyOps(takeBatch());
     noteCommitDrained();
 }
+/**
+ * NOTE: reading this now DRAINS the surface telemetry too — `nodesCreated` is folded in from
+ * `readSurfaceTelemetry`, which zeroes on read in C++. A sampler polling this on an interval
+ * therefore empties what a later `readSurfaceTelemetry` call would have reported.
+ */
 export function readCommitProfile() {
-    const snapshot = { commits, propWrites: takePropStats().writes };
+    // ONE read, not two: `readSurfaceTelemetry` zeroes the C++ accumulator, so asking it twice hands
+    // the second caller zeroes and the field would read as "the buffer never crossed".
+    //
+    // Gated on a commit having LANDED in this window, and not merely on a tag being known. Fabric's
+    // `TransactionTelemetry::getCommitStartTime` asserts that a commit has started, so asking a
+    // surface that has not committed since the last read aborts the process in a debug build and
+    // reads an undefined time point in a release one. The window's own `commits` is the only thing
+    // that answers "is there anything to ask about" without asking.
+    const telemetry = commits === 0 || lastCommittedTag === undefined
+        ? undefined
+        : readSurfaceTelemetry(lastCommittedTag);
+    const snapshot = {
+        commits,
+        propWrites: takePropStats().writes,
+        nodesCreated: telemetry?.nodesCreated ?? 0,
+        applyCalls: telemetry?.applyCalls ?? 0,
+        applyMs: telemetry?.applyMs ?? 0,
+        decodeMs: telemetry?.decodeMs ?? 0,
+    };
     commits = 0;
     return snapshot;
 }

package/cpp/SymbioteFabricProps.cpp

@@ -2573,6 +2573,10 @@ dynamic fabricProps(
   dynamic aliasResolved;
   if (isTextInput) {
     aliasResolved = foldTextInputAliases(*bag, component == kMultilineTextInput);
+    // `TextInput.js:583` — `props.accessible !== false`, handed to both the singleline and the
+    // multiline view (`:703`, `:772`). The same shape as the Text rule below, and found the same
+    // way: diffing one bench row's committed payload against React Native's own.
+    aliasResolved["accessible"] = boolAt(aliasResolved, "accessible").value_or(true);
     bag = &aliasResolved;
   }
 
@@ -2598,6 +2602,19 @@ dynamic fabricProps(
     const bool optedOut =
         scaling != nullptr && scaling->isBool() && scaling->getBool() == false;
     textDefaulted["allowFontScaling"] = !optedOut;
+    // `Text.js:145` — `accessible !== false` on iOS, the same "only a literal false opts out" shape
+    // as the two above. Android resolves it off the press handlers instead, which is a behavior's
+    // job and not this rule's.
+    textDefaulted["accessible"] = boolAt(textDefaulted, "accessible").value_or(true);
+    // `Text.js:547` puts this in the component's own default STYLE, and its comment says why:
+    // "native components have historically acted like overflow: hidden ... to let client
+    // differentiate with overflow: 'visible'". Written at the TOP LEVEL rather than into the style
+    // slot so an authored `style.overflow` still beats it — `addStyle` hoists the slot over this
+    // payload after the copy loop below, which is what makes it a fallback rather than an override.
+    const dynamic *overflow = textDefaulted.get_ptr("overflow");
+    if (overflow == nullptr || overflow->isNull()) {
+      textDefaulted["overflow"] = "hidden";
+    }
     bag = &textDefaulted;
   }
 

package/cpp/SymbioteTree.cpp

@@ -327,7 +327,27 @@ struct Node : jsi::NativeState {
   //
   // The reference applier has no such window (a JS child's `parent` reference keeps the parent
   // alive), so nothing headless can reach this and there is no test to write for it.
+  /**
+   * How many nodes this process is holding, right now.
+   *
+   * The one reading nothing else can produce. Ownership here is JS-anchored — `children` is strong,
+   * `parent` is raw, and a node lives while a parent holds it or while JS names it through
+   * `NativeState` — so "JS gave its half back" IMPLIES the C++ half went with it. That is an
+   * inference from the ownership model, and the shape it would miss is the one
+   * software-mansion/react-native-reanimated#10527 describes: a container keyed by surface that
+   * nothing empties, holding a root alive after the surface is gone. We have no such container; this
+   * counter is what turns "we have no such container" from a reading of the code into a reading of
+   * the process.
+   *
+   * Not atomic, and deliberately: a commit walk is single-threaded, and the counter exists for a
+   * test rather than for a report anything acts on.
+   */
+  static inline int64_t live = 0;
+
+  Node() { live += 1; }
+
   ~Node() {
+    live -= 1;
     for (const NodePtr &child : children) {
       // A HOLE, from a detach nothing has read past yet. The destructor is the one reader that does
       // not compact first: compaction renumbers, and renumbering a vector whose owner is being
@@ -2578,6 +2598,10 @@ jsi::Value Tree::readSurfaceTelemetry(
   result.setProperty(
       runtime, "valueConversions", jsi::Value(static_cast<double>(walkCost_.valueConversions)));
   result.setProperty(runtime, "applyMs", millis(walkCost_.applyNs));
+  // NOT DRAINED ON READ, unlike every counter around it: this is a level rather than a total, and a
+  // level that zeroed itself when read would answer about nothing. `retention-after-clear.itest.ts`
+  // reads it across cycles.
+  result.setProperty(runtime, "liveNodes", jsi::Value(static_cast<double>(Node::live)));
   result.setProperty(runtime, "stringDecodeMs", millis(walkCost_.stringDecodeNs));
   result.setProperty(runtime, "structureMs", millis(walkCost_.structureNs));
   result.setProperty(runtime, "holdHandleMs", millis(walkCost_.holdHandleNs));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/engine",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "SymbioteNative's retained shadow-tree engine — clone-on-write commit path + event normalization over React Native Fabric, shared by every framework adapter.",
   "license": "MIT",
   "repository": {
@@ -71,7 +71,7 @@
   },
   "peerDependenciesMeta": {},
   "devDependencies": {
-    "@symbiote-native/test-utils": "0.4.0"
+    "@symbiote-native/test-utils": "0.4.1"
   },
   "scripts": {
     "typecheck": "tsc --build",