@symbiote-native/engine 0.4.0 → 1.0.0

package/cpp/SymbioteTree.h

@@ -0,0 +1,257 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace symbiote {
+
+/**
+ * The shadow tree, owned by NATIVE. JS emits nothing but a command buffer.
+ *
+ * The spec is `core/engine/src/mutation-buffer.ts` and this file must agree with it — the opcode
+ * numbers are the contract, and renumbering on one side commits a different tree in silence.
+ *
+ * ── WHAT THIS REPLACES, AND WHY IT IS SMALLER THAN WHAT IT REPLACES ──────────────────────────────
+ *
+ * `SymbioteApplier` sat beside this file until 2026-09-08 and is deleted. It replayed FABRIC
+ * operations that a 2 041-line JS walk worked out — and that walk existed to re-derive a diff the
+ * framework had already computed and thrown away: a reconciler's whole job is knowing what changed,
+ * and every adapter tells us call by call.
+ *
+ * So this takes the ADAPTER's alphabet instead, and the derivation does not move here — it stops
+ * existing. What was 2 041 lines of JS diffing is, on this side, a child vector and a dirty flag.
+ * Three rules survive the collapse, and all three are two lines each rather than a walk:
+ *
+ *   a text element inside a text element commits as `RCTVirtualText`. Decided when a node acquires
+ *   a PARENT, because that is when the answer first exists, and re-decided on a reparent.
+ *
+ *   an anchor and an empty raw-text node are skipped from their parent's child set — an anchor
+ *   hoisting its own children up in its place. Decided when the set is built.
+ *
+ *   `cloneNodeWithNewProps` MERGES rather than replaces, so a clone's payload must be a minimal
+ *   diff with vanished keys sent as `null`. Cheaper here than in JS: we already know which keys an
+ *   op touched, so nothing has to be compared.
+ *
+ * ── LIFETIME: THIS CLASS HOLDS NOTHING ───────────────────────────────────────────────────────────
+ *
+ * A node's owner is the JS handle. `applyOps` attaches each created node to the placeholder object
+ * the adapter is already holding, as JSI `NativeState`, so the node lives exactly as long as that
+ * object and Hermes' collector is what frees it. A node also stays alive while a PARENT holds it,
+ * which is the browser's rule exactly: alive while in the tree or referenced from script.
+ *
+ * That is not a preference. The previous applier kept an `unordered_map<int32_t, shared_ptr>` and
+ * addressed nodes by a monotonic id — correct, and a second owner with nothing to tell it when the
+ * first one let go. One benchmark suite took it from 792 MB to 1492 MB. A `weak_ptr` table was
+ * tried and died on device on the first commit (`node 1 is gone`): Fabric's state reconciliation
+ * clones a stateful node AND THE PATH TO THE ROOT, so any `ScrollView` re-creates the root every
+ * commit while the JS side legitimately still names it. The repair is not a better table. It is
+ * having one owner.
+ *
+ * Hence: no members. `Tree` exists to give the host functions a `this`, and a per-call instance
+ * would behave identically.
+ */
+class Tree {
+ public:
+  /**
+   * `applyOps(ops, strings, values, instanceHandles, handles)`.
+   *
+   * `ops` is an `Int32Array` read as MEMORY — the commands never become JS values. The side tables
+   * carry what JSI has to marshal either way, and `handles` travels OUT: it holds the placeholder
+   * object for every slot the ops address, and a created node is attached to the object at its own
+   * slot. A slot is an index into THIS batch and is meaningless outside it, deliberately — an id
+   * that outlives a batch is what forces a table on this side.
+   *
+   * Prop values are converted to `folly::dynamic` ONCE, here, and never marshalled again. That is
+   * strictly cheaper than what ships today: `ConcreteComponentDescriptor::cloneProps` calls
+   * `RawProps::parse` unconditionally, and in `Mode::JSI` the preparse walks every key of every
+   * node with a `std::string` allocation per key — ~44 001 of each on a 1 000-row create, inside
+   * `createNode`. `Mode::Dynamic` does the identical work with no JSI at all.
+   */
+  facebook::jsi::Value applyOps(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+
+  /**
+   * The five READS JS makes, and their oracle is `core/test-utils/src/tree-applier.ts` — the
+   * TypeScript half of this file, which ~5 500 tests drive. Each one below mirrors an export there.
+   *
+   * Two are VALUE reads. The host behaviors (the press, text-input and switch machines) run in JS
+   * and must see the props they react to; `getViewName` exists on top of that because it may answer
+   * something the adapter did not choose — see the virtual-text rule above.
+   *
+   * Three are STRUCTURAL, and they are their seams' contract rather than our choice: Solid's nodeOps
+   * declare getParentNode / getFirstChild / getNextSibling, Vue's RendererOptions and Angular's
+   * Renderer2 declare a parent/sibling pair, and Svelte's compiled output reaches `firstChild` as a
+   * real prototype getter. Fabric answers none of them — `nativeFabricUIManager` exposes no
+   * structural read, and `NativeDOM` answers against the CURRENT REVISION, which is never the tree a
+   * reconciler is mid-way through building.
+   *
+   * All five run at GESTURE or lifecycle rate rather than commit rate, which is what makes the
+   * crossing irrelevant: ~10 reads per touch against the 19 009 per commit this design exists to
+   * remove.
+   *
+   * `census` is deliberately NOT here. It has one JS caller, it is diagnostics, and answering it
+   * would cost a full native walk of the very tree this design exists to stop walking.
+   */
+  facebook::jsi::Value getProp(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /** `getProps(handle)` — every prop standing on the node, in one crossing. */
+  facebook::jsi::Value getProps(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /** `markPropsDirty(handle)` — the dirtying route a DERIVED payload has, since it writes no prop. */
+  facebook::jsi::Value markPropsDirty(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value getViewName(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /** `parentOf(handle)` — the node's OWN parent, a surface included. */
+  facebook::jsi::Value parentOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /**
+   * `nextSiblingOf(handle)` — the next entry in the parent's child list, anchors included.
+   *
+   * Its own call because the JS spelling was `parentOf` plus a whole `childrenOf`, which a keyed
+   * patch makes quadratic: 1 002 001 handles crossed on a 1 000-row Vue append.
+   */
+  facebook::jsi::Value nextSiblingOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /** `childrenOf(handle)` — in order, ANCHORS INCLUDED. */
+  facebook::jsi::Value childrenOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /**
+   * `parentsOf(handles)` / `subtreesOf(roots)` — the batched twins of the two reads above, each
+   * answering for a whole list in ONE crossing.
+   *
+   * They are members rather than a JS loop because the teardown sweep is the one structural read
+   * whose size is the TREE's rather than one node's: it asks for every removed node's parent and
+   * then walks everything the removal took with it, which at a thousand rows was eleven thousand
+   * crossings inside the timed step.
+   *
+   * `subtreesOf` answers PRE-ORDER, each root followed by its descendants, concatenated in root
+   * order. Anchors included, exactly as `childrenOf` includes them.
+   */
+  facebook::jsi::Value parentsOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value subtreesOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /**
+   * `ancestorsOf(handle)` — the node and every ancestor above it, DEEPEST FIRST, in one crossing.
+   *
+   * The upward twin of `subtreesOf`, and it exists for the same reason the batched pair above does:
+   * a walk that asks per LEVEL pays a crossing per level. Event dispatch needs this chain for every
+   * event (capture reads it reversed, bubble forward) and the responder negotiation needs it again
+   * on every frame of every drag — measured at 18 crossings per event on a depth-8 chain before the
+   * two phases shared a walk, and 9 after.
+   *
+   * A SURFACE is included, exactly as `parentOf`'s answer includes one: stopping at a surface is
+   * `host-access.ts`'s job, and it reads the answer's `component` to do it.
+   */
+  facebook::jsi::Value ancestorsOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  /** `committedRecordOf(handle)` — `{handle, tag, rootTag}`, or undefined before a first commit. */
+  facebook::jsi::Value committedRecordOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+
+  /**
+   * The imperative six, taking the same placeholder object `applyOps` attached the node to.
+   *
+   * Each is the matching branch of `UIManagerBinding::get` with one substitution: where the binding
+   * unwraps a handle IT minted, these unwrap ours and then take the `ShadowNode` the last commit
+   * left on the node. They live HERE rather than beside `Applier` because a handle carries exactly
+   * one `NativeState` — under this tree that state is a `Node`, which nothing in `Applier` can read.
+   *
+   * A node with no committed `ShadowNode` gets the SAME answer as a surface with no revision: six
+   * zeroes, four zeroes, `onFail`, and a no-op for the two that go straight to `UIManager`. It is
+   * the ordinary state under an async-batched commit, and an app that only asked where something is
+   * must not be thrown into.
+   *
+   *   dispatchCommand(handle, name, args)   sendAccessibilityEvent(handle, eventType)
+   *   measure(handle, cb)                   measureInWindow(handle, cb)
+   *   measureLayout(handle, relativeTo, onFail, onSuccess)
+   *   setIsJSResponder(handle, isResponder, blockNativeResponder)
+   */
+  facebook::jsi::Value dispatchCommand(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value sendAccessibilityEvent(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value measure(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value measureInWindow(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value measureLayout(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+  facebook::jsi::Value setIsJSResponder(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+
+  /**
+   * RN's own commit telemetry for ANY surface, read on demand — `{ layoutMs, textMs, commitMs,
+   * layoutNodes, textMeasures }` for whichever commit produced that surface's current revision.
+   *
+   * It takes a surface id, so it can be pointed at a surface REACT drove — the only way to answer
+   * whether a tree-wide text re-measure is ours or something a Fabric commit costs.
+   */
+  facebook::jsi::Value readSurfaceTelemetry(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+
+  /**
+   * The PAYLOAD the last commit handed Fabric for this node, or `undefined` before its first.
+   *
+   * A TEST READ, and the only complete one there is. What a committed node can otherwise report is
+   * `Props::getDebugProps()`, a hand-written SELECTION per component — `RCTView` answers seven keys
+   * and `RCTSinglelineTextInputView` answers `testID` and nothing else, because RN implements none
+   * for `TextInputProps`. So a test asking "did the payload builder resolve `inputMode` into
+   * `keyboardType`" had no way to look, and every rule in `SymbioteFabricProps.cpp` was verifiable
+   * only through its TypeScript twin.
+   *
+   * RN's own complete read is `Props::rawProps`, behind `RN_SERIALIZABLE_STATE` — which drags
+   * `fbjni/fbjni.h` into `State`'s virtual interface and cannot compile on a host build (tried
+   * 2026-09-15, recorded in `core/engine/cpp/tests/CMakeLists.txt`). This needs no flag: the bag is
+   * already retained per node as the next commit's diff baseline, so the read costs a conversion and
+   * nothing else, and no commit path changes at all.
+   *
+   * WHAT IT IS NOT: proof that Fabric PARSED any of it. A key no ViewConfig declares sits in here
+   * exactly as it was sent — `processor-refusal.itest.ts` is the test for that question, and
+   * `getDebugProps` stays the read that proves the round trip. This answers what we SENT.
+   */
+  facebook::jsi::Value committedPayloadOf(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value *arguments,
+      size_t count);
+};
+
+} // namespace symbiote

package/ios/SymbioteEngineModule.h

@@ -0,0 +1,25 @@
+// The first native code this project owns. Everything else under `packages/*` with a podspec is a
+// WRAPPER that vendors somebody else's sources; this compiles our own.
+//
+// It exists for item 8c of the `symbiote-fabric-cxx-surface` skill: the engine's structure must live
+// in memory a native module owns, so that JS reads it as a typed-array view rather than calling for
+// it. This header is the iOS entry point — the module whose creation installs the host object.
+//
+// It does NOT touch React Native's own native sources, which `<native_core_is_untouched>` forbids.
+// Everything it uses is public: `RCTTurboModuleWithJSIBindings` is a declared protocol, and RN's own
+// `AnimatedModule` reaches the runtime through the identical hook.
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Registered as `SymbioteEngine`. Resolving it from JS is what CREATES it, and creation is what runs
+ * `installJSIBindingsWithRuntime:callInvoker:` — so `core/engine/src/native-engine.ts` touches the
+ * module for its side effect and then reads the global the hook installed.
+ */
+@interface SymbioteEngineModule : NSObject <RCTBridgeModule>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SymbioteEngineModule.mm

@@ -0,0 +1,44 @@
+#import "SymbioteEngineModule.h"
+
+#import <ReactCommon/RCTTurboModule.h>
+#import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
+#import <SymbioteEngineSpec/SymbioteEngineSpec.h>
+
+#include "../cpp/SymbioteEngineBindings.h"
+
+using namespace facebook;
+
+@interface SymbioteEngineModule () <NativeSymbioteEngineSpec, RCTTurboModuleWithJSIBindings>
+@end
+
+@implementation SymbioteEngineModule
+
+RCT_EXPORT_MODULE(SymbioteEngine)
+
+- (std::shared_ptr<react::TurboModule>)getTurboModule:(const react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<react::NativeSymbioteEngineSpecJSI>(params);
+}
+
+- (NSNumber *)getVersion
+{
+  return @(symbiote::kNativeVersion);
+}
+
+#pragma mark - RCTTurboModuleWithJSIBindings
+
+// Called ONCE, by `RCTTurboModuleManager`, at the moment this module is first created — which is why
+// `native-engine.ts` resolves the module for its side effect and then reads the global. There is no
+// `install()` for JS to call, deliberately: an explicit install has to happen before the first use
+// and nothing enforces that ordering, while this hook cannot be skipped by anyone who reaches the
+// module at all.
+//
+// Everything below the next line is platform-shared. When Android's shim lands it calls the same
+// `installBindings` from JNI, and this file stays this length.
+- (void)installJSIBindingsWithRuntime:(jsi::Runtime &)runtime
+                          callInvoker:(const std::shared_ptr<react::CallInvoker> &)callInvoker
+{
+  symbiote::installBindings(runtime);
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/engine",
-  "version": "0.4.0",
+  "version": "1.0.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": {
@@ -31,19 +31,47 @@
     ".": {
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
+    },
+    "./mutation-buffer": {
+      "types": "./build/mutation-buffer.d.ts",
+      "default": "./build/mutation-buffer.js"
     }
   },
   "files": [
-    "build"
+    "build",
+    "cpp",
+    "!cpp/tests",
+    "ios",
+    "android",
+    "codegen-specs",
+    "symbiote-engine.podspec",
+    "react-native.config.cjs"
   ],
+  "codegenConfig": {
+    "name": "SymbioteEngineSpec",
+    "type": "modules",
+    "jsSrcsDir": "codegen-specs",
+    "android": {
+      "javaPackageName": "dev.symbiotenative.engine"
+    },
+    "ios": {
+      "modulesProvider": {
+        "SymbioteEngine": "SymbioteEngineModule"
+      }
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@react-native/normalize-colors": "0.86.2"
+  },
   "peerDependencies": {
     "react-native": ">=0.86"
   },
+  "peerDependenciesMeta": {},
   "devDependencies": {
-    "@symbiote-native/test-utils": "0.3.0"
+    "@symbiote-native/test-utils": "0.3.1"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/react-native.config.cjs

@@ -0,0 +1,23 @@
+// Declares this package's Android native project to @react-native-community/cli autolinking.
+// Explicit rather than relying on auto-detection, so the Kotlin ReactPackage is registered
+// deterministically — same reasoning as `packages/android/react-native.config.js`.
+//
+// `ios` is deliberately ABSENT rather than null: the iOS half is a real podspec
+// (`symbiote-engine.podspec`) that CocoaPods autolinking already finds, and naming the key would
+// only give us a chance to get it wrong.
+//
+// `.cjs`, not `.js`: this package is `"type": "module"`, so a `.js` file using `module.exports`
+// would be loaded as ESM and throw. The CLI searches `react-native.config.js`,
+// `react-native.config.cjs` and `react-native.config.ts` (cli-config's `searchPlacesForCJS`), so the
+// extension costs nothing.
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+        packageImportPath: 'import dev.symbiotenative.engine.SymbioteEnginePackage;',
+        packageInstance: 'new SymbioteEnginePackage()',
+      },
+    },
+  },
+};

package/symbiote-engine.podspec

@@ -0,0 +1,42 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+# `@symbiote-native/engine` is a DIRECT dependency of every example app, so RN's autolinking finds
+# this podspec with no entry in anybody's Podfile — which is the whole reason the native module lives
+# here instead of in a package of its own. A new package would have needed a release, an entry in
+# every example's manifest, and a row in three parity audits; this needs a `pod install`.
+#
+# Note the two vendoring workarounds that `packages/{slider,navigation}` carry are absent here, on
+# purpose: those podspecs glob files out of a THIRD-PARTY package that pnpm puts behind a symlink,
+# and CocoaPods' recursive glob never descends into one. Our sources sit under this pod's own
+# directory, so a plain downward pattern reaches them.
+Pod::Spec.new do |s|
+  s.name         = 'symbiote-engine'
+  s.version      = package['version']
+  s.summary      = 'Native store and commit hook for the SymbioteNative engine.'
+  s.license      = package['license'] || 'MIT'
+  s.authors      = package['author'] || 'symbiote'
+  s.homepage     = package['homepage'] || 'https://github.com/symbiote/symbiote'
+  s.platforms    = { :ios => '15.1', :visionos => '1.0' }
+  s.source       = { :git => 'https://github.com/symbiote/symbiote.git', :tag => "v#{s.version}" }
+
+  # `cpp/` is the platform-shared half and `ios/` is the registration shim. Android's shim will glob
+  # the same `cpp/` from its own build file rather than copying anything.
+  s.source_files = 'ios/**/*.{h,m,mm}', 'cpp/**/*.{h,cpp}'
+
+  # Pulls in React-Core, the codegen'd spec pod, ReactCommon/turbomodule and the folly flags that
+  # every New Architecture module needs. Defined by react-native's `react_native_pods.rb`, which the
+  # app's Podfile requires before it reaches this file; the fallback keeps `pod spec lint` and any
+  # non-RN evaluation from dying on an undefined method.
+  if defined?(install_modules_dependencies)
+    install_modules_dependencies(s)
+  else
+    s.dependency 'React-Core'
+    s.dependency 'React-jsi'
+    s.dependency 'ReactCommon/turbomodule/core'
+    s.pod_target_xcconfig = {
+      'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20'
+    }
+  end
+end

package/build/animated/bezier.d.ts

@@ -1 +0,0 @@
-export declare function bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;

package/build/animated/bezier.js

@@ -1,102 +0,0 @@
-// Cubic-bezier easing solver, ported verbatim from React Native's
-// Libraries/Animated/bezier.js (originally bezier-easing by Gaëtan Renaudeau,
-// MIT). Pure math (no React, no native), so it lives unchanged in shared.
-// Established by empiricism (tradeoff: performance vs precision).
-const NEWTON_ITERATIONS = 4;
-const NEWTON_MIN_SLOPE = 0.001;
-const SUBDIVISION_PRECISION = 0.0000001;
-const SUBDIVISION_MAX_ITERATIONS = 10;
-const SPLINE_TABLE_SIZE = 11;
-const SAMPLE_STEP_SIZE = 1.0 / (SPLINE_TABLE_SIZE - 1.0);
-function a(a1, a2) {
-    return 1.0 - 3.0 * a2 + 3.0 * a1;
-}
-function b(a1, a2) {
-    return 3.0 * a2 - 6.0 * a1;
-}
-function c(a1) {
-    return 3.0 * a1;
-}
-// x(t) given t, x1, x2, or y(t) given t, y1, y2.
-function calcBezier(t, a1, a2) {
-    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;
-}
-// dx/dt given t, x1, x2, or dy/dt given t, y1, y2.
-function getSlope(t, a1, a2) {
-    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);
-}
-function binarySubdivide(x, lower, upper, mX1, mX2) {
-    let currentX;
-    let currentT;
-    let lo = lower;
-    let hi = upper;
-    let i = 0;
-    do {
-        currentT = lo + (hi - lo) / 2.0;
-        currentX = calcBezier(currentT, mX1, mX2) - x;
-        if (currentX > 0.0) {
-            hi = currentT;
-        }
-        else {
-            lo = currentT;
-        }
-    } while (Math.abs(currentX) > SUBDIVISION_PRECISION &&
-        ++i < SUBDIVISION_MAX_ITERATIONS);
-    return currentT;
-}
-function newtonRaphsonIterate(x, guess, mX1, mX2) {
-    let guessT = guess;
-    for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
-        const currentSlope = getSlope(guessT, mX1, mX2);
-        if (currentSlope === 0.0) {
-            return guessT;
-        }
-        const currentX = calcBezier(guessT, mX1, mX2) - x;
-        guessT -= currentX / currentSlope;
-    }
-    return guessT;
-}
-export function bezier(mX1, mY1, mX2, mY2) {
-    if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
-        throw new Error('bezier x values must be in [0, 1] range');
-    }
-    // Precompute the spline samples once.
-    const sampleValues = new Array(SPLINE_TABLE_SIZE);
-    if (mX1 !== mY1 || mX2 !== mY2) {
-        for (let i = 0; i < SPLINE_TABLE_SIZE; ++i) {
-            sampleValues[i] = calcBezier(i * SAMPLE_STEP_SIZE, mX1, mX2);
-        }
-    }
-    function getTForX(x) {
-        let intervalStart = 0.0;
-        let currentSample = 1;
-        const lastSample = SPLINE_TABLE_SIZE - 1;
-        for (; currentSample !== lastSample && sampleValues[currentSample] <= x; ++currentSample) {
-            intervalStart += SAMPLE_STEP_SIZE;
-        }
-        --currentSample;
-        // Interpolate to provide an initial guess for t.
-        const dist = (x - sampleValues[currentSample]) /
-            (sampleValues[currentSample + 1] - sampleValues[currentSample]);
-        const guessForT = intervalStart + dist * SAMPLE_STEP_SIZE;
-        const initialSlope = getSlope(guessForT, mX1, mX2);
-        if (initialSlope >= NEWTON_MIN_SLOPE) {
-            return newtonRaphsonIterate(x, guessForT, mX1, mX2);
-        }
-        if (initialSlope === 0.0) {
-            return guessForT;
-        }
-        return binarySubdivide(x, intervalStart, intervalStart + SAMPLE_STEP_SIZE, mX1, mX2);
-    }
-    return function bezierEasing(x) {
-        if (mX1 === mY1 && mX2 === mY2) {
-            return x; // linear
-        }
-        // JS numbers are imprecise; pin the extremes.
-        if (x === 0)
-            return 0;
-        if (x === 1)
-            return 1;
-        return calcBezier(getTForX(x), mY1, mY2);
-    };
-}

package/build/commit.d.ts

@@ -1,49 +0,0 @@
-import { type IFabricNode, type IRootTag, type IMeasureOnSuccess, type IMeasureInWindowOnSuccess, type IMeasureLayoutOnSuccess } from './fabric';
-import { type ISymbioteNode } from './node';
-export { processColor, setColorProcessor } from './platform-color';
-declare global {
-    var __SYMBIOTE_BATCH_CREATE__: boolean | undefined;
-}
-export declare function disposeRoot(rootTag: IRootTag): void;
-export declare function commitChildren(rootTag: IRootTag, children: readonly ISymbioteNode[]): void;
-export interface ICommitProfile {
-    commits: number;
-    walkMs: number;
-    nodesVisited: number;
-    /** Update-path nodes that rebuilt their Fabric payload and deep-compared it. */
-    propsBuilt: number;
-    /** Update-path nodes that re-cloned for a child but reused the committed payload by reference. */
-    propsReused: number;
-    propWrites: number;
-    propNoops: number;
-    childScans: number;
-    childScanProbed: number;
-    childFlattens: number;
-    childFlattenProbed: number;
-    childFlattenWidest: number;
-}
-export declare function readCommitProfile(): ICommitProfile;
-export declare function flushNativeProps(): void;
-export declare function setNativeProps(node: ISymbioteNode, partial: Record<string, unknown>): void;
-/**
- * Publish a node whose props were changed OUTSIDE any renderer mutation.
- *
- * Dirtying is not publishing. Every other write reaches Fabric because the framework's own commit
- * follows it; a change driven by a NATIVE EVENT has no such follow-up — `native-events.ts`
- * requests no commit and no adapter does either, so a node marked dirty from an event handler
- * simply stays dirty. The host-behavior press path (`setNodePressed` for `:active`) is the first
- * caller that is not `setNativeProps`, and `setNodeHidden`'s React twin never needed it because
- * the reconciler is already in its commit phase when it calls.
- *
- * Queued rather than committed on the spot, sharing `setNativeProps`' batch: several writes in one
- * task publish together at the microtask boundary, one commit per surface.
- */
-export declare function requestCommitFor(node: ISymbioteNode): void;
-export declare function getNativeTag(node: ISymbioteNode): number | undefined;
-export declare function whenCommitted(node: ISymbioteNode, action: () => void): () => void;
-export declare function getNativeNode(node: ISymbioteNode): IFabricNode | undefined;
-export declare function dispatchViewCommand(node: ISymbioteNode, commandName: string, args: readonly unknown[]): void;
-export declare function sendAccessibilityEvent(node: ISymbioteNode, eventType: string): void;
-export declare function measure(node: ISymbioteNode, callback: IMeasureOnSuccess): void;
-export declare function measureInWindow(node: ISymbioteNode, callback: IMeasureInWindowOnSuccess): void;
-export declare function measureLayout(node: ISymbioteNode, relativeTo: ISymbioteNode, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;