@symbiote-native/engine 1.3.1 → 1.5.0

package/build/events/names.d.ts

@@ -0,0 +1,24 @@
+export declare const BUBBLING_EVENTS: Readonly<Record<string, string>>;
+export declare const DIRECT_EVENTS: Readonly<Record<string, string>>;
+export declare const TOUCH_START = "topTouchStart";
+export declare const TOUCH_MOVE = "topTouchMove";
+export declare const TOUCH_END = "topTouchEnd";
+export declare const TOUCH_CANCEL = "topTouchCancel";
+export declare const PRESS = "press";
+export declare const RESPONDER_GRANT = "responderGrant";
+export declare const RESPONDER_REJECT = "responderReject";
+export declare const RESPONDER_START = "responderStart";
+export declare const RESPONDER_MOVE = "responderMove";
+export declare const RESPONDER_END = "responderEnd";
+export declare const RESPONDER_RELEASE = "responderRelease";
+export declare const RESPONDER_TERMINATE = "responderTerminate";
+export declare const RESPONDER_TERMINATION_REQUEST = "responderTerminationRequest";
+export declare const SHOULD_SET_NAMES: Readonly<Record<'start' | 'move', {
+    readonly capture: string;
+    readonly bubble: string;
+}>>;
+export declare const PRESS_IN = "pressIn";
+export declare const PRESS_OUT = "pressOut";
+export declare const LONG_PRESS = "longPress";
+export declare const DEFAULT_LONG_PRESS_MS = 500;
+export declare const LONG_PRESS_DEACTIVATION_DISTANCE = 10;

package/build/events/names.js

@@ -0,0 +1,80 @@
+// Raw Fabric event name -> listener name, and the synthesized names that have no raw event at all.
+// Kept apart from the handler so the file holding the strings is not the file read while debugging
+// a gesture
+// Bubbling events walk target -> root, direct ones fire on the target alone. `press` is synthesized
+// from a touch sequence and `layout` is direct, so neither is in these tables
+export const BUBBLING_EVENTS = {
+    topFocus: 'focus',
+    topBlur: 'blur',
+    topChange: 'change',
+    topEndEditing: 'endEditing',
+    topSubmitEditing: 'submitEditing',
+    topKeyPress: 'keyPress',
+};
+export const DIRECT_EVENTS = {
+    topLayout: 'layout',
+    topScroll: 'scroll',
+    topScrollBeginDrag: 'scrollBeginDrag',
+    topScrollEndDrag: 'scrollEndDrag',
+    topMomentumScrollBegin: 'momentumScrollBegin',
+    topMomentumScrollEnd: 'momentumScrollEnd',
+    topSelectionChange: 'selectionChange',
+    topContentSizeChange: 'contentSizeChange',
+    topLoadStart: 'loadStart',
+    topLoad: 'load',
+    topLoadEnd: 'loadEnd',
+    topError: 'error',
+    topProgress: 'progress',
+    topPartialLoad: 'partialLoad',
+    topRefresh: 'refresh',
+    topShow: 'show',
+    topRequestClose: 'requestClose',
+    topDismiss: 'dismiss',
+    topOrientationChange: 'orientationChange',
+    topTextLayout: 'textLayout',
+    topScrollToTop: 'scrollToTop',
+    // From RN's base ViewConfig, so any view may emit them. `accessibilityAction` fires on both
+    // platforms; the other three have no Android producer and are inert there
+    topAccessibilityAction: 'accessibilityAction',
+    topAccessibilityTap: 'accessibilityTap',
+    topMagicTap: 'magicTap',
+    topAccessibilityEscape: 'accessibilityEscape',
+};
+export const TOUCH_START = 'topTouchStart';
+export const TOUCH_MOVE = 'topTouchMove';
+export const TOUCH_END = 'topTouchEnd';
+export const TOUCH_CANCEL = 'topTouchCancel';
+export const PRESS = 'press';
+// The responder protocol (PanResponder / Touchable), post-`on` names: `onResponderMove` is
+// `responderMove` here. RN's negotiation and its two-phase walk live in `./responder`
+export const RESPONDER_GRANT = 'responderGrant';
+export const RESPONDER_REJECT = 'responderReject';
+export const RESPONDER_START = 'responderStart';
+export const RESPONDER_MOVE = 'responderMove';
+export const RESPONDER_END = 'responderEnd';
+export const RESPONDER_RELEASE = 'responderRelease';
+export const RESPONDER_TERMINATE = 'responderTerminate';
+export const RESPONDER_TERMINATION_REQUEST = 'responderTerminationRequest';
+// The should-set pair asked per phase, as one table т.к. the only thing separating a start
+// negotiation from a move one is which two names get asked
+export const SHOULD_SET_NAMES = {
+    start: {
+        capture: 'startShouldSetResponderCapture',
+        bubble: 'startShouldSetResponder',
+    },
+    move: {
+        capture: 'moveShouldSetResponderCapture',
+        bubble: 'moveShouldSetResponder',
+    },
+};
+// Synthesized alongside `press` so a Pressable can paint its pressed state. Both fire on the node
+// the touch STARTED on, `pressOut` on end and on cancel
+export const PRESS_IN = 'pressIn';
+export const PRESS_OUT = 'pressOut';
+// Synthesized from a sustained hold, so a bare Text or View gets `onLongPress` with no native
+// event behind it. A fired long press suppresses the tap on release
+export const LONG_PRESS = 'longPress';
+export const DEFAULT_LONG_PRESS_MS = 500;
+// How far the touch may drift before the pending long press is cancelled
+// (`Pressability.DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE`)
+export const LONG_PRESS_DEACTIVATION_DISTANCE = 10;

package/build/events/press.d.ts

@@ -0,0 +1,20 @@
+import { type ISymbioteNode } from '../node';
+export interface IPressGesture {
+    owner: ISymbioteNode;
+    longPressTimer: ReturnType<typeof setTimeout> | undefined;
+    longPressFired: boolean;
+    longPressStart: {
+        x: number;
+        y: number;
+    } | undefined;
+}
+export declare const activePresses: Set<IPressGesture>;
+export declare function clearLongPress(press: IPressGesture): void;
+export declare function takeAllPresses(): IPressGesture[];
+export declare function findActivePress(target: ISymbioteNode): IPressGesture | undefined;
+export declare function takeEndedPresses(nativeEvent: Record<string, unknown>): IPressGesture[];
+export declare function readTouchPoint(nativeEvent: Record<string, unknown>): {
+    x: number;
+    y: number;
+} | undefined;
+export declare function hasRemainingTouchWithin(owner: ISymbioteNode, nativeEvent: Record<string, unknown>): boolean;

package/build/events/press.js

@@ -0,0 +1,89 @@
+// The synthesized tap: Fabric has no `press` event, so one is built from a touch sequence. This
+// module owns the in-flight gestures and the long-press clock, nothing about delivery
+// A press is INDEPENDENT of the responder: `negotiateResponder` runs on the same touch frames and
+// neither consumes the other, т.к. a View can be a Pressable and a PanResponder target at once
+import { isRecord } from '../type-guards.js';
+import { isSymbioteNode } from '../node.js';
+import { endsWithin } from './delivery.js';
+// Each unrelated target owns an independent press, and further fingers under the same owner JOIN
+// it, so one target still sees exactly one `pressIn` / `press` / `pressOut` lifecycle
+export const activePresses = new Set();
+export function clearLongPress(press) {
+    if (press.longPressTimer !== undefined) {
+        clearTimeout(press.longPressTimer);
+        press.longPressTimer = undefined;
+    }
+}
+export function takeAllPresses() {
+    const presses = [...activePresses];
+    activePresses.clear();
+    for (const press of presses)
+        clearLongPress(press);
+    return presses;
+}
+export function findActivePress(target) {
+    for (const press of activePresses) {
+        if (endsWithin(target, press.owner))
+            return press;
+    }
+    return undefined;
+}
+// Every press whose last finger left in this frame, removed from the active set. An owner with a
+// finger still down keeps its press, which is what makes a multi-touch lift not a release
+export function takeEndedPresses(nativeEvent) {
+    const ended = [];
+    for (const press of activePresses) {
+        if (hasRemainingTouchWithin(press.owner, nativeEvent))
+            continue;
+        activePresses.delete(press);
+        clearLongPress(press);
+        ended.push(press);
+    }
+    return ended;
+}
+function pagePointOf(source) {
+    if (!source)
+        return undefined;
+    const { pageX, pageY } = source;
+    if (typeof pageX === 'number' && typeof pageY === 'number')
+        return { x: pageX, y: pageY };
+    return undefined;
+}
+// The changed finger's page coordinate, falling back to the active-touch list and then to
+// undefined, which callers read as "skip the coordinate-dependent logic" rather than guessing
+export function readTouchPoint(nativeEvent) {
+    const direct = pagePointOf(nativeEvent);
+    if (direct)
+        return direct;
+    // `changedTouches` identifies the finger for THIS frame, so it is read before the full
+    // active-touch list, whose first entry may belong to another simultaneously pressed target
+    for (const key of ['changedTouches', 'touches']) {
+        const touches = nativeEvent[key];
+        if (!Array.isArray(touches))
+            continue;
+        for (const touch of touches) {
+            if (!isRecord(touch))
+                continue;
+            const point = pagePointOf(touch);
+            if (point)
+                return point;
+        }
+    }
+    return undefined;
+}
+// Whether any touch still down started inside `owner`. RN's `noResponderTouches` walks
+// `nativeEvent.touches` the same way; a headless smoke fires an empty `{}`, so no remaining touch,
+// which preserves single-touch behavior
+export function hasRemainingTouchWithin(owner, nativeEvent) {
+    const touches = nativeEvent.touches;
+    if (!Array.isArray(touches))
+        return false;
+    for (const touch of touches) {
+        if (!isRecord(touch))
+            continue;
+        const target = touch.target;
+        if (isSymbioteNode(target) && endsWithin(target, owner))
+            return true;
+    }
+    return false;
+}

package/build/events/responder.d.ts

@@ -0,0 +1,6 @@
+import { type ISymbioteNode } from '../node';
+export declare function heldResponder(): ISymbioteNode | undefined;
+export declare function clearResponder(): void;
+/** Release the responder to native, on a final touch end or a terminate. */
+export declare function releaseResponderToNative(node: ISymbioteNode): void;
+export declare function negotiateResponder(target: ISymbioteNode, phase: 'start' | 'move', nativeEvent: Record<string, unknown>): void;

package/build/events/responder.js

@@ -0,0 +1,124 @@
+// The responder protocol: who owns the in-flight gesture, and the negotiation that moves it.
+// Split from `./index` so the touch handler reads as four phases rather than as the negotiation
+// `currentResponder` is module state reached from outside through `heldResponder` and
+// `clearResponder`, т.к. the touch handler must read it between its own phases
+import { dlog, isDebug } from '../debug.js';
+import { setIsJSResponder } from '../imperative.js';
+import { hasListenerFor } from '../node.js';
+import { callOwnListener, lowestCommonAncestor, pathToRoot } from './delivery.js';
+import { RESPONDER_GRANT, RESPONDER_REJECT, RESPONDER_TERMINATE, RESPONDER_TERMINATION_REQUEST, SHOULD_SET_NAMES, } from './names.js';
+// The node that claimed the responder for the in-flight touch, or undefined when nobody did.
+// Receives move and release/terminate
+let currentResponder;
+export function heldResponder() {
+    return currentResponder;
+}
+export function clearResponder() {
+    currentResponder = undefined;
+}
+// RN's two-phase should-set walk: CAPTURE root to deepest, then BUBBLE deepest to root, first true
+// wins. `skip` drops the deepest node when it IS the current responder, т.к. asking the holder to
+// re-claim would let its should-set consume the frame from under its own `onResponderMove`
+function findWantsResponder(path, phase, nativeEvent, skip) {
+    const names = SHOULD_SET_NAMES[phase];
+    for (let i = path.length - 1; i >= 0; i--) {
+        if (path[i] !== skip &&
+            callOwnListener(path[i], names.capture, nativeEvent) === true) {
+            return path[i];
+        }
+    }
+    for (const node of path) {
+        if (node !== skip &&
+            callOwnListener(node, names.bubble, nativeEvent) === true)
+            return node;
+    }
+    return undefined;
+}
+// Tell native which node owns the gesture, RN's `injectGlobalResponderHandler`. The OLD owner
+// first, then the new one, both in one call so no site can do half of it
+// WITHOUT THIS A JS RESPONDER LOSES TO ANY SCROLL VIEW ABOVE IT, invisibly: the claim returns true,
+// the native UIScrollView never learns of it, and every later move arrives as `topScroll`
+function handOverNativeResponder(from, to, blockNativeResponder) {
+    if (isDebug()) {
+        dlog(`setIsJSResponder from=${from === undefined ? 'none' : 'yes'} ` +
+            `to=${to === undefined ? 'none' : 'yes'} block=${blockNativeResponder}`);
+    }
+    if (from !== undefined)
+        setIsJSResponder(from, false, blockNativeResponder);
+    if (to !== undefined)
+        setIsJSResponder(to, true, blockNativeResponder);
+}
+/** Release the responder to native, on a final touch end or a terminate. */
+export function releaseResponderToNative(node) {
+    handOverNativeResponder(node, undefined, false);
+}
+// The slice of the target's ancestry the negotiation may ask, plus the node it must not ask
+// ONE WALK, and the common case never needs a second: while a finger stays inside the view that
+// claimed it, the responder IS an ancestor of the target, so the scope RN computes as a lowest
+// common ancestor is already in the target's own path and an index lookup answers it
+function scopeFor(target) {
+    const targetPath = pathToRoot(target);
+    if (currentResponder === undefined)
+        return { path: targetPath, skip: undefined };
+    const heldAt = targetPath.indexOf(currentResponder);
+    if (heldAt >= 0)
+        return { path: targetPath.slice(heldAt), skip: currentResponder };
+    // The finger left the responder's subtree, a rare frame rather than every frame
+    const from = lowestCommonAncestor(currentResponder, target);
+    return { path: from === undefined ? [] : pathToRoot(from), skip: undefined };
+}
+function grantTo(wants, nativeEvent) {
+    currentResponder = wants;
+    if (isDebug())
+        dlog(`responder granted to ${wants.component}`);
+    const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
+    handOverNativeResponder(undefined, wants, granted === true);
+}
+// RN's `setResponderAndExtractTransfer` order: grant the TAKER, then terminate the incumbent
+// RN also grants ahead of the termination request purely to read the block-native return. We have
+// no native surface to block, so on the REJECT path that grant is omitted as a visible no-op
+function transferTo(incumbent, wants, nativeEvent) {
+    // A missing termination-request listener means implicit consent (RN's default true), so only an
+    // explicit non-true answer keeps the incumbent
+    const guarded = hasListenerFor(incumbent, RESPONDER_TERMINATION_REQUEST);
+    const allowed = !guarded ||
+        callOwnListener(incumbent, RESPONDER_TERMINATION_REQUEST, nativeEvent) ===
+            true;
+    if (!allowed) {
+        if (isDebug())
+            dlog(`responder takeover of ${incumbent.component} rejected`);
+        callOwnListener(wants, RESPONDER_REJECT, nativeEvent);
+        return;
+    }
+    if (isDebug())
+        dlog(`responder transferred ${incumbent.component} -> ${wants.component}`);
+    const granted = callOwnListener(wants, RESPONDER_GRANT, nativeEvent);
+    callOwnListener(incumbent, RESPONDER_TERMINATE, nativeEvent);
+    currentResponder = wants;
+    handOverNativeResponder(incumbent, wants, granted === true);
+}
+// Negotiate (or re-negotiate) the responder for a touch start or move. With nobody holding it the
+// winner is granted; with an incumbent it is asked to relinquish first
+export function negotiateResponder(target, phase, nativeEvent) {
+    const { path, skip } = scopeFor(target);
+    if (path.length === 0)
+        return;
+    const wants = findWantsResponder(path, phase, nativeEvent, skip);
+    // Every exit is logged: a negotiation that declines is indistinguishable from one that never
+    // ran, and the two have opposite causes
+    if (!wants) {
+        if (isDebug()) {
+            dlog(`responder ${phase}: nobody wants it (path=${path.length}${skip === undefined ? '' : ', one skipped'})`);
+        }
+        return;
+    }
+    if (wants === currentResponder) {
+        if (isDebug())
+            dlog(`responder ${phase}: ${wants.component} already holds it`);
+        return;
+    }
+    if (currentResponder === undefined)
+        grantTo(wants, nativeEvent);
+    else
+        transferTo(currentResponder, wants, nativeEvent);
+}

package/build/expo-native-view.d.ts

@@ -0,0 +1,2 @@
+export declare function expoViewManagerName(moduleName: string): string;
+export declare function tryRegisterNativeView(register: () => unknown): boolean;

package/build/expo-native-view.js

@@ -0,0 +1,19 @@
+// The Fabric name `requireNativeViewManager` registers: the adapter prefix plus the module name,
+// and the app identifier when the host sets one
+export function expoViewManagerName(moduleName) {
+    const appIdentifier = Reflect.get(Reflect.get(globalThis, 'expo') ?? {}, '__expo_app_identifier__');
+    const suffix = typeof appIdentifier === 'string' && appIdentifier !== ''
+        ? `_${appIdentifier}`
+        : '';
+    return `ViewManagerAdapter_${moduleName}${suffix}`;
+}
+// A missing view config must not crash the render, the view just renders nothing
+export function tryRegisterNativeView(register) {
+    try {
+        register();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/imperative.d.ts

@@ -1,5 +1,6 @@
 import type { IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, IMeasureOnSuccess, IRootTag } from './fabric';
 import { type ISymbioteNode } from './node';
+import { type IDomRect } from './tree-host';
 export declare function registerSurfaceCommit(commit: (rootTag: IRootTag) => void, forget: (rootTag: IRootTag) => void): void;
 export declare function flushNativeProps(): void;
 export declare function requestCommitFor(node: ISymbioteNode): void;
@@ -14,6 +15,7 @@ export declare function dispatchViewCommand(node: ISymbioteNode, commandName: st
 export declare function sendAccessibilityEvent(node: ISymbioteNode, eventType: string): void;
 export declare function measure(node: ISymbioteNode, callback: IMeasureOnSuccess): void;
 export declare function measureInWindow(node: ISymbioteNode, callback: IMeasureInWindowOnSuccess): void;
+export declare function getBoundingClientRect(node: ISymbioteNode, includeTransform: boolean): IDomRect | undefined;
 export declare function measureLayout(node: ISymbioteNode, relativeTo: ISymbioteNode, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;
 export declare function setIsJSResponder(node: ISymbioteNode, isResponder: boolean, blockNativeResponder: boolean): void;
 /** The node's CURRENT prop value, as the host holds it. The behaviors' one read. */

package/build/imperative.js

@@ -7,7 +7,7 @@
 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';
+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 can't answer about ops
 // it hasn't been handed.
@@ -136,6 +136,23 @@ export function measureInWindow(node, callback) {
     }
     treeHost()?.measureInWindow(node, callback);
 }
+// Synchronous, unlike the six above, mirroring nativeFabricUIManager's own shape. `undefined`
+// covers "not committed", "host predates this member", and a build without react/renderer/dom
+// (the native call throws there) - all read the same to a caller, like a detached element's rect.
+export function getBoundingClientRect(node, includeTransform) {
+    const record = committedRecordOf(node);
+    if (record === undefined) {
+        dlog('getBoundingClientRect skipped: node not committed');
+        return undefined;
+    }
+    try {
+        return treeHost()?.getBoundingClientRect?.(node, includeTransform);
+    }
+    catch (error) {
+        dlog(`getBoundingClientRect skipped - ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
 // 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 = () => { }) {

package/build/index.d.ts

@@ -13,7 +13,8 @@ export type { ISymbioteNode, ISymbioteEvent, IListener } from './node';
 export { SymbioteSurface, createSurface } from './surface';
 export { setEventDispatcher } from './dispatch';
 export { setColorProcessor, processColor } from './platform-color';
-export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, requestCommitFor, } from './imperative';
+export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, getBoundingClientRect, disposeRoot, requestCommitFor, } from './imperative';
+export type { IDomRect } from './tree-host';
 export { setTreeHost, treeHost, registerBeforeFlush, readCommitProfile, readSurfaceTelemetry, setNativeDebug, takeNativeDebugLog, } from './tree-host';
 export type { ISurfaceTelemetry } from './tree-host';
 export { nativeTreeHost, installNativeTreeHost } from './native-tree-host';
@@ -51,6 +52,7 @@ 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 type { IEventValueSource } from './event-value-source';
 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, IEasing, IEasingFunction, IInterpolationConfig, IExtrapolateType, IAnimation, IEndCallback, IEndResult, ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig, ILoopAnimationConfig, INativeNodeConfig, INativeAnimationConfig, INativeEventMapping, IPlatformConfig, } from './animated';
@@ -102,4 +104,12 @@ export { hideTransition, STATUS_BAR_MANAGER, ANIMATED_HIDE_TRANSITION, STATIC_HI
 export type { IStatusBarProps, IStatusBarStyle, IStatusBarAnimation, IStatusBarImperative, } from './status-bar/shared';
 export { registerHostBehavior, hasHostBehaviors, hostBehaviorFor, clearHostBehaviors, appListenerFor, addDerivedNode, SLOT_DERIVED_ALL, } from './host-behavior';
 export type { IClaimMode, IHostBehavior, IPayloadFold } from './host-behavior';
-export { setBehaviorListener, markPropsDirty } from './node';
+export { setBehaviorListener, markPropsDirty, setNodeDispatch } from './node';
+export { hasListenerFor, listenerFor } from './node';
+export type { IEventDispatch } from './node';
+export { createPermissionApi, resolveInitialPermission, fetchInitialPermission, splitWriteOnlyPermissionOptions, } from './permission-hook-runtime';
+export type { IWriteOnlyPermissionOptions } from './permission-hook-runtime';
+export { expoViewManagerName, tryRegisterNativeView } from './expo-native-view';
+export { createResourceController } from './resource-controller';
+export type { IResourceController } from './resource-controller';
+export type { IPermissionHookBehavior, IPermissionHookMethods, IPermissionHookOptions, IPermissionApi, IPermissionHookResult, } from './permission-hook-runtime';

package/build/index.js

@@ -40,7 +40,7 @@ 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';
-export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, requestCommitFor, } from './imperative.js';
+export { dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, getBoundingClientRect, 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';
@@ -135,4 +135,10 @@ export { registerHostBehavior, hasHostBehaviors, hostBehaviorFor, clearHostBehav
 // 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';
+export { setBehaviorListener, markPropsDirty, setNodeDispatch } from './node.js';
+// The only correct way to ask what would receive an event: a behavior may answer a name through
+// one shared `IEventDispatch` rather than a closure in `node.listeners`
+export { hasListenerFor, listenerFor } from './node.js';
+export { createPermissionApi, resolveInitialPermission, fetchInitialPermission, splitWriteOnlyPermissionOptions, } from './permission-hook-runtime.js';
+export { expoViewManagerName, tryRegisterNativeView } from './expo-native-view.js';
+export { createResourceController } from './resource-controller.js';

package/build/mutation-buffer.d.ts

@@ -20,6 +20,7 @@ export declare const KIND_ANCHOR = 2;
 export type IMutationHandle = {
     slot: number;
     slotBatch: number;
+    createdBatch: number;
 };
 export type IMutationBatch = {
     readonly ops: Int32Array;
@@ -38,6 +39,8 @@ export declare function noteCommitDrained(): void;
 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;
+/** Has the host never heard of this node, т.к. the op that creates it is still in the buffer? */
+export declare function isPendingCreate(handle: IMutationHandle): boolean;
 export declare function recordCreateElement(handle: IMutationHandle, viewName: string, isText: boolean, instanceHandle: unknown): void;
 export declare function recordCreateRawText(handle: IMutationHandle, text: string): void;
 export declare function recordCreateAnchor(handle: IMutationHandle): void;

package/build/mutation-buffer.js

@@ -188,7 +188,7 @@ function slotOf(handle) {
 // OP_COMMIT is excluded deliberately: recording a commit is not a change to the tree, and counting
 // it would make every commit look like it had work.
 let changedSinceCommit = false;
-function push(op, a = 0, b = 0, c = 0, d = 0, e = 0) {
+function push(op, a = 0, b = 0, c = 0) {
     if (op !== OP_COMMIT)
         changedSinceCommit = true;
     if (opCount + OP_STRIDE > ops.length) {
@@ -200,10 +200,16 @@ function push(op, a = 0, b = 0, c = 0, d = 0, e = 0) {
     ops[opCount + 1] = a;
     ops[opCount + 2] = b;
     ops[opCount + 3] = c;
-    ops[opCount + 4] = d;
-    ops[opCount + 5] = e;
+    ops[opCount + 4] = 0;
+    ops[opCount + 5] = 0;
     opCount += OP_STRIDE;
 }
+// `OP_CREATE_ELEMENT` is the only op with a FOURTH operand, and it writes it itself rather than
+// widening `push` for one call site. A rest parameter or an options bag would allocate per op,
+// which is the one thing this buffer exists to avoid
+function pushFourth(value) {
+    ops[opCount - OP_STRIDE + 4] = value;
+}
 // Whether a commit would publish anything. See changedSinceCommit.
 export function hasChangedSinceCommit() {
     return changedSinceCommit;
@@ -235,21 +241,32 @@ let placementPending = new Set();
 export function hasPendingPlacement(handle) {
     return placementPending.has(handle);
 }
+// A field rather than a second Set, т.к. this is read on the create path and a `Set.add` per node
+// would charge the thing it saves. `createdBatch` starts at 0, which no live batch carries
+function noteCreated(handle) {
+    placementPending.add(handle);
+    handle.createdBatch = batchId;
+}
+/** Has the host never heard of this node, т.к. the op that creates it is still in the buffer? */
+export function isPendingCreate(handle) {
+    return handle.createdBatch === batchId;
+}
 export function recordCreateElement(handle, viewName, isText, instanceHandle) {
     instanceHandles.push(instanceHandle);
-    placementPending.add(handle);
-    push(OP_CREATE_ELEMENT, slotOf(handle), intern(viewName), isText ? 1 : 0, instanceHandles.length - 1);
+    noteCreated(handle);
+    push(OP_CREATE_ELEMENT, slotOf(handle), intern(viewName), isText ? 1 : 0);
+    pushFourth(instanceHandles.length - 1);
 }
 export function recordCreateRawText(handle, text) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_RAW_TEXT, slotOf(handle), intern(text));
 }
 export function recordCreateAnchor(handle) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_ANCHOR, slotOf(handle));
 }
 export function recordCreateVoid(handle) {
-    placementPending.add(handle);
+    noteCreated(handle);
     push(OP_CREATE_VOID, slotOf(handle));
 }
 export function recordAppendChild(parent, child) {

package/build/native-engine.d.ts

@@ -31,6 +31,12 @@ export type INativeEngineBindings = {
     measureInWindow: (handle: object, callback: (x: number, y: number, width: number, height: number) => void) => void;
     measureLayout: (handle: object, relativeTo: object, onFail: () => void, onSuccess: (x: number, y: number, width: number, height: number) => void) => void;
     setIsJSResponder: (handle: object, isResponder: boolean, blockNativeResponder: boolean) => void;
+    getBoundingClientRect?: (handle: object, includeTransform: boolean) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | undefined;
     setDebugEnabled?: (enabled: boolean) => void;
     takeDebugLog?: () => readonly string[];
     readSurfaceTelemetry?: (surfaceId: number) => {