@symbiote-native/engine 0.2.0 → 0.4.0

package/build/fabric.js

@@ -35,8 +35,17 @@ export function getSlot() {
     cached = {
         createNode: (reactTag, viewName, rootTag, props, instanceHandle) => createNode(reactTag, viewName, rootTag, props, instanceHandle),
         cloneNodeWithNewProps: (node, newProps) => cloneNodeWithNewProps(node, newProps),
-        cloneNodeWithNewChildren: node => cloneNodeWithNewChildren(node),
-        cloneNodeWithNewChildrenAndProps: (node, newProps) => cloneNodeWithNewChildrenAndProps(node, newProps),
+        // The host's 3-arg form is (node, children, props); ours keeps props second.
+        cloneNodeWithNewChildren: (node, children) => children === undefined
+            ? cloneNodeWithNewChildren(node)
+            : cloneNodeWithNewChildren(node, children),
+        cloneNodeWithNewChildrenAndProps: (node, newProps, children) => children === undefined
+            ? cloneNodeWithNewChildrenAndProps(node, newProps)
+            : cloneNodeWithNewChildrenAndProps(node, children, newProps),
+        supportsCloneWithChildren: typeof cloneNodeWithNewChildren === 'function' &&
+            cloneNodeWithNewChildren.length >= 2 &&
+            typeof cloneNodeWithNewChildrenAndProps === 'function' &&
+            cloneNodeWithNewChildrenAndProps.length >= 3,
         createChildSet: rootTag => createChildSet(rootTag),
         appendChild: (parent, child) => appendChild(parent, child),
         appendChildToSet: (childSet, child) => appendChildToSet(childSet, child),

package/build/host-behavior.d.ts

@@ -0,0 +1,47 @@
+import type { ISymbioteNode } from './node';
+/**
+ * A pure props -> props mapping a behavior applies on the way to the Fabric payload.
+ *
+ * It exists because a lowered element has no component body, and a wrapper's body is where the
+ * per-primitive prop FOLDS live — TextInput's W3C aliases (`inputMode` -> `keyboardType`,
+ * `readOnly` -> `editable`), Pressable's `disabled` -> `accessibilityState`. Every one of those was
+ * silently dropped the moment the primitive lowered: the raw alias reached Fabric as a key no
+ * ViewConfig declares, so nothing threw and nothing rendered differently in a headless test —
+ * only the device showed a numeric keyboard that never appeared.
+ *
+ * NOT a hook on `setProp`, for the same reason `afterCommit` is not: `setProp` is the hottest path
+ * in the engine. This runs once per node per payload build, and only for a node whose behavior
+ * supplied one.
+ *
+ * MUST be pure and MUST NOT mutate its input — `node.props` is the live bag, and the folds beside
+ * this one return their input by identity when there is nothing to do.
+ */
+export type IPayloadFold = (props: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+export interface IHostBehavior {
+    readonly ownedListeners?: readonly string[];
+    attach(node: ISymbioteNode): void;
+    attachAfterCommit?(node: ISymbioteNode): void;
+    afterCommit?(node: ISymbioteNode): void;
+    detach(node: ISymbioteNode): void;
+    readonly foldPayload?: IPayloadFold;
+}
+export declare function registerHostBehavior(component: string, behavior: IHostBehavior): void;
+export declare function hostBehaviorFor(tag: string): IHostBehavior | undefined;
+export declare function hasHostBehaviors(): boolean;
+export declare function ownsListener(node: ISymbioteNode, name: string): boolean;
+export declare function stashAppListener(node: ISymbioteNode, name: string, listener: unknown): void;
+export declare function appListenerFor(node: ISymbioteNode, name: string): unknown;
+export declare function attachHostBehavior(node: ISymbioteNode, tag: string): void;
+/**
+ * Run the deferred half of every behavior whose node has now been committed. Called from the commit
+ * path immediately after `completeRoot`, where fresh Fabric tags have just been assigned.
+ *
+ * `isCommitted` is passed in for the same no-cycle reason — `committedOf` lives in `commit.ts`. A
+ * still-uncommitted node stays in the set: a create superseded before it ever reached Fabric waits
+ * for the commit that lands it, and `detachSubtree` drops it if that commit never comes.
+ */
+export declare function runDeferredAttaches(isCommitted: (node: ISymbioteNode) => boolean): void;
+export declare function markDetachCandidate(node: ISymbioteNode): void;
+export declare function sweepDetachedBehaviors(topLevel: readonly ISymbioteNode[]): void;
+export declare function reattachHostBehaviors(node: ISymbioteNode): void;
+export declare function clearHostBehaviors(): void;

package/build/host-behavior.js

@@ -0,0 +1,262 @@
+// Per-TAG behavior on an engine node — the seam that lets a primitive's state machine live BELOW
+// the framework instead of inside a framework component.
+//
+// WHY IT EXISTS. Vue, Svelte, Solid and Angular all optimize element subtrees and stop at a
+// component boundary, so a primitive shipped as a component is charged a per-instance price in
+// each framework's own currency (an instance, a props Proxy, anchor nodes, an LView). A primitive
+// whose state the TEMPLATE never reads does not need to be a component at all — its machine only
+// needs a per-node home, and the engine node is one. `.claude/rules/host-primitive-tier.md` has
+// the tier model; this module is the tier-2 half of it.
+//
+// WHY A REGISTRY RATHER THAN A DIRECT IMPORT. `@symbiote-native/components` depends on
+// `@symbiote-native/engine`, never the reverse, so the engine cannot import `createPressHandlers`
+// and friends. CLAUDE.md's preferred answer to a registration problem — delete the indirection —
+// is therefore unavailable here; the inversion is forced, not chosen.
+//
+// WHICH MEANS THE REGISTRATION ITSELF IS THE HAZARD, and it is the one CLAUDE.md spells out:
+// Metro turns on `inlineRequires` for production only, moving a `require` down to the first place
+// its binding is used as a VALUE, and a barrel's `export { X } from './x'` compiles to a lazy
+// getter. A module whose only job is to call `registerHostBehavior` is never named as a value, so
+// re-exporting it from a barrel means it NEVER EVALUATES in a release build — dev is perfect,
+// release silently has no behavior. The one shape that works is a bare side-effect import that is
+// never re-exported from that barrel, the pattern in
+// `packages/slider/src/{react,vue,svelte,angular}/index.ts`:
+//
+//     import '../register';     // in the adapter entry — NOT `export * from '../register'`
+//
+// `registerHostBehavior` emits a `dlog` precisely so `DEBUG=1` answers "did my registration run at
+// all" before anyone starts debugging the behavior itself.
+import { dlog } from './debug.js';
+const behaviors = new Map();
+// Nodes that `removeChild` unlinked and that may or may not be coming back. See
+// `sweepDetachedBehaviors` for why the answer is not known until commit.
+const detachCandidates = new Set();
+// Nodes the sweep has torn down. A torn-down node can still be re-inserted — see
+// `reattachHostBehaviors` — and this is what tells an insert whether it must walk at all, so the
+// common case (building a fresh tree) never walks anything.
+const tornDown = new WeakSet();
+// The behavior a node actually got, remembered from its one and only registry lookup.
+//
+// THE REGISTRY IS KEYED BY INTRINSIC TAG AND THE NODE IS NOT. `node.component` is the FABRIC view
+// name: every adapter resolves the tag through `descriptorFor` before calling `createElement`, so
+// `symbiote-view` arrives as `RCTView`. Keying the registry by Fabric name instead is not an
+// option — a pressable resolves to `RCTView` like any other view, so the press machine would
+// attach to every plain `View` in the app. So the tag alphabet is used EXACTLY ONCE, at
+// `attachHostBehavior`, where the caller still holds it; every later lookup reads this map.
+//
+// Found by a peer session probing the installed shape, not by a unit test: the tests built their
+// subject with `createElement(PRESSABLE_TAG)`, which passes the tag AS the Fabric name and makes
+// the key match by accident. No adapter constructs a node that way, so the registration could
+// never have fired in an app while all six break-tests kept failing correctly on their own axes.
+const attached = new WeakMap();
+// The gate. `createElement` and `removeChild` are the two hottest paths in the engine (9 002 and
+// ~1 000 calls on one benchmark row set), so neither may pay a Set insert for a feature no app
+// uses yet. While this is false both paths cost one boolean read, the same discipline as `isDebug`.
+let hasBehaviors = false;
+export function registerHostBehavior(component, behavior) {
+    dlog(`registerHostBehavior: ${component}`);
+    behaviors.set(component, behavior);
+    hasBehaviors = true;
+}
+// Read access to the registry, so an audit can DERIVE what a behavior owns instead of restating it.
+// The one that matters: a name in `ownedListeners` is only reachable if `routeProp` also treats it
+// as a registered event — otherwise the app's callback lands in `node.props` and the machine, which
+// reads the stash, never sees it. That set difference is a test
+// (`core/components/src/behaviors/owned-listeners-are-routable.test.ts`) and it needs this to stay
+// derived rather than becoming another hand-written list.
+export function hostBehaviorFor(tag) {
+    return behaviors.get(tag);
+}
+export function hasHostBehaviors() {
+    return hasBehaviors;
+}
+// The app's listeners for names a behavior owns, per node. Not on the node: this exists only for
+// nodes carrying a behavior, and adding a field for it would pay a shape transition on every node
+// in every app for a feature almost none of them use.
+const stashed = new WeakMap();
+// Takes the NODE, not a component string: the caller (`setEventListener`) has only the Fabric name
+// by then, which is not the registry's alphabet. Reads the same map `attachHostBehavior` wrote.
+export function ownsListener(node, name) {
+    return attached.get(node)?.ownedListeners?.includes(name) === true;
+}
+export function stashAppListener(node, name, listener) {
+    let bag = stashed.get(node);
+    if (bag === undefined) {
+        bag = new Map();
+        stashed.set(node, bag);
+    }
+    if (listener === undefined)
+        bag.delete(name);
+    else
+        bag.set(name, listener);
+}
+// What the app wrote for an owned event name — the behavior's OUTPUT target. Undefined when the
+// app wired nothing, which is an ordinary case, not an error.
+export function appListenerFor(node, name) {
+    return stashed.get(node)?.get(name);
+}
+// `tag` is the INTRINSIC tag the adapter started from, not the resolved Fabric name it put on the
+// node. Defaulted to `node.component` so an adapter that has not been taught to pass it keeps
+// working for a behavior registered under a Fabric name — no adapter registers one, so in practice
+// the default simply never matches and costs one failed lookup.
+export function attachHostBehavior(node, tag) {
+    const behavior = behaviors.get(tag);
+    if (behavior === undefined)
+        return;
+    attached.set(node, behavior);
+    // A field rather than a lookup at payload-build time: `fabricProps` runs per node per commit and
+    // must not pay a Map probe to discover that almost nothing has a fold.
+    node.payloadFold = behavior.foldPayload;
+    behavior.attach(node);
+    if (behavior.attachAfterCommit !== undefined)
+        awaitingCommit.add(node);
+    if (behavior.afterCommit !== undefined)
+        committedEachTime.add(node);
+}
+// Nodes whose behavior declared `afterCommit`. Separate from `awaitingCommit` because the two have
+// opposite lifetimes: one empties as its nodes commit, this one holds until teardown.
+const committedEachTime = new Set();
+// Nodes whose behavior declared `attachAfterCommit` and whose first commit has not happened yet.
+//
+// A plain Set rather than a call into `whenCommitted`: `commit.ts` already imports this module, so
+// reaching back for it would close an import cycle. Metro's `inlineRequires` has made module
+// evaluation order a real hazard here rather than a theoretical one (see this file's own
+// registration comment), so the dependency stays one-directional and commit DRAINS this instead.
+const awaitingCommit = new Set();
+/**
+ * Run the deferred half of every behavior whose node has now been committed. Called from the commit
+ * path immediately after `completeRoot`, where fresh Fabric tags have just been assigned.
+ *
+ * `isCommitted` is passed in for the same no-cycle reason — `committedOf` lives in `commit.ts`. A
+ * still-uncommitted node stays in the set: a create superseded before it ever reached Fabric waits
+ * for the commit that lands it, and `detachSubtree` drops it if that commit never comes.
+ */
+export function runDeferredAttaches(isCommitted) {
+    // The gate: an app registering no behavior pays two Set-size reads per commit, matching the
+    // discipline `hasBehaviors` sets for `createElement`.
+    if (awaitingCommit.size === 0 && committedEachTime.size === 0)
+        return;
+    // SETUP BEFORE THE RECURRING BEAT, and the order is load-bearing on the FIRST commit, where a
+    // node carrying both hooks is drained by both. `attachAfterCommit` is where a behavior seeds the
+    // mirrors that `afterCommit` then compares against; run them the other way round and the first
+    // beat compares against nothing and commands a redundant write down to native.
+    for (const node of awaitingCommit) {
+        if (!isCommitted(node))
+            continue;
+        awaitingCommit.delete(node);
+        attached.get(node)?.attachAfterCommit?.(node);
+    }
+    for (const node of committedEachTime) {
+        if (!isCommitted(node))
+            continue;
+        attached.get(node)?.afterCommit?.(node);
+    }
+}
+// `removeChild` is NOT the destroy signal, and reading it as one is the bug this indirection
+// exists to avoid. Engine-side it looks like one — a reorder goes through `detach` inside
+// appendChild/insertBefore and never lands in removeChild — but a FRAMEWORK can spell a move as
+// remove-then-reinsert. Solid does, in `solid-js/universal`: `replaceNode` (universal.cjs:186) is
+// `insertNode` + `removeNode`, and `reconcileArrays` calls it at :157 for a node that IS in the
+// new array and is needed at a later index. Its sibling call at :130 is guarded by
+// `if (!map || !map.has(a[aStart]))` and removes only genuinely absent nodes — one guarded call
+// and one not, which is why a quick read of that file says "removeChild means gone".
+//
+// Tearing down there would kill the machine of a node that returns alive a few operations later,
+// in the same batch: long-press silently stops working after certain list reorders, on device
+// only, with nothing red. So removal only nominates.
+export function markDetachCandidate(node) {
+    detachCandidates.add(node);
+}
+// Commit is where a removal is CHEAPEST to distinguish from a move — a node unlinked and
+// reinserted before the commit is back in the tree by now, which covers Solid's replaceNode. It is
+// NOT a proof of death, and the earlier version of this comment claimed it was. Svelte parks LIVE
+// nodes offscreen across commits and sometimes across seconds: `detachFromParent`
+// (adapters/svelte/src/dom-shim/shim-node.ts) moves a node into a DocumentFragment that has no
+// engine node, calls engineRemoveChild AND requestCommit, and Svelte fully intends to bring it
+// back — from a parked `{#if}` branch, from `each.js`'s destroy_effects, and worst, from
+// boundary.js's move_effect while a pending snippet shows, which returns when async work resolves.
+// So a sweep can and does tear down a node that comes back, which is why `attach` is re-runnable
+// (reattachHostBehaviors) rather than why the sweep tries to be cleverer. The machine RESTARTS on
+// re-insert instead of surviving an arbitrary absence; a parked subtree is offscreen, so nobody is
+// mid-gesture in it, and teardown staying unconditional means there is no leak mode.
+//
+// The subtree walk lives here rather than at removal, and is cheaper for it: only the nodes that
+// actually left are walked.
+export function sweepDetachedBehaviors(topLevel) {
+    if (detachCandidates.size === 0)
+        return;
+    // A surface's top-level nodes carry `parent === undefined` by design (surface.ts), and
+    // `commitChildren` re-lists them without going through appendChild — so for those the parent
+    // check alone would report a live node as gone.
+    const seen = new Set();
+    for (const node of detachCandidates) {
+        if (node.parent !== undefined || topLevel.includes(node))
+            continue;
+        detachSubtree(node, seen);
+    }
+    detachCandidates.clear();
+}
+// `seen` guards the one overlap the candidate set can contain: a removed parent and a removed
+// descendant of it are both nominated, and without it the descendant is detached twice.
+function detachSubtree(node, seen) {
+    if (seen.has(node))
+        return;
+    seen.add(node);
+    // Marked whether or not THIS node carries a behavior: the mark is what tells a later insert to
+    // walk, and the node re-inserted is usually a plain container whose DESCENDANT holds the
+    // machine. Gating the mark on `behaviors.has` made the row wrapper unmarked and the whole walk
+    // skip — the first version of the parked-node test caught exactly that.
+    tornDown.add(node);
+    // Drop a deferral the node never got to run. NO TEST CAN SEE THIS, and it is kept anyway —
+    // stated rather than left as apparent coverage. The `isCommitted` predicate in the drain already
+    // stops such a node from firing, so removing this line changes no observable behaviour; what it
+    // changes is that a node created and torn down inside one tick stays in the Set forever, holding
+    // a strong reference to a dead subtree. A leak, not a wrong result, and this file's break-test
+    // discipline correctly reports it as unfalsifiable.
+    awaitingCommit.delete(node);
+    // The recurring hook stops with the node, and unlike the deferral above this one has a visible
+    // consequence if forgotten: a torn-down node would keep being asked to reconcile props against a
+    // subtree that has left the tree, on every commit, forever.
+    // The recurring hook stops with the node, and unlike the deferral above this one has a visible
+    // consequence if forgotten: a torn-down node would keep being asked to reconcile props against a
+    // subtree that has left the tree, on every commit, forever.
+    committedEachTime.delete(node);
+    // The map, not the registry: by here only the Fabric name is left on the node.
+    attached.get(node)?.detach(node);
+    for (const child of node.children)
+        detachSubtree(child, seen);
+}
+// Re-arms a node the sweep tore down but that the framework put back. Called from appendChild and
+// insertBefore, and it is a WeakSet miss — no walk at all — for every node in a freshly built
+// tree, which is the path that runs ~9 000 times per benchmark create.
+export function reattachHostBehaviors(node) {
+    if (!tornDown.has(node))
+        return;
+    reattachSubtree(node);
+}
+function reattachSubtree(node) {
+    if (tornDown.has(node)) {
+        tornDown.delete(node);
+        const behavior = attached.get(node);
+        behavior?.attach(node);
+        // Re-arm the deferred half too. A parked node usually returns with its tag intact, so this
+        // fires on the next drain — but re-arming is what keeps `attach` and `attachAfterCommit` a
+        // PAIR. Restore only one and a behavior that splits its setup across the two comes back
+        // half-initialised, which is the failure this seam exists to prevent.
+        if (behavior?.attachAfterCommit !== undefined)
+            awaitingCommit.add(node);
+        if (behavior?.afterCommit !== undefined)
+            committedEachTime.add(node);
+    }
+    for (const child of node.children)
+        reattachSubtree(child);
+}
+// Test-only. A registry is module state, so a suite that registers a behavior leaks it into every
+// later test in the same file unless it is cleared.
+export function clearHostBehaviors() {
+    behaviors.clear();
+    detachCandidates.clear();
+    awaitingCommit.clear();
+    committedEachTime.clear();
+    hasBehaviors = false;
+}

package/build/host-instance/index.d.ts

@@ -1,11 +1,3 @@
-import { type ISymbioteNode } from '../node';
-import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess } from '../fabric';
-export interface IHostInstance extends ISymbioteNode {
-    measure(callback: IMeasureOnSuccess): void;
-    measureInWindow(callback: IMeasureInWindowOnSuccess): void;
-    measureLayout(relativeToNativeNode: IHostInstance | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;
-    setNativeProps(nativeProps: Record<string, unknown>): void;
-    focus(): void;
-    blur(): void;
-}
+import type { ISymbioteNode } from '../node';
+export type IHostInstance = ISymbioteNode;
 export declare function toPublicInstance(node: ISymbioteNode): IHostInstance;

package/build/host-instance/index.js

@@ -1,49 +1,16 @@
-// The public instance a host ref hands back, RN's ReactFabricHostComponent. toPublicInstance
-// augments the retained node with the imperative API libraries reach through (reanimated,
-// gesture-handler, react-navigation): measure / measureInWindow / measureLayout /
-// setNativeProps / focus / blur. The methods are attached onto the node object itself (not its
-// props, so they never reach Fabric); each resolves the node's CURRENT committed handle at call
-// time through the engine, so a clone-on-write commit between calls is transparent.
+// The public instance a host ref hands back, RN's ReactFabricHostComponent: measure /
+// measureInWindow / measureLayout / setNativeProps / focus / blur, the imperative API libraries
+// reach through (reanimated, gesture-handler, react-navigation).
 //
-// This lives in the engine, not an adapter: it depends only on engine internals (the commit
-// free functions + the retained node), so every adapter inherits the SAME public instance for
-// free — React's getPublicInstance and the Vue renderer both graft this onto their host nodes.
-import { measure as engineMeasure, measureInWindow as engineMeasureInWindow, measureLayout as engineMeasureLayout, setNativeProps as engineSetNativeProps, dispatchViewCommand, } from '../commit.js';
-import { isSymbioteNode } from '../node.js';
-import { dlog } from '../debug.js';
-const FOCUS_COMMAND = 'focus';
-const BLUR_COMMAND = 'blur';
-function isHostInstance(node) {
-    return typeof Reflect.get(node, 'measure') === 'function';
-}
-// Augment the retained node with the public-instance methods, once. The same node
-// instance persists across commits, so attaching once is enough, every method reads
-// the live handle through the engine on each call.
+// EVERY retained node already carries it — the six methods live on the shared node prototype
+// (`SymbioteNode` in ../node), so there is nothing left to graft and `toPublicInstance` is the
+// identity. It used to Object.assign six fresh closures onto each node; that cost 54 000 closures
+// per 1 000-row create and made GC the largest bucket in the profile. The rationale, and why
+// React was the one adapter not paying it, is recorded on ISymbioteNode.
+//
+// The function and the type both stay: they are the seam every adapter names (React's
+// getPublicInstance, Vue's nodeOps createElement, Angular's Renderer2, Svelte's dom-shim), and a
+// call site saying "hand me the public instance" still reads correctly at a no-op.
 export function toPublicInstance(node) {
-    if (isHostInstance(node))
-        return node;
-    return Object.assign(node, {
-        measure(callback) {
-            engineMeasure(node, callback);
-        },
-        measureInWindow(callback) {
-            engineMeasureInWindow(node, callback);
-        },
-        measureLayout(relativeToNativeNode, onSuccess, onFail) {
-            if (!isSymbioteNode(relativeToNativeNode)) {
-                dlog('measureLayout: relative target must be a host ref');
-                return;
-            }
-            engineMeasureLayout(node, relativeToNativeNode, onSuccess, onFail);
-        },
-        setNativeProps(nativeProps) {
-            engineSetNativeProps(node, nativeProps);
-        },
-        focus() {
-            dispatchViewCommand(node, FOCUS_COMMAND, []);
-        },
-        blur() {
-            dispatchViewCommand(node, BLUR_COMMAND, []);
-        },
-    });
+    return node;
 }

package/build/image-loader.js

@@ -14,7 +14,7 @@
 // alongside Alert/Share, not in a view/render-*.ts file (whose contract is zero state / zero
 // native bridge).
 import { dlog } from './debug.js';
-import { resolveImageSource } from './image-source-resolver.js';
+import { resolveImageSource, } from './image-source-resolver.js';
 import { getNativeModule } from './native-modules/index.js';
 import { Platform } from './platform';
 import { isNumber } from './type-guards.js';
@@ -26,7 +26,8 @@ const IMAGE_LOADER_MODULE = 'ImageLoader';
 let imageLoaderModule;
 function getImageLoader() {
     if (imageLoaderModule === undefined) {
-        imageLoaderModule = getNativeModule(IMAGE_LOADER_MODULE);
+        imageLoaderModule =
+            getNativeModule(IMAGE_LOADER_MODULE);
         dlog(`Image: ImageLoader module ${imageLoaderModule ? 'resolved' : 'NOT resolved (null)'}`);
     }
     return imageLoaderModule;

package/build/index.d.ts

@@ -1,8 +1,8 @@
-export { createElement, createRawText, createAnchor, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, getExplicitStyle, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node';
+export { createElement, createRawText, createAnchor, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, setNodeHidden, setNodeComponent, setNodePressed, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node';
 export { isEventFor } from './view-config';
 export { registerComponent, setNativeViewConfigSource } from './registry';
 export { isRecord } from './type-guards';
-export { InteractionManager, Events as InteractionManagerEvents } from './interaction-manager';
+export { InteractionManager, Events as InteractionManagerEvents, } from './interaction-manager';
 export type { IInteractionEvent, ISimpleTask, IPromiseTask, ITask, IHandle, ICancellable, } from './interaction-manager';
 export { default as PanResponder } from './pan-responder';
 export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from './pan-responder';
@@ -10,11 +10,14 @@ 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, } from './commit';
+export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, readCommitProfile, } from './commit';
+export type { ICommitProfile } from './commit';
+export { registerPostCommit, unregisterPostCommit } from './post-commit';
+export { foldAriaProps } from './accessibility-props';
 export { toPublicInstance } from './host-instance';
 export type { IHostInstance } from './host-instance';
-export { PlatformColor, DynamicColorIOS, isOpaqueColorValue } from './platform-color';
-export type { IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple } from './platform-color';
+export { PlatformColor, DynamicColorIOS, isOpaqueColorValue, } from './platform-color';
+export type { IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple, } from './platform-color';
 export { processBoxShadow } from './process-box-shadow';
 export type { IParsedBoxShadow } from './process-box-shadow';
 export { processFilter } from './process-filter';
@@ -28,19 +31,19 @@ export type { IParsedBackgroundImage } from './process-background-image';
 export { flattenStyle } from './style';
 export type { IViewStyle, ITextStyle, IStyleProp, IDimensionValue, IFlexAlign, IFlexJustify, ITransformProp, IBoxShadowValue, IDropShadowValue, IFilterFunction, IColorStopValue, ILinearGradientValue, IRadialGradientValue, IRadialGradientPosition, IRadialGradientShape, IRadialGradientSize, IBackgroundImageValue, IBlendMode, } from './styles';
 export { StyleSheet, computeHairlineWidth } from './style-sheet';
-export { registerStyles, resolveClassName, clearGlobalStyles, isClassNameValue, } from './style-registry';
-export type { IClassNameValue } from './style-registry';
-export { scopeClassName } from './style-registry/scope';
-export type { IClassToggleMap, IScopableClassValue } from './style-registry/scope';
+export { registerRules, resolveClassName, clearGlobalStyles, isClassNameValue, } from './style-registry';
+export type { IClassNameValue, IStyleRule } from './style-registry';
+export { renameClassTokens } from './style-registry/scope';
+export type { IClassNameRenames, IClassToggleMap, IScopableClassValue, } from './style-registry/scope';
 export { Platform } from './platform';
-export type { IPlatformStatic, IPlatformOSType, IPlatformSelectSpec } from './platform';
+export type { IPlatformStatic, IPlatformOSType, IPlatformSelectSpec, } from './platform';
 export type { IPlatformConstantsIOS } from './platform/index.ios';
 export type { IPlatformConstantsAndroid } from './platform/index.android';
 export { dlog, isDebug } from './debug';
 export { reportUncaughtError } from './report-error';
 export type { IUncaughtErrorInfo } from './report-error';
 export { getNativeModule, getEnforcingNativeModule } from './native-modules';
-export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource } from './native-events';
+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';
@@ -51,8 +54,8 @@ export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlert
 export { Share } from './share';
 export type { IShareContent, IShareOptions, IShareAction } from './share';
 export { imageStatics } from './image-loader';
-export type { IImageStatics, IImageSize, IImageCacheStatus } from './image-loader';
-export { setImageSourceResolver, resolveImageSource } from './image-source-resolver';
+export type { IImageStatics, IImageSize, IImageCacheStatus, } from './image-loader';
+export { setImageSourceResolver, resolveImageSource, } from './image-source-resolver';
 export type { IImageSource, IImageSourceProp } from './image-source-resolver';
 export { ActionSheetIOS } from './action-sheet-ios';
 export type { IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, } from './action-sheet-ios';
@@ -74,16 +77,20 @@ export type { IAppStateStatus, IAppStateEvent } from './app-state';
 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 type { IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics, } from './keyboard';
 export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } 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';
 export type { IBackPressEventName, IBackPressHandler } from './back-handler';
-export { PermissionsAndroid, PERMISSIONS, RESULTS } from './permissions-android';
-export type { IPermission, IPermissionStatus, IRationale } from './permissions-android';
+export { PermissionsAndroid, PERMISSIONS, RESULTS, } from './permissions-android';
+export type { IPermission, IPermissionStatus, IRationale, } from './permissions-android';
 export { AccessibilityInfo } from './accessibility-info';
 export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityInfoStatic, IAccessibilityEventType, IAccessibilityHandle, } from './accessibility-info/shared';
-export { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight } from './status-bar';
+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, } from './host-behavior';
+export type { IHostBehavior } from './host-behavior';
+export { requestCommitFor } from './commit';
+export { setBehaviorListener } from './node';

package/build/index.js

@@ -2,7 +2,7 @@
 // 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, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, getExplicitStyle, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node.js';
+export { createElement, createRawText, createAnchor, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, censusRetainedTree, getExplicitStyle, setNodeHidden, setNodeComponent, setNodePressed, setText, isSymbioteNode, isSymbioteEvent, RAW_TEXT_COMPONENT, debugNodeId, } from './node.js';
 export { isEventFor } from './view-config.js';
 export { registerComponent, setNativeViewConfigSource } from './registry.js';
 // Real cross-package consumer: core/components' KeyboardAvoidingView render narrows
@@ -10,18 +10,29 @@ export { registerComponent, setNativeViewConfigSource } from './registry.js';
 export { isRecord } from './type-guards.js';
 // InteractionManager: pure JS (timers + emitter), framework-agnostic, so it lives
 // here; every adapter re-exports it.
-export { InteractionManager, Events as InteractionManagerEvents } from './interaction-manager/index.js';
+export { InteractionManager, Events as InteractionManagerEvents, } from './interaction-manager/index.js';
 // PanResponder: pure JS gesture recognition over the View responder props,
 // framework-agnostic, so it lives here; every adapter re-exports it.
 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, } from './commit.js';
-// The public instance grafted onto a host node by every adapter (React's getPublicInstance,
-// the Vue renderer's createElement): the imperative measure/setNativeProps/focus API. Lives
-// here because it depends only on engine internals, so all adapters inherit it identically.
+export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, readCommitProfile, } from './commit.js';
+// "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.
+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.
+export { foldAriaProps } from './accessibility-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.
 export { toPublicInstance } from './host-instance/index.js';
-export { PlatformColor, DynamicColorIOS, isOpaqueColorValue } from './platform-color/index.js';
+export { PlatformColor, DynamicColorIOS, isOpaqueColorValue, } from './platform-color/index.js';
 // 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';
@@ -33,13 +44,13 @@ export { processFontVariant } from './process-font-variant.js';
 export { processBackgroundImage } from './process-background-image/index.js';
 export { flattenStyle } from './style/index.js';
 export { StyleSheet, computeHairlineWidth } from './style-sheet/index.js';
-export { registerStyles, resolveClassName, clearGlobalStyles, isClassNameValue, } from './style-registry/index.js';
-export { scopeClassName } from './style-registry/scope.js';
+export { registerRules, resolveClassName, clearGlobalStyles, isClassNameValue, } from './style-registry/index.js';
+export { renameClassTokens } from './style-registry/scope.js';
 export { Platform } from './platform';
 export { dlog, isDebug } from './debug.js';
 export { reportUncaughtError } from './report-error.js';
 export { getNativeModule, getEnforcingNativeModule } from './native-modules/index.js';
-export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource } from './native-events.js';
+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';
 // Imperative runtime modules: framework-agnostic native-bridge consumers (no visual, no
@@ -52,7 +63,7 @@ export { Share } from './share';
 // no view of its own, same shape as Alert/Share. The source-resolution seam it shares with
 // @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 { setImageSourceResolver, resolveImageSource, } from './image-source-resolver.js';
 export { ActionSheetIOS } from './action-sheet-ios/index.js';
 export { Linking } from './linking';
 export { Vibration } from './vibration';
@@ -74,9 +85,12 @@ export { Keyboard, KEYBOARD_EVENT } from './keyboard/index.js';
 export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } 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 { PermissionsAndroid, PERMISSIONS, RESULTS, } from './permissions-android/index.js';
 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 { 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, } from './host-behavior.js';
+export { requestCommitFor } from './commit.js';
+export { setBehaviorListener } from './node.js';

package/build/interaction-manager/index.js

@@ -202,7 +202,8 @@ class InteractionManagerImpl {
                 break;
             if (typeof next === 'function')
                 next();
-            if (this.deadline > DEFAULT_DEADLINE && Date.now() - startTime >= this.deadline) {
+            if (this.deadline > DEFAULT_DEADLINE &&
+                Date.now() - startTime >= this.deadline) {
                 if (this.taskQueue.length > 0) {
                     scheduleTimeout(() => {
                         this.flushQueue();