@symbiote-native/engine 0.5.0 → 1.0.0

package/build/imperative.js

@@ -0,0 +1,258 @@
+// The imperative half of what `commit.ts` used to export — everything an app or an adapter reaches
+// for OUTSIDE a render: measure, view commands, accessibility events, the Animated fast path.
+//
+// It survived the tree's removal unchanged in SHAPE, because every one of these was already written
+// against three fields — a Fabric handle, a tag, a root tag — and never against the walk. What
+// changed is where those come from: `committedOf(node)` read an `IMirror` on the node, and the tree
+// HOST answers now (`tree-host.ts`) — native on device, the TypeScript applier headlessly.
+//
+// `undefined` is the ORDINARY state here, not an error. An adapter that wires an imperative call at
+// lifecycle time runs before `completeRoot` under an async-batched commit (Vue and Svelte schedule
+// it on a microtask), so the node has no handle yet. Every function either defers (`whenCommitted`)
+// or logs and returns — never throws.
+import { dlog, isDebug } from './debug.js';
+import { clearPublishedStyle, writeProp } from './node.js';
+import { flattenStyle } from './style/index.js';
+import { flushOps, treeHost } from './tree-host.js';
+/**
+ * What Fabric currently holds for `node`, or `undefined` before its first commit.
+ *
+ * Flushes first: an imperative call can land between a mutation and its commit, and the host cannot
+ * answer about ops it has not been handed.
+ *
+ * `undefined` is the ORDINARY state, not an error — and it is also what a WRAPPED node gets. The host
+ * keys on the handle OBJECT, so a Vue `reactive()` / deep-`ref()` Proxy around a host element misses
+ * and every function below degrades to its log. Hold host nodes with `shallowRef`.
+ */
+function committedRecordOf(node) {
+    flushOps();
+    return treeHost()?.committedRecordOf(node);
+}
+// Surfaces that have asked for a commit this task, and the callback that performs one. Registered
+// by `surface.ts` rather than imported from it: a surface owns its own commit, and reaching into it
+// from here would put the cycle back that this split exists to remove.
+const pendingRoots = new Set();
+let commitSurface;
+let forgetSurface;
+let flushScheduled = false;
+export function registerSurfaceCommit(commit, forget) {
+    commitSurface = commit;
+    forgetSurface = forget;
+}
+export function flushNativeProps() {
+    flushScheduled = false;
+    if (pendingRoots.size === 0)
+        return;
+    const roots = [...pendingRoots];
+    pendingRoots.clear();
+    for (const rootTag of roots)
+        commitSurface?.(rootTag);
+}
+/**
+ * Publish a node whose props changed OUTSIDE any renderer mutation.
+ *
+ * Recording 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 — the press path's
+ * `setNodePressed` is the first caller that is not `setNativeProps`.
+ *
+ * Queued rather than committed on the spot: several writes in one task publish together at the
+ * microtask boundary, one commit per surface.
+ */
+export function requestCommitFor(node) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog('requestCommitFor skipped: node not committed');
+        return;
+    }
+    requestCommitForRoot(record.rootTag);
+}
+/**
+ * The same request, for a caller that already holds the node's record.
+ *
+ * `committedRecordOf` crosses the host boundary, and `setNativeProps` fetches the record two lines
+ * before it calls this — so asking again was two crossings for one fact, on the path an
+ * `AnimatedProps` leaf runs once per frame per animated node. Measured at 2 of the 3 crossings a
+ * frame made (`__tests__/animated-frame-cost.test.ts`).
+ */
+function requestCommitForRoot(rootTag) {
+    pendingRoots.add(rootTag);
+    if (!flushScheduled) {
+        flushScheduled = true;
+        queueMicrotask(flushNativeProps);
+    }
+}
+export function disposeRoot(rootTag) {
+    // Drop anything still queued for this surface: its flush is a microtask away and would otherwise
+    // commit into a container that no longer exists.
+    pendingRoots.delete(rootTag);
+    forgetSurface?.(rootTag);
+    dlog(`root disposed root=${rootTag}`);
+}
+/** The committed reactTag, stable across clone-on-write — what the native Animated driver binds. */
+export function getNativeTag(node) {
+    return committedRecordOf(node)?.tag;
+}
+/**
+ * The node's current native handle, in kind identical to React's `stateNode.node`.
+ *
+ * OPAQUE. Under the native host it is a `ShadowNode`, under a headless one whatever that host
+ * committed — see `ICommittedRecord.handle`. It used to be typed `IFabricNode`, a brand with no
+ * members, so a caller can do exactly as much with it as before.
+ */
+export function getNativeNode(node) {
+    return committedRecordOf(node)?.handle;
+}
+// Actions waiting for their node's first commit. An adapter that wires an imperative call at
+// lifecycle time can run BEFORE completeRoot under an async-batched commit, so the node has no
+// handle yet and the call would silently no-op. Each waiter retries after a commit and is dropped
+// once it runs. React commits synchronously, so its actions run inline and never land here.
+const pendingCommitWaiters = new Set();
+/** Called by the commit path once a batch has published. */
+export function notifyCommitted() {
+    for (const waiter of pendingCommitWaiters) {
+        if (waiter())
+            pendingCommitWaiters.delete(waiter);
+    }
+}
+/**
+ * Run `action` once `node` has a committed Fabric handle — immediately if it already does, else
+ * after the commit that assigns one. Returns a cancel fn (drop the retry, e.g. on unmount).
+ */
+export function whenCommitted(node, action) {
+    const attempt = () => {
+        if (committedRecordOf(node) === undefined)
+            return false;
+        action();
+        return true;
+    };
+    if (!attempt())
+        pendingCommitWaiters.add(attempt);
+    return () => {
+        pendingCommitWaiters.delete(attempt);
+    };
+}
+export function dispatchViewCommand(node, commandName, args) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog(`dispatchViewCommand "${commandName}" skipped: node not committed`);
+        return;
+    }
+    dlog(`dispatchViewCommand "${commandName}"`);
+    treeHost()?.dispatchCommand(node, commandName, args);
+}
+export function sendAccessibilityEvent(node, eventType) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog(`sendAccessibilityEvent "${eventType}" skipped: node not committed`);
+        return;
+    }
+    treeHost()?.sendAccessibilityEvent(node, eventType);
+}
+export function measure(node, callback) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog('measure skipped: node not committed');
+        return;
+    }
+    treeHost()?.measure(node, callback);
+}
+export function measureInWindow(node, callback) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog('measureInWindow skipped: node not committed');
+        return;
+    }
+    treeHost()?.measureInWindow(node, callback);
+}
+// RN's public signature is (relative, onSuccess, onFail) but the native slot wants the fail
+// callback first, so the order is swapped here.
+export function measureLayout(node, relativeTo, onSuccess, onFail = () => { }) {
+    const record = committedRecordOf(node);
+    const relativeRecord = committedRecordOf(relativeTo);
+    if (record === undefined || relativeRecord === undefined) {
+        dlog('measureLayout skipped: a node is not committed');
+        return;
+    }
+    treeHost()?.measureLayout(node, relativeTo, onFail, onSuccess);
+}
+/**
+ * Tell native that JS has taken the gesture, or given it up.
+ *
+ * Through the HOST like the five above it, never through the Fabric slot: under the native tree
+ * host the committed handle is our placeholder, and `nativeFabricUIManager.setIsJSResponder` unwraps
+ * only a `ShadowNode` reference it minted itself.
+ */
+export function setIsJSResponder(node, isResponder, blockNativeResponder) {
+    if (committedRecordOf(node) === undefined) {
+        dlog('setIsJSResponder skipped: node not committed');
+        return;
+    }
+    treeHost()?.setIsJSResponder(node, isResponder, blockNativeResponder);
+}
+/** The node's CURRENT prop value, as the host holds it. The behaviors' one read. */
+export function propOf(node, key) {
+    flushOps();
+    return treeHost()?.propOf(node, key);
+}
+// Per-frame prop write for the JS-driven Animated path, and the one write that bypasses the
+// declarative style. RN flushes an animation frame with an in-place `instance.setNativeProps(...)`;
+// Fabric is persistent, so a frame is one scoped commit instead.
+//
+// IT NO LONGER BYPASSES ANYTHING, and the correction it used to owe the host is gone with the
+// bypass. This wrote to Fabric directly once, so the host had to be told what had been sent behind
+// its back or its next diff would be computed against a stale base. The write is an ordinary op now
+// — the commit that carries it updates that record itself. Telling the host EARLY was strictly
+// worse than not telling it: `noteNativePropsBypass` folded the values into `committedProps` before
+// the commit ran, so the diff found nothing to send and the write never reached Fabric at all.
+//
+// One correction survives, because it is about the ENGINE's own state rather than the host's:
+// `parts.published` is cleared, so `pushClassStyle`'s guard cannot turn away the re-push that
+// RESTORES the declarative style this frame just overwrote. The guard is exact, and an app handing
+// over a hoisted style constant (StyleSheet.create, a module-level object) would otherwise never
+// get it back.
+export function setNativeProps(node, partial) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog('setNativeProps skipped: node not committed');
+        return;
+    }
+    const merged = {};
+    for (const [key, value] of Object.entries(partial)) {
+        if (key === 'style') {
+            // A partial style override MERGES onto the standing style (RN semantics):
+            // setNativeProps({style:{backgroundColor}}) recolors without dropping height or radius.
+            // Transient: the next declarative commit re-applies the full style.
+            merged.style = {
+                ...flattenStyle(treeHost()?.propOf(node, 'style')),
+                ...flattenStyle(value),
+            };
+        }
+        else {
+            merged[key] = value;
+            // This path used to owe the aria gate that `setProp` carried, since it bypasses it. There is
+            // no gate to owe any more: the fold is the device's rule and it recomputes presence from the
+            // bag. See `node.ts`'s note at the old choke point.
+        }
+    }
+    for (const [key, value] of Object.entries(merged)) {
+        // `writeProp`, not `recordSetProp`: this is the path with no `routeProp` in front of it, so a
+        // function reaches the wire from here and nowhere else. `AnimatedProps.__getValue()` copies
+        // every key its leaf holds, `panHandlers` included.
+        writeProp(node, key, value);
+    }
+    if (merged.style !== undefined)
+        clearPublishedStyle(node);
+    // GATED, and this is the one place in the engine where "per frame" is the right unit to worry
+    // about. An `AnimatedProps` leaf calls this once per frame per animated node, so the template
+    // string and the `Object.keys` array it builds are 60 allocations a second per node — times the
+    // list, for a list that animates its rows. F-61 dismissed 347 ungated arguments because none of
+    // them was on a path that repeats; this one is, and F-61 had it in its own in-loop list and
+    // priced it as "runs once".
+    if (isDebug()) {
+        dlog(`setNativeProps root=${record.rootTag} tag=${record.tag} keys=${Object.keys(partial)}`);
+    }
+    // Queued, not committed: every write made in this task publishes together at the microtask
+    // boundary. With the record already in hand — asking for it again is a second crossing for a
+    // fact this function fetched four lines up.
+    requestCommitForRoot(record.rootTag);
+}

package/build/index.d.ts

@@ -1,4 +1,5 @@
-export { createElement, createRawText, createAnchor, ANCHOR_COMPONENT, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, setNodeHidden, setNodeComponent, setNodePressed, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node';
+export { createElement, createRawText, createAnchor, ANCHOR_COMPONENT, isAnchor, createVoid, VOID_COMPONENT, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, isSameShallowStyle, getPublishedStyle, setNodeHidden, setNodeComponent, setNodePressed, setNodeUnderlayShown, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, takePropKeyTally, } from './node';
+export { parentOf, childrenOf, firstChildOf, nextSiblingOf, isTextContainer, isRawTextNode, componentOf, textOf, propOf, propsOf, committedPayloadOf, } from './host-access';
 export { setAnimatedBehaviorStyle } from './animated/host-binding';
 export { isEventFor } from './view-config';
 export { registerComponent, setNativeViewConfigSource } from './registry';
@@ -11,10 +12,15 @@ export type { IComponentRegistration, INativeEventBinding, INativeViewConfig, IN
 export type { ISymbioteNode, ISymbioteEvent, IListener } from './node';
 export { SymbioteSurface, createSurface } from './surface';
 export { setEventDispatcher } from './dispatch';
-export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, readCommitProfile, } from './commit';
-export type { ICommitProfile } from './commit';
+export { setColorProcessor, processColor } from './platform-color';
+export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, requestCommitFor, } from './imperative';
+export { setTreeHost, treeHost, registerBeforeFlush, readCommitProfile, readSurfaceTelemetry, setNativeDebug, takeNativeDebugLog, } from './tree-host';
+export type { ISurfaceTelemetry } from './tree-host';
+export { nativeTreeHost, installNativeTreeHost } from './native-tree-host';
+export type { ITreeHost, ITreeCensus, ICommittedRecord, ICommitProfile, } from './tree-host';
 export { registerPostCommit, unregisterPostCommit } from './post-commit';
 export { ARIA_ALIAS_KEYS, foldAriaProps } from './accessibility-props';
+export { fabricProps } from './fabric-props';
 export { toPublicInstance } from './host-instance';
 export type { IHostInstance } from './host-instance';
 export { PlatformColor, DynamicColorIOS, isOpaqueColorValue, } from './platform-color';
@@ -47,8 +53,9 @@ export { getNativeModule, getEnforcingNativeModule } from './native-modules';
 export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource, } from './native-events';
 export type { IEventSubscription, IEventEmitterModule, INativeEventListener, IDeviceEventSource, } from './native-events';
 export { AnimatedNode, AnimatedWithChildren, AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedInterpolation, AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, AnimatedEvent, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, flushValue, Easing, createNumericInterpolation, checkValidRanges, TimingAnimation, SpringAnimation, DecayAnimation, AnimatedTracking, timing, spring, decay, parallel, sequence, stagger, loop, delay, nativeAnimated, isNativeAnimatedAvailable, AnimatedProps, createAnimatedLeafLifecycle, AnimatedStyle, AnimatedTransform, AnimatedMock, reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated';
-export type { IAnimatedLeafLifecycle, IValueXY, IRgbaValue, IColorInput, IEventConfig, IEventListener, IAnimatedEventHandler, INativeEventAttachment, IValueListener, IEasingFunction, IInterpolationConfig, IExtrapolateType, IAnimation, IEndCallback, IEndResult, ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig, ILoopAnimationConfig, INativeNodeConfig, INativeAnimationConfig, INativeEventMapping, IPlatformConfig, } from './animated';
+export type { IAnimatedLeafLifecycle, IValueXY, IRgbaValue, IColorInput, IEventConfig, IEventListener, IAnimatedEventHandler, INativeEventAttachment, IValueListener, IEasing, IEasingFunction, IInterpolationConfig, IExtrapolateType, IAnimation, IEndCallback, IEndResult, ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig, ILoopAnimationConfig, INativeNodeConfig, INativeAnimationConfig, INativeEventMapping, IPlatformConfig, } from './animated';
 export { getSlot } from './fabric';
+export { resetSlot } from './fabric';
 export type { IFabricSlot, IFabricNode, IFabricChildSet, IFabricProps, IFabricEventHandler, IRootTag, IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, } from './fabric';
 export { Alert } from './alert';
 export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, } from './alert';
@@ -64,6 +71,7 @@ export { Linking } from './linking';
 export type { IUrlEvent } from './linking';
 export { Vibration } from './vibration';
 export { ToastAndroid } from './toast-android';
+export { SoundManager } from './sound-manager';
 export { Settings } from './settings';
 export { I18nManager } from './i18n-manager';
 export type { II18nManagerConstants } from './i18n-manager';
@@ -79,7 +87,7 @@ export { createAppRegistry } from './app-registry';
 export type { IAppRegistry, ICreateAppRegistryResult, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './app-registry';
 export { Keyboard, KEYBOARD_EVENT } from './keyboard';
 export type { IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics, } from './keyboard';
-export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } from './text-input-state';
+export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, focusTextInput, } from './text-input-state';
 export { LayoutAnimation } from './layout-animation';
 export type { ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, ILayoutAnimationTypes, ILayoutAnimationProperties, } from './layout-animation';
 export { BackHandler } from './back-handler';
@@ -91,7 +99,6 @@ export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessi
 export { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight, } from './status-bar';
 export { hideTransition, STATUS_BAR_MANAGER, ANIMATED_HIDE_TRANSITION, STATIC_HIDE_TRANSITION, } from './status-bar/shared';
 export type { IStatusBarProps, IStatusBarStyle, IStatusBarAnimation, IStatusBarImperative, } from './status-bar/shared';
-export { registerHostBehavior, hasHostBehaviors, hostBehaviorFor, clearHostBehaviors, appListenerFor, addDerivedNode, } from './host-behavior';
+export { registerHostBehavior, hasHostBehaviors, hostBehaviorFor, clearHostBehaviors, appListenerFor, addDerivedNode, SLOT_DERIVED_ALL, } from './host-behavior';
 export type { IClaimMode, IHostBehavior, IPayloadFold } from './host-behavior';
-export { requestCommitFor } from './commit';
 export { setBehaviorListener, markPropsDirty } from './node';

package/build/index.js

@@ -7,7 +7,25 @@ export { createElement, createRawText, createAnchor,
 // 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.
-ANCHOR_COMPONENT, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, setNodeHidden, setNodeComponent, setNodePressed, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node.js';
+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`.
+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.
+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
+// what keeps the retained tree's shape ours to change (symbiote-fabric-cxx-surface §9).
+export { parentOf, childrenOf, firstChildOf, nextSiblingOf, isTextContainer, isRawTextNode, componentOf, textOf, propOf, propsOf, 
+// A TEST read, exported off the package root because the itest fixtures reach it that way — the
+// real payload builder lives in C++ and this is the only complete view of what it produced.
+committedPayloadOf, } from './host-access.js';
 // For a HOST BEHAVIOR that owns an animated style layer on its own node — TouchableOpacity's press
 // fade, which RN drives from an `Animated.View` the tag replaces.
 export { setAnimatedBehaviorStyle } from './animated/host-binding.js';
@@ -24,7 +42,23 @@ export { InteractionManager, Events as InteractionManagerEvents, } from './inter
 export { default as PanResponder } from './pan-responder/index.js';
 export { SymbioteSurface, createSurface } from './surface.js';
 export { setEventDispatcher } from './dispatch.js';
-export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, readCommitProfile, } from './commit.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 { 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.
+export { setTreeHost, treeHost, registerBeforeFlush, readCommitProfile, readSurfaceTelemetry, setNativeDebug, takeNativeDebugLog, } from './tree-host.js';
+// The native host, exported for the same audience as `setTreeHost` — a HOST author, not an app.
+// `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
@@ -32,10 +66,14 @@ export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibility
 // 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.
 export { registerPostCommit, unregisterPostCommit } from './post-commit.js';
-// The aria/role -> accessibility* fold. Lives here rather than in a component wrapper because a
-// LOWERED element has no wrapper: `fabricProps` runs it on the way to the payload, so every path
-// gets it. `core/components`' typed `resolveAccessibilityProps` delegates to this one.
+// 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.
+// `core/components`' typed `resolveAccessibilityProps` delegates to this one.
 export { ARIA_ALIAS_KEYS, foldAriaProps } from './accessibility-props.js';
+// The payload builder, exported for the HOST rather than for an app: the engine holds no tree, so
+// whoever built the bag calls this on the way to `createNode`. Headlessly that is the TypeScript
+// applier; on device it will be the C++ one, which does not have it yet.
+export { fabricProps } from './fabric-props.js';
 // The public instance every host node already is (React's getPublicInstance, the Vue renderer's
 // createElement): the imperative measure/setNativeProps/focus API, on the shared node prototype.
 // toPublicInstance is the identity that names the seam — see ./host-instance.
@@ -61,6 +99,10 @@ export { getNativeModule, getEnforcingNativeModule } from './native-modules/inde
 export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource, } from './native-events.js';
 export { AnimatedNode, AnimatedWithChildren, AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedInterpolation, AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, AnimatedEvent, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, flushValue, Easing, createNumericInterpolation, checkValidRanges, TimingAnimation, SpringAnimation, DecayAnimation, AnimatedTracking, timing, spring, decay, parallel, sequence, stagger, loop, delay, nativeAnimated, isNativeAnimatedAvailable, AnimatedProps, createAnimatedLeafLifecycle, AnimatedStyle, AnimatedTransform, AnimatedMock, reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated/index.js';
 export { getSlot } from './fabric.js';
+// Test seam, not app API: forget the bound slot so a
+// fixture can install a different host and be believed. Exported now that the harness lives in
+// 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
@@ -76,6 +118,7 @@ export { ActionSheetIOS } from './action-sheet-ios/index.js';
 export { Linking } from './linking';
 export { Vibration } from './vibration';
 export { ToastAndroid } from './toast-android/index.js';
+export { SoundManager } from './sound-manager/index.js';
 export { Settings } from './settings/index.js';
 export { I18nManager } from './i18n-manager/index.js';
 // Device-state / event modules (Dimensions, Appearance, AppState, Keyboard, …).
@@ -90,7 +133,7 @@ export { AppState } from './app-state/index.js';
 // framework-specific seam — how to build a runnable from a component provider).
 export { createAppRegistry } from './app-registry/index.js';
 export { Keyboard, KEYBOARD_EVENT } from './keyboard/index.js';
-export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } from './text-input-state.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';
@@ -99,10 +142,10 @@ export { AccessibilityInfo } from './accessibility-info';
 // .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, } from './host-behavior.js';
-export { requestCommitFor } from './commit.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 `node.props` — has no
-// prop to write. Pair it with `requestCommitFor`: dirtying is not publishing.
+// 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.
 export { setBehaviorListener, markPropsDirty } from './node.js';