@symbiote-native/engine 1.2.0 → 1.3.1

package/build/index.js

@@ -1,23 +1,18 @@
-// @symbiote-native/engine: the retained shadow-tree + clone-on-write commit engine.
-// Every framework adapter drives this tiny mutation API; all Fabric-specific
-// logic (tag allocation, view-name resolution, clone-on-write, event
-// normalization) lives behind it, in one place.
+// @symbiote-native/engine: the retained shadow-tree + clone-on-write commit engine. Every framework
+// adapter drives this tiny mutation API; all Fabric-specific logic (tag allocation, view-name
+// resolution, clone-on-write, event normalization) lives behind it, in one place.
 export { createElement, createRawText, createAnchor, 
-// The component name of a node the commit walk skips and whose children flatten into its parent.
-// Exported so a PRIMITIVE that renders no view of its own can be born with it — RN's
-// TouchableNativeFeedback clones onto its single child and commits nothing
-// (TouchableNativeFeedback.js:339) — rather than being converted after the fact.
+// The component name of a node the commit walk skips and whose children flatten into its
+// parent. Exported so a primitive rendering no view of its own (TouchableNativeFeedback) can be
+// born with it directly, rather than converted after the fact.
 ANCHOR_COMPONENT, isAnchor, createVoid, 
-// The component name of a node whose ENTIRE subtree the commit walk drops — unlike
-// `ANCHOR_COMPONENT`, which hoists its children up in its place, a void node contributes neither
-// itself nor them. For a primitive whose whole component renders nothing on this platform —
-// `input-accessory-view` on Android, `InputAccessoryView.js`'s `return null`.
+// The component name of a node whose entire subtree the commit walk drops — unlike
+// ANCHOR_COMPONENT, which hoists children in its place, a void node contributes neither itself
+// nor them. For a primitive whose whole component renders nothing on this platform.
 VOID_COMPONENT, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, 
-// Exported for the ONE adapter that has to build style objects rather than receive them: Angular's
-// `ɵɵstyleMap` hands over keys, so its renderer allocates a fresh object per node and needs to
-// recognise one it has already published. A second copy of this comparator in the adapter is the
-// mirror shape this codebase deletes on sight — and its deliberate conservatism (a nested value
-// reports "not the same") is exactly right for that use too.
+// Exported for the one adapter that has to build style objects rather than receive them:
+// Angular's ɵɵstyleMap hands over keys, so its renderer allocates a fresh object per node and
+// needs to recognise one it has already published.
 isSameShallowStyle, getPublishedStyle, setNodeHidden, setNodeComponent, setNodePressed, setNodeUnderlayShown, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, takePropKeyTally, } from './node.js';
 // Host access — the DOM read half Fabric does not ship. Adapters route their seam's
 // parentNode/nextSibling/firstChild through these instead of reading a node's fields, which is
@@ -44,7 +39,7 @@ export { SymbioteSurface, createSurface } from './surface.js';
 export { setEventDispatcher } from './dispatch.js';
 // `setColorProcessor` / `processColor` were only RE-exported by the old `commit.ts`; they point at
 // their real home now.
-export { setColorProcessor, processColor } from './platform-color/index.js';
+export { setColorProcessor, processColor } from './platform-color';
 export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, requestCommitFor, } from './imperative.js';
 // The tree host: the seam a runtime installs to answer about the tree JS does not hold. `setTreeHost`
 // is what `installFabric()` (@symbiote-native/test-utils) calls with the TypeScript applier.
@@ -53,18 +48,12 @@ export { setTreeHost, treeHost, registerBeforeFlush, readCommitProfile, readSurf
 // `installNativeTreeHost` is not on any app path: `getSlot()` already calls it, and it is here so a
 // bring-up probe can install one explicitly against a hand-built set of bindings.
 export { nativeTreeHost, installNativeTreeHost } from './native-tree-host.js';
-// The OPCODES and the recorder are deliberately NOT here. They are the wire contract between this
-// package and whatever implements the tree, so their audience is a HOST author — the C++ and the
-// TypeScript applier — not an app. They live on the `@symbiote-native/engine/mutation-buffer`
-// subpath, for the same reason `state-style` does: a name on this barrel is public API on all five
-// adapters at once, with no edit to any of them
-// (`.claude/rules/adapter-parity-audit.md`, "A build-tool-facing symbol belongs on a SUBPATH").
-// "A commit just reached completeRoot." The one seam that means the same thing under every
-// adapter: React commits synchronously inside its own commit phase, while Vue / Svelte / Angular
-// schedule completeRoot on a microtask, so each framework's own after-render hook fires at a
-// DIFFERENT point relative to the native commit. Anything timing or comparing the commit path
-// across adapters has to hang off this, not off a per-framework lifecycle hook, or it measures a
-// different quantity in each one under the same name.
+// The opcodes and the recorder are deliberately NOT here: they're the wire contract between this
+// package and whatever implements the tree, audience a host author, not an app. They live on the
+// mutation-buffer subpath instead, since a name on this barrel is public API on all five adapters.
+// "A commit just reached completeRoot" — the one seam that means the same thing under every
+// adapter: React commits synchronously, Vue/Svelte/Angular schedule it on a microtask, so each
+// framework's after-render hook fires at a different point relative to the native commit.
 export { registerPostCommit, unregisterPostCommit } from './post-commit.js';
 // The aria/role -> accessibility* fold. Lives here rather than in a component wrapper because a tag
 // has none: `fabricProps` runs it on the way to the payload, so every path gets it.
@@ -78,7 +67,7 @@ export { fabricProps } from './fabric-props.js';
 // createElement): the imperative measure/setNativeProps/focus API, on the shared node prototype.
 // toPublicInstance is the identity that names the seam — see ./host-instance.
 export { toPublicInstance } from './host-instance/index.js';
-export { PlatformColor, DynamicColorIOS, isOpaqueColorValue, } from './platform-color/index.js';
+export { PlatformColor, DynamicColorIOS, isOpaqueColorValue, } from './platform-color';
 // CSS-style processors (boxShadow/filter): RN parses these in JS before native because
 // enableNativeCSSParsing() defaults to false. Exported so an adapter / test can reuse them.
 export { processBoxShadow } from './process-box-shadow/index.js';
@@ -104,9 +93,8 @@ export { getSlot } from './fabric.js';
 // another package (`@symbiote-native/test-utils`) and can no longer reach `./fabric` directly.
 export { resetSlot } from './fabric.js';
 // Imperative runtime modules: framework-agnostic native-bridge consumers (no visual, no
-// lifecycle), moved here from @symbiote-native/react so every adapter re-exports the SAME module.
-// The native module a JS API talks to is chosen per platform and can only be confirmed on a
-// real device or simulator, not headless (a headless fake resolves any module name).
+// lifecycle), so every adapter re-exports the same module. The native module a JS API talks to is
+// chosen per platform and can only be confirmed on a real device or simulator, not headless.
 export { Alert } from './alert';
 export { Share } from './share';
 // Image statics (getSize/prefetch/queryCache/...): a stateful, native-bridge-touching module with
@@ -114,12 +102,13 @@ export { Share } from './share';
 // @symbiote-native/components' renderImage lives alongside it in image-source-resolver.
 export { imageStatics } from './image-loader.js';
 export { setImageSourceResolver, resolveImageSource, } from './image-source-resolver.js';
+export { setAssetSourceResolver, resolveAssetSource, } from './asset-source-resolver.js';
 export { ActionSheetIOS } from './action-sheet-ios/index.js';
 export { Linking } from './linking';
 export { Vibration } from './vibration';
-export { ToastAndroid } from './toast-android/index.js';
+export { ToastAndroid } from './toast-android';
 export { SoundManager } from './sound-manager/index.js';
-export { Settings } from './settings/index.js';
+export { Settings } from './settings';
 export { I18nManager } from './i18n-manager/index.js';
 // Device-state / event modules (Dimensions, Appearance, AppState, Keyboard, …).
 export { Dimensions } from './dimensions/index.js';
@@ -135,17 +124,15 @@ export { createAppRegistry } from './app-registry/index.js';
 export { Keyboard, KEYBOARD_EVENT } from './keyboard/index.js';
 export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, focusTextInput, } from './text-input-state.js';
 export { LayoutAnimation } from './layout-animation/index.js';
-export { BackHandler } from './back-handler/index.js';
-export { PermissionsAndroid, PERMISSIONS, RESULTS, } from './permissions-android/index.js';
+export { BackHandler, installBackHandler } from './back-handler/index.js';
+export { PermissionsAndroid, PERMISSIONS, RESULTS, } from './permissions-android';
 export { AccessibilityInfo } from './accessibility-info';
 // StatusBar: values from the platform-selected './status-bar', types from '-shared' (the
 // .ios re-export would otherwise duplicate-export the type symbols).
 export { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight, } from './status-bar';
 export { hideTransition, STATUS_BAR_MANAGER, ANIMATED_HIDE_TRANSITION, STATIC_HIDE_TRANSITION, } from './status-bar/shared.js';
 export { registerHostBehavior, hasHostBehaviors, hostBehaviorFor, clearHostBehaviors, appListenerFor, addDerivedNode, SLOT_DERIVED_ALL, } from './host-behavior.js';
-// `markPropsDirty` is a behavior's only way to say "the fold reads state I just changed". Every
-// other dirtying route goes through a prop write, and a behavior whose payload is DERIVED — the
-// sticky header's debounced translateY lives in its own runtime, not in the node's props — has no
-// prop to write. Pair it with `requestCommitFor` (exported off `./imperative` above): dirtying is
-// not publishing.
+// markPropsDirty is a behavior's only way to say "the fold reads state I just changed" — every
+// other dirtying route goes through a prop write, and a derived-payload behavior has no prop to
+// write. Pair it with requestCommitFor: dirtying is not publishing.
 export { setBehaviorListener, markPropsDirty } from './node.js';

package/build/invariant.d.ts

@@ -0,0 +1 @@
+export declare function invariant(condition: boolean, message: string): asserts condition;

package/build/invariant.js

@@ -0,0 +1,10 @@
+// RN's `invariant(condition, message)` (the `invariant` package): a synchronous throw named
+// 'Invariant Violation' carrying the message verbatim. Ports use it where RN does, so a failure is
+// the same exception at the same moment.
+export function invariant(condition, message) {
+    if (condition)
+        return;
+    const error = new Error(message);
+    error.name = 'Invariant Violation';
+    throw error;
+}

package/build/keyboard/index.js

@@ -33,25 +33,6 @@ function isKeyboardEvent(payload) {
 // Keyboard listens to its OWN show/hide events and caches the event so the synchronous
 // isVisible() / metrics() reads need no native round-trip.
 let currentlyShowing = null;
-// Every live subscription this module handed out, grouped by event type, so
-// removeAllListeners(eventType) can tear them all down. The shared NativeEventEmitter
-// exposes only per-listener remove(), so Keyboard tracks the set itself (mirrors RN's
-// _emitter.removeAllListeners, which we cannot reach through the shared emitter).
-const subscriptions = new Map();
-function trackSubscription(eventType, subscription) {
-    let set = subscriptions.get(eventType);
-    if (set === undefined) {
-        set = new Set();
-        subscriptions.set(eventType, set);
-    }
-    set.add(subscription);
-    return {
-        remove() {
-            subscription.remove();
-            set.delete(subscription);
-        },
-    };
-}
 // Lazily resolved so importing this module has no native side effect: a headless
 // run without a fake __turboModuleProxy still loads it; resolution happens on the
 // first addListener. Null when the module isn't linked.
@@ -73,42 +54,40 @@ const deviceEventModule = createDeviceEventModule({
         });
     },
 });
+// RN builds KeyboardImpl, and with it the didShow/didHide tracking, the first time Keyboard is
+// touched. Every method goes through here so the tracking starts at that same moment.
 function getEmitter() {
     return deviceEventModule.getEmitter();
 }
 export const Keyboard = {
     addListener(eventType, listener) {
         dlog(`Keyboard.addListener -> ${eventType}`);
-        return trackSubscription(eventType, getEmitter().addListener(eventType, listener));
+        return getEmitter().addListener(eventType, listener);
     },
-    // Tear down every listener this module added for one event type. The self-subscription
-    // that feeds the cache is untracked, so it survives (RN parity: removeAllListeners only
-    // clears caller subscriptions). No-op when nobody's listening for that event.
+    // RN's `_emitter.removeAllListeners(eventType)`: every listener of the event on the device bus,
+    // Keyboard's own show/hide tracking included — a later show is then no longer cached.
     removeAllListeners(eventType) {
         dlog(`Keyboard.removeAllListeners -> ${eventType}`);
-        const set = subscriptions.get(eventType);
-        if (set === undefined)
-            return;
-        for (const subscription of set)
-            subscription.remove();
-        set.clear();
+        getEmitter().removeAllListeners(eventType);
     },
     // Whether the keyboard is last known to be visible. Reads the cached show event.
     isVisible() {
+        getEmitter();
         return currentlyShowing !== null;
     },
     // The soft-keyboard frame if visible (the cached event's endCoordinates), else
     // undefined. RN's metrics().
     metrics() {
+        getEmitter();
         return currentlyShowing?.endCoordinates;
     },
     // Syncs an accessory view's layout with the keyboard transition: configure the next
     // commit to animate over the keyboard's own duration/easing. RN's
-    // scheduleLayoutAnimation (Keyboard.js:193). Skipped when duration is absent or 0,
-    // since a zero-length animation is a no-op.
+    // scheduleLayoutAnimation (Keyboard.js:193): only when `duration != null && duration !== 0`.
     scheduleLayoutAnimation(event) {
+        getEmitter();
         const { duration, easing } = event;
-        if (duration === 0)
+        if (duration == null || duration === 0)
             return;
         dlog(`Keyboard.scheduleLayoutAnimation -> duration ${duration}, easing ${easing}`);
         LayoutAnimation.configureNext({

package/build/linking/index.android.js

@@ -9,9 +9,11 @@
 import { createLinking } from './shared.js';
 export const Linking = createLinking({
     moduleName: 'IntentAndroid',
-    sendIntent: (module, action, extras) => {
-        if (module === null || module.sendIntent === undefined) {
-            return Promise.reject(new Error('Linking: IntentAndroid native module unavailable'));
+    // RN: `nullthrows(NativeIntentAndroid).sendIntent(action, extras)`.
+    sendIntent: (requireModule, action, extras) => {
+        const module = requireModule();
+        if (module.sendIntent === undefined) {
+            throw new TypeError('NativeIntentAndroid.sendIntent is not a function');
         }
         return module.sendIntent(action, extras);
     },

package/build/linking/shared.d.ts

@@ -26,7 +26,7 @@ export interface ILinkingStatic {
 }
 export interface ILinkingPlatform {
     moduleName: string;
-    sendIntent(module: INativeLinkingModule | null, action: string, extras?: IIntentExtra[]): Promise<void>;
+    sendIntent(requireModule: () => INativeLinkingModule, action: string, extras?: IIntentExtra[]): Promise<void>;
 }
 export declare function createLinking(platform: ILinkingPlatform): ILinkingStatic;
 export {};

package/build/linking/shared.js

@@ -12,6 +12,8 @@ import { getNativeModule } from '../native-modules/index.js';
 import { dlog } from '../debug.js';
 // The one event symbiote observes: an incoming deep link. RN's LinkingEventDefinitions.
 const URL_EVENT = 'url';
+// The `nullthrows` package's message, which RN's Linking surfaces for a missing native module.
+const NULLTHROWS_MESSAGE = 'Got unexpected null or undefined';
 // RN's _validateURL: a typo / empty URL must fail loudly at the call, not reach native.
 function validateUrl(url) {
     if (typeof url !== 'string' || url.length === 0) {
@@ -50,8 +52,15 @@ export function createLinking(platform) {
         }
         return emitter;
     }
-    function moduleUnavailable() {
-        return new Error(`Linking: ${platform.moduleName} native module unavailable`);
+    // RN's `nullthrows(NativeModule)`: a missing module throws SYNCHRONOUSLY, with that package's
+    // message, from every method (Linking.js).
+    function requireModule() {
+        const module = getModule();
+        if (module === null) {
+            dlog(`Linking: ${platform.moduleName} unavailable -> throw`);
+            throw new Error(NULLTHROWS_MESSAGE);
+        }
+        return module;
     }
     return {
         addEventListener(eventType, listener) {
@@ -63,36 +72,24 @@ export function createLinking(platform) {
         openURL(url) {
             validateUrl(url);
             dlog(`Linking.openURL -> ${url}`);
-            const module = getModule();
-            if (module === null)
-                return Promise.reject(moduleUnavailable());
-            return module.openURL(url);
+            return requireModule().openURL(url);
         },
         canOpenURL(url) {
             validateUrl(url);
             dlog(`Linking.canOpenURL -> ${url}`);
-            const module = getModule();
-            if (module === null)
-                return Promise.reject(moduleUnavailable());
-            return module.canOpenURL(url);
+            return requireModule().canOpenURL(url);
         },
         getInitialURL() {
             dlog('Linking.getInitialURL');
-            const module = getModule();
-            if (module === null)
-                return Promise.resolve(null);
-            return module.getInitialURL();
+            return requireModule().getInitialURL();
         },
         openSettings() {
             dlog('Linking.openSettings');
-            const module = getModule();
-            if (module === null)
-                return Promise.reject(moduleUnavailable());
-            return module.openSettings();
+            return requireModule().openSettings();
         },
         sendIntent(action, extras) {
             dlog(`Linking.sendIntent -> ${action}`);
-            return platform.sendIntent(getModule(), action, extras);
+            return platform.sendIntent(requireModule, action, extras);
         },
     };
 }

package/build/mutation-buffer.d.ts

@@ -1,10 +1,3 @@
-/**
- * The opcodes. These numbers ARE the contract: renumbering here without renumbering the C++ commits
- * a different tree, silently, and no test in either language can see across the boundary.
- *
- * Stride is fixed so the ops array is addressable as memory rather than parsed. Operands are either
- * a SLOT (an index into the batch's `handles` array — see below) or an index into a side table.
- */
 export declare const OP_STRIDE = 6;
 export declare const OP_CREATE_ELEMENT = 0;
 export declare const OP_CREATE_RAW_TEXT = 1;
@@ -16,120 +9,14 @@ export declare const OP_SET_PROP = 6;
 export declare const OP_SET_TEXT = 7;
 export declare const OP_COMMIT = 8;
 export declare const OP_SET_COMPONENT = 9;
-/**
- * The INTRINSIC TAG this node came from — `pressable`, not `RCTView`. `[slot, tag]`.
- *
- * Emitted only for a node a host behavior actually attached to, from `attachHostBehavior`, which is
- * where the tag is already in hand and already matched. Every other node pays nothing.
- *
- * WHY THE TAG HAS TO CROSS AT ALL. A tag's platform props are resolved natively now, and the native
- * side keys them off what it knows the node IS. For `<text-input>` the Fabric view name answers
- * that by itself (`RCTSinglelineTextInputView` names nothing else); for `<pressable>` it does not —
- * it commits as `RCTView`, byte-identical to a plain view. The tag is the only fact that separates
- * them, and it is the same fact a browser keys user-agent behavior off.
- */
 export declare const OP_SET_TAG = 10;
-/**
- * An app callback appeared on, or disappeared from, an event name the behavior OWNS.
- * `[slot, name, present]`. See `recordSetOwnedListener` for why the bit crosses and the closure
- * does not.
- */
 export declare const OP_SET_OWNED_LISTENER = 11;
-/**
- * A behavior's FEEDBACK state flipped — TouchableHighlight's underlay is showing, or stopped.
- * `[slot, shown]`.
- *
- * The second bit to cross for the same reason the first did. `OP_SET_OWNED_LISTENER` carries whether
- * the app wired a handler; this carries whether the control is currently giving feedback, which is
- * the platform's own `:active` in everything but the timing. `setNodePressed`'s header already calls
- * the press state "the engine-owned half of what `:active` is on the web", and this is its twin for
- * the one control whose feedback does NOT track the press exactly: RN holds the underlay past
- * release so a fast tap still flashes (`TouchableHighlight.js:270-293`).
- *
- * THE TIMER STAYS IN JS and that is the boundary, not an omission. WHEN the bit flips is Pressability
- * plus a `delayPressOut` hold, running at gesture rate and calling back into app code
- * (`onShowUnderlay` / `onHideUnderlay`). WHAT a showing underlay looks like — a background colour and
- * a dimmed child, from two props no ViewConfig declares — is the platform's, and it is
- * `foldTouchableHighlightUnderlay` now.
- *
- * A flip is a GESTURE-rate event rather than a per-render one: twice a tap, against a `payloadFold`
- * that was charged on every commit the node was dirty in for the life of the screen.
- */
 export declare const OP_SET_UNDERLAY_SHOWN = 12;
-/**
- * A VOID node: commits nothing of its own AND does not hoist its children into Fabric either —
- * unlike an anchor, which hoists. `[slot]`.
- *
- * `InputAccessoryView.js` renders `null` on Android: the whole component, children included,
- * contributes nothing to the host tree. An anchor cannot express that — it exists precisely to hand
- * its children up in its own place — so a node whose entire subtree must vanish from Fabric needs
- * its own kind. Everything else about it (the retained JS tree, `appendChild`, adapter bookkeeping)
- * is unaffected; only the commit walk treats it as contributing zero Fabric nodes, recursively.
- */
 export declare const OP_CREATE_VOID = 13;
-/**
- * A `setProp` whose value slot is this DELETES the key.
- *
- * `undefined` cannot carry it: `null` is a legitimate Fabric prop value meaning "reset to the
- * default", and the two must stay distinguishable — `cloneNodeWithNewProps` merges, so a removed
- * key has to be sent as an explicit `null` while a key that was never there must not be sent at
- * all. The JS `setProp` already collapses `undefined` to a delete before anything is encoded.
- */
 export declare const NO_VALUE = -1;
-/**
- * A node kind. Native needs it because two of the three never become a Fabric node the same way,
- * and both rules are decided at INSERT or at child-set build — never by a walk:
- *
- *   ELEMENT   an ordinary view. Its Fabric view name is fixed at creation, with ONE exception:
- *             a text element inside another text element commits as `RCTVirtualText` instead of
- *             `RCTText`. Native resolves that when the node acquires a parent, because that is when
- *             it first knows the answer, and re-resolves it on a reparent.
- *   RAW_TEXT  an `RCTRawText` leaf. Skipped from its parent's child set when its text is empty —
- *             an empty one would paint.
- *   ANCHOR    a position marker the frameworks insert (`{#if}`, a fragment, a `{@render}` slot).
- *             It never becomes a Fabric node at all: native keeps it in ITS OWN structure so
- *             `insertBefore(parent, node, anchor)` resolves, and hoists its children into its
- *             parent's child list when building the child set. This is why our own store cannot BE
- *             the Fabric tree — there is no Fabric node to hold an anchor, which is the one thing
- *             `IMirror` was genuinely for.
- *
- * A SURFACE is an anchor too, and that is not a trick: an anchor is a node whose children belong to
- * its parent's list, and a surface is a node whose children belong to the root's child set. Same
- * shape, so `OP_COMMIT` names one and the native side needs no `rootTag -> node` map — which keeps
- * the applier stateless, the property the whole lifetime design rests on.
- */
 export declare const KIND_ELEMENT = 0;
 export declare const KIND_RAW_TEXT = 1;
 export declare const KIND_ANCHOR = 2;
-/**
- * One recorded batch, flat.
- *
- * `handles` is the load-bearing table and it travels OUT rather than back: it holds the placeholder
- * object for every slot the ops address, and native attaches each created node to the object at
- * that slot as JSI `NativeState`. So the objects the adapter is already holding become the handles
- * in place, their lifetime is the nodes' lifetime, and nothing has to be freed explicitly.
- *
- * A slot is an index into THIS batch and is meaningless outside it. That is deliberate: an id that
- * outlives a batch forces a table on the far side, and a table is a second owner with nothing to
- * tell it when the first one let go — which is exactly the leak that took the previous applier from
- * 792 to 1492 MB.
- *
- * `values` carries whatever a prop is: a string, a number, a boolean, `null`, a style object, an
- * array. Native converts each to `folly::dynamic` ONCE, when the op is applied — never again per
- * commit, which is the half that ships today.
- */
-/**
- * What the buffer needs a handle to BE.
- *
- * Still an identity and nothing else as far as the ops are concerned — no parent, no children, no
- * order. The two fields are the buffer's own scratch space for `slotOf`, written by this file and
- * read by nobody else; `ISymbioteNode` declares them from its constructor so every real handle
- * carries the pair on one hidden class.
- *
- * Spelled as a requirement rather than as optional fields on purpose: a handle that cannot hold its
- * slot would fall back to nothing, and the failure would be a silently re-pushed node rather than a
- * type error.
- */
 export type IMutationHandle = {
     slot: number;
     slotBatch: number;
@@ -141,35 +28,13 @@ export type IMutationBatch = {
     readonly instanceHandles: readonly unknown[];
     readonly handles: readonly object[];
 };
-/**
- * What native answers back, for the four things JS still asks.
- *
- * All four are per-node and none of them is structural — no parent, no children, no order. They
- * exist because a host behavior runs in JS and has to see the props it reacts to, and because an
- * app can measure a ref.
- *
- * Called at GESTURE rate, not commit rate, which is what makes the crossing cost irrelevant: ~10
- * reads per touch against the 19 009 per commit this whole design exists to remove.
- */
 export type INativeTree = {
     applyOps: (batch: IMutationBatch) => void;
     getProp: (handle: IMutationHandle, key: string) => unknown;
-    /** The resolved Fabric view name, which native may have changed at insert (see `KIND_ELEMENT`). */
     getViewName: (handle: IMutationHandle) => string;
 };
-/** Whether a commit would publish anything. See `changedSinceCommit`. */
 export declare function hasChangedSinceCommit(): boolean;
-/**
- * Called by `commitSurfaceOps` once it has drained. Separate from `takeBatch` because a READ drains
- * too, and a read is not a commit — clearing there would make the next commit believe its work had
- * already been published.
- */
 export declare function noteCommitDrained(): void;
-/**
- * The one dirtying route that writes no op: a behavior with a DERIVED payload asks the host to
- * rebuild a node the buffer never named. Without this the commit that follows would look idle and
- * be skipped, and the derived payload would sit unpublished until something unrelated changed.
- */
 export declare function noteHostSideChange(): void;
 /** Does the pending batch hold anything that could change what the host says this node's parent is? */
 export declare function hasPendingPlacement(handle: IMutationHandle): boolean;
@@ -183,56 +48,14 @@ export declare function recordRemoveChild(parent: IMutationHandle, child: IMutat
 /** `undefined` DELETES the key — the collapse `setProp` has always performed, spelled on the wire. */
 export declare function recordSetProp(handle: IMutationHandle, key: string, value: unknown): void;
 export declare function recordSetText(handle: IMutationHandle, text: string): void;
-/**
- * Change a node's Fabric view name after creation.
- *
- * It exists for exactly one thing and would not otherwise: `TextInput`'s `multiline` decides between
- * `RCTSinglelineTextInputView` and `RCTMultilineTextInputView`, and an app can flip it. No prop write
- * moves a node between native views, so the host has to RE-CREATE the node under the new name and
- * re-parent its children — which is the same path a reparent already takes, and why this needs no
- * new machinery on the far side beyond honouring the name.
- *
- * A JS-only workaround was the alternative and it is the one thing this design rules out: to know
- * what to rebuild, JS would have to hold the tree.
- */
 export declare function recordSetComponent(handle: IMutationHandle, viewName: string): void;
 export declare function recordSetTag(handle: IMutationHandle, tag: string): void;
-/**
- * Whether an app callback is currently wired to an event name the BEHAVIOR owns. `[slot, name,
- * present]`, `present` being 1 or 0.
- *
- * The EXISTENCE, never the function. A name a behavior owns is diverted into a JS stash by
- * `setEventListener` and never becomes a prop, so the payload builder sees no trace of it — and
- * `focusable` on a touchable is `focusable !== false && onPress !== undefined && !disabled`
- * (`TouchableOpacity.js:336-339`), two props and one thing only JS knew. This is the one bit that
- * closes that gap.
- *
- * The browser is the argument rather than convenience: a UA computes focusability itself and CAN,
- * because `addEventListener` is its own API — it knows which elements carry a click handler, while
- * the handler's body stays the application's. Same split.
- *
- * Emitted on a FLIP only, from `setEventListener`, which already refuses to notify on listener
- * identity because a framework hands a fresh closure nearly every render. So this is a mount-time
- * op, not a per-render one — against the per-commit fold it replaces.
- */
 export declare function recordSetOwnedListener(handle: IMutationHandle, name: string, isPresent: boolean): void;
 /** See `OP_SET_UNDERLAY_SHOWN`. Emitted on a flip only, from the behavior that owns the timer. */
 export declare function recordSetUnderlayShown(handle: IMutationHandle, shown: boolean): void;
 export declare function recordCommit(rootTag: number, surface: IMutationHandle): void;
 /** Whether anything is pending. The commit path asks before paying for a drain. */
 export declare function hasPendingOps(): boolean;
-/**
- * Drain the buffer.
- *
- * Fresh arrays rather than reused ones: the batch outlives this call on the native path (`applyOps`
- * reads `handles` while attaching state), and a recycled array would be mutated under it by the next
- * mutation the adapter makes.
- *
- * `slice` for the ops and not `subarray` for exactly that reason — a subarray would share the
- * backing store the very next `push` writes into. It is a typed-array copy rather than the
- * element-by-element iterator walk this used to be, and the ops buffer itself is KEPT so its
- * capacity survives the drain.
- */
 export declare function takeBatch(): IMutationBatch;
 /** Test seam. Drops everything pending without applying it. */
 export declare function resetMutationBuffer(): void;