@symbiote-native/engine 0.1.0

package/build/pan-responder/index.js

@@ -0,0 +1,353 @@
+// PanResponder: pure JS gesture recognition layered on the View responder event
+// props. It reconciles a stream of touch events into one accumulative gesture and
+// exposes a `panHandlers` object the caller spreads onto a View. There is no new
+// native view and no core change: it only consumes the responder props shared
+// already synthesizes (onStartShouldSetResponder / onResponderGrant /
+// onResponderMove / onResponderRelease / onResponderTerminate / ...), exactly
+// as RN's PanResponder consumes them.
+//
+// Ported from react-native/Libraries/Interaction/PanResponder.js. RN sources its
+// touch geometry from a global ResponderTouchHistoryStore; symbiote's synthetic
+// events instead carry the live touches on `event.nativeEvent.touches` (and the
+// changed ones on `changedTouches`), so the centroid/velocity math here reads
+// those directly while keeping RN's accumulate-deltas-over-time behavior.
+import { dlog } from '../debug';
+const SINGLE_TOUCH_COUNT = 1;
+// onShouldBlockNativeResponder defaults to true (RN: block native by default).
+const DEFAULT_BLOCK_NATIVE_RESPONDER = true;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function toFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+// Pull one touch out of an untyped array element, skipping anything that does not
+// carry numeric pageX/pageY. `timestamp` falls back to 0 when absent so a touch
+// with coordinates but no time still contributes to the centroid.
+function toTouchPoint(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const pageX = toFiniteNumber(raw.pageX);
+    const pageY = toFiniteNumber(raw.pageY);
+    if (pageX === undefined || pageY === undefined)
+        return undefined;
+    return { pageX, pageY, timestamp: toFiniteNumber(raw.timestamp) ?? 0 };
+}
+// All current touches on screen, read off event.nativeEvent.touches.
+function readTouches(event) {
+    const raw = event.nativeEvent.touches;
+    if (!Array.isArray(raw))
+        return [];
+    const points = [];
+    for (const entry of raw) {
+        const point = toTouchPoint(entry);
+        if (point !== undefined)
+            points.push(point);
+    }
+    return points;
+}
+// Mean of a coordinate across the active touches, the gesture centroid. RN's
+// TouchHistoryMath does the same averaging over active touches.
+function centroidX(touches) {
+    if (touches.length === 0)
+        return 0;
+    let sum = 0;
+    for (const touch of touches)
+        sum += touch.pageX;
+    return sum / touches.length;
+}
+function centroidY(touches) {
+    if (touches.length === 0)
+        return 0;
+    let sum = 0;
+    for (const touch of touches)
+        sum += touch.pageY;
+    return sum / touches.length;
+}
+// The most recent touch timestamp in the current frame, the clock PanResponder
+// advances `_accountsForMovesUpTo` to and divides the velocity by.
+function mostRecentTimestamp(touches) {
+    let latest = 0;
+    for (const touch of touches) {
+        if (touch.timestamp > latest)
+            latest = touch.timestamp;
+    }
+    return latest;
+}
+// #region touchHistory (RN-faithful multitouch geometry)
+// shared attaches a touch-history bank onto nativeEvent (matching RN's
+// ResponderEventPlugin). When present, the gesture math runs through RN's
+// TouchHistoryMath instead of the all-touch centroid, so dx/vx counts only the touches
+// that moved this frame, via each touch's own previous->current delta. Headless callers
+// that invoke the handlers directly (no shared, no store) carry no touchHistory and fall
+// back to the centroid path below, which keeps single-touch behavior.
+function isTouchRecord(value) {
+    return (isRecord(value) &&
+        typeof value.touchActive === 'boolean' &&
+        typeof value.currentPageX === 'number' &&
+        typeof value.currentPageY === 'number' &&
+        typeof value.currentTimeStamp === 'number' &&
+        typeof value.previousPageX === 'number' &&
+        typeof value.previousPageY === 'number');
+}
+function isTouchHistory(value) {
+    return (isRecord(value) &&
+        Array.isArray(value.touchBank) &&
+        typeof value.numberActiveTouches === 'number' &&
+        typeof value.indexOfSingleActiveTouch === 'number' &&
+        typeof value.mostRecentTimeStamp === 'number');
+}
+function touchHistoryOf(event) {
+    const raw = event.nativeEvent.touchHistory;
+    return isTouchHistory(raw) ? raw : undefined;
+}
+// Ported from RN Interaction/TouchHistoryMath.js:centroidDimension (lines 30-85). Mean
+// of one coordinate over the touches that moved after `touchesChangedAfter`, taking each
+// touch's current or previous position. The single-active-touch fast path uses a strict
+// `>`; the multi-touch scan uses `>=`, both kept from RN.
+function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+    const { touchBank } = touchHistory;
+    let total = 0;
+    let count = 0;
+    const single = touchHistory.numberActiveTouches === SINGLE_TOUCH_COUNT
+        ? touchBank[touchHistory.indexOfSingleActiveTouch]
+        : undefined;
+    if (isTouchRecord(single)) {
+        if (single.touchActive && single.currentTimeStamp > touchesChangedAfter) {
+            total += dimensionOf(single, isXAxis, ofCurrent);
+            count = 1;
+        }
+    }
+    else {
+        for (const record of touchBank) {
+            if (isTouchRecord(record) &&
+                record.touchActive &&
+                record.currentTimeStamp >= touchesChangedAfter) {
+                total += dimensionOf(record, isXAxis, ofCurrent);
+                count++;
+            }
+        }
+    }
+    return count > 0 ? total / count : NO_CENTROID;
+}
+const NO_CENTROID = -1;
+function dimensionOf(record, isXAxis, ofCurrent) {
+    if (ofCurrent)
+        return isXAxis ? record.currentPageX : record.currentPageY;
+    return isXAxis ? record.previousPageX : record.previousPageY;
+}
+function currentCentroidXOfChanged(touchHistory, after) {
+    return centroidDimension(touchHistory, after, true, true);
+}
+function currentCentroidYOfChanged(touchHistory, after) {
+    return centroidDimension(touchHistory, after, false, true);
+}
+function previousCentroidXOfChanged(touchHistory, after) {
+    return centroidDimension(touchHistory, after, true, false);
+}
+function previousCentroidYOfChanged(touchHistory, after) {
+    return centroidDimension(touchHistory, after, false, false);
+}
+function currentCentroidXAll(touchHistory) {
+    return centroidDimension(touchHistory, 0, true, true);
+}
+function currentCentroidYAll(touchHistory) {
+    return centroidDimension(touchHistory, 0, false, true);
+}
+// RN PanResponder._updateGestureStateOnMove (Interaction/PanResponder.js lines 330-366):
+// accumulate the centroid change of touches that moved after `_accountsForMovesUpTo`,
+// rather than tracking the absolute centroid of all touches. This is what makes a
+// stopped finger in a multi-finger drag stop contributing to dx.
+function updateGestureStateFromHistory(gestureState, touchHistory) {
+    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+    const movedAfter = gestureState._accountsForMovesUpTo;
+    gestureState.moveX = currentCentroidXOfChanged(touchHistory, movedAfter);
+    gestureState.moveY = currentCentroidYOfChanged(touchHistory, movedAfter);
+    const prevX = previousCentroidXOfChanged(touchHistory, movedAfter);
+    const x = currentCentroidXOfChanged(touchHistory, movedAfter);
+    const prevY = previousCentroidYOfChanged(touchHistory, movedAfter);
+    const y = currentCentroidYOfChanged(touchHistory, movedAfter);
+    const nextDx = gestureState.dx + (x - prevX);
+    const nextDy = gestureState.dy + (y - prevY);
+    const dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+    if (dt > 0) {
+        gestureState.vx = (nextDx - gestureState.dx) / dt;
+        gestureState.vy = (nextDy - gestureState.dy) / dt;
+    }
+    else {
+        gestureState.vx = 0;
+        gestureState.vy = 0;
+    }
+    gestureState.dx = nextDx;
+    gestureState.dy = nextDy;
+    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+}
+// #endregion
+function initializeGestureState(gestureState) {
+    gestureState.moveX = 0;
+    gestureState.moveY = 0;
+    gestureState.x0 = 0;
+    gestureState.y0 = 0;
+    gestureState.dx = 0;
+    gestureState.dy = 0;
+    gestureState.vx = 0;
+    gestureState.vy = 0;
+    gestureState.numberActiveTouches = 0;
+    gestureState._accountsForMovesUpTo = 0;
+}
+// The timestamp this frame advances to: the touch-history clock when shared attached a
+// store, else the most recent of the live touches (headless direct-call path).
+function frameTimestampOf(event, touches) {
+    return touchHistoryOf(event)?.mostRecentTimeStamp ?? mostRecentTimestamp(touches);
+}
+// Advance the gesture for a move frame. With a touch-history store (the device / shared
+// path) this defers to RN's accumulate-per-moved-touch math; without one it falls back to
+// the all-touch centroid delta, correct for the single dragging finger the headless
+// pan-responder smoke exercises. Guards dt === 0 so a zero-gap frame reports zero
+// velocity instead of NaN.
+function updateGestureStateOnMove(gestureState, event, touches) {
+    const touchHistory = touchHistoryOf(event);
+    if (touchHistory !== undefined) {
+        updateGestureStateFromHistory(gestureState, touchHistory);
+        return;
+    }
+    const currentX = centroidX(touches);
+    const currentY = centroidY(touches);
+    const frameTimestamp = mostRecentTimestamp(touches);
+    gestureState.numberActiveTouches = touches.length;
+    gestureState.moveX = currentX;
+    gestureState.moveY = currentY;
+    const nextDx = currentX - gestureState.x0;
+    const nextDy = currentY - gestureState.y0;
+    const dt = frameTimestamp - gestureState._accountsForMovesUpTo;
+    if (dt > 0) {
+        gestureState.vx = (nextDx - gestureState.dx) / dt;
+        gestureState.vy = (nextDy - gestureState.dy) / dt;
+    }
+    else {
+        gestureState.vx = 0;
+        gestureState.vy = 0;
+    }
+    gestureState.dx = nextDx;
+    gestureState.dy = nextDy;
+    gestureState._accountsForMovesUpTo = frameTimestamp;
+}
+const PanResponder = {
+    create(config) {
+        const gestureState = {
+            // Random per-gesture id, matching RN. Useful only for debugging.
+            stateID: Math.random(),
+            moveX: 0,
+            moveY: 0,
+            x0: 0,
+            y0: 0,
+            dx: 0,
+            dy: 0,
+            vx: 0,
+            vy: 0,
+            numberActiveTouches: 0,
+            _accountsForMovesUpTo: 0,
+        };
+        const panHandlers = {
+            onStartShouldSetResponder(event) {
+                return config.onStartShouldSetPanResponder === undefined
+                    ? false
+                    : config.onStartShouldSetPanResponder(event, gestureState);
+            },
+            onMoveShouldSetResponder(event) {
+                return config.onMoveShouldSetPanResponder === undefined
+                    ? false
+                    : config.onMoveShouldSetPanResponder(event, gestureState);
+            },
+            onStartShouldSetResponderCapture(event) {
+                // A fresh single touch begins a new gesture, so reset the accumulator
+                // before any should-set callback inspects it (RN does the same).
+                const touches = readTouches(event);
+                if (touches.length === SINGLE_TOUCH_COUNT) {
+                    initializeGestureState(gestureState);
+                }
+                gestureState.numberActiveTouches =
+                    touchHistoryOf(event)?.numberActiveTouches ?? touches.length;
+                return config.onStartShouldSetPanResponderCapture === undefined
+                    ? false
+                    : config.onStartShouldSetPanResponderCapture(event, gestureState);
+            },
+            onMoveShouldSetResponderCapture(event) {
+                const touches = readTouches(event);
+                // Skip a duplicate dispatch of the same frame: when two touches change at
+                // once the responder system fires twice, but the geometry was already
+                // folded in on the first call.
+                if (gestureState._accountsForMovesUpTo === frameTimestampOf(event, touches)) {
+                    return false;
+                }
+                updateGestureStateOnMove(gestureState, event, touches);
+                return config.onMoveShouldSetPanResponderCapture === undefined
+                    ? false
+                    : config.onMoveShouldSetPanResponderCapture(event, gestureState);
+            },
+            onResponderGrant(event) {
+                dlog('PanResponder grant');
+                const touches = readTouches(event);
+                const touchHistory = touchHistoryOf(event);
+                // x0/y0 is the non-cumulative centroid at grant time (RN: currentCentroid).
+                gestureState.x0 = touchHistory ? currentCentroidXAll(touchHistory) : centroidX(touches);
+                gestureState.y0 = touchHistory ? currentCentroidYAll(touchHistory) : centroidY(touches);
+                gestureState.dx = 0;
+                gestureState.dy = 0;
+                // The grant frame is already accounted for, so the first move's velocity
+                // is measured from here, not from time 0.
+                gestureState._accountsForMovesUpTo = frameTimestampOf(event, touches);
+                gestureState.numberActiveTouches = touchHistory?.numberActiveTouches ?? touches.length;
+                config.onPanResponderGrant?.(event, gestureState);
+                return config.onShouldBlockNativeResponder === undefined
+                    ? DEFAULT_BLOCK_NATIVE_RESPONDER
+                    : config.onShouldBlockNativeResponder(event, gestureState);
+            },
+            onResponderReject(event) {
+                config.onPanResponderReject?.(event, gestureState);
+            },
+            onResponderStart(event) {
+                gestureState.numberActiveTouches =
+                    touchHistoryOf(event)?.numberActiveTouches ?? readTouches(event).length;
+                config.onPanResponderStart?.(event, gestureState);
+            },
+            onResponderMove(event) {
+                const touches = readTouches(event);
+                // Same duplicate-frame guard as the capture path.
+                if (gestureState._accountsForMovesUpTo === frameTimestampOf(event, touches)) {
+                    return;
+                }
+                updateGestureStateOnMove(gestureState, event, touches);
+                config.onPanResponderMove?.(event, gestureState);
+            },
+            onResponderEnd(event) {
+                gestureState.numberActiveTouches =
+                    touchHistoryOf(event)?.numberActiveTouches ?? readTouches(event).length;
+                config.onPanResponderEnd?.(event, gestureState);
+            },
+            onResponderRelease(event) {
+                dlog('PanResponder release');
+                config.onPanResponderRelease?.(event, gestureState);
+                initializeGestureState(gestureState);
+            },
+            onResponderTerminate(event) {
+                dlog('PanResponder terminate');
+                config.onPanResponderTerminate?.(event, gestureState);
+                initializeGestureState(gestureState);
+            },
+            onResponderTerminationRequest(event) {
+                return config.onPanResponderTerminationRequest === undefined
+                    ? true
+                    : config.onPanResponderTerminationRequest(event, gestureState);
+            },
+        };
+        return {
+            panHandlers,
+            // Deprecated in RN; kept for shape parity. No InteractionManager handle.
+            getInteractionHandle() {
+                return null;
+            },
+        };
+    },
+};
+export default PanResponder;

package/build/permissions-android/index.d.ts

@@ -0,0 +1,115 @@
+export declare const RESULTS: Readonly<{
+    readonly GRANTED: "granted";
+    readonly DENIED: "denied";
+    readonly NEVER_ASK_AGAIN: "never_ask_again";
+}>;
+export type IPermissionStatus = (typeof RESULTS)[keyof typeof RESULTS];
+export declare const PERMISSIONS: Readonly<{
+    readonly READ_CALENDAR: "android.permission.READ_CALENDAR";
+    readonly WRITE_CALENDAR: "android.permission.WRITE_CALENDAR";
+    readonly CAMERA: "android.permission.CAMERA";
+    readonly READ_CONTACTS: "android.permission.READ_CONTACTS";
+    readonly WRITE_CONTACTS: "android.permission.WRITE_CONTACTS";
+    readonly GET_ACCOUNTS: "android.permission.GET_ACCOUNTS";
+    readonly ACCESS_FINE_LOCATION: "android.permission.ACCESS_FINE_LOCATION";
+    readonly ACCESS_COARSE_LOCATION: "android.permission.ACCESS_COARSE_LOCATION";
+    readonly ACCESS_BACKGROUND_LOCATION: "android.permission.ACCESS_BACKGROUND_LOCATION";
+    readonly RECORD_AUDIO: "android.permission.RECORD_AUDIO";
+    readonly READ_PHONE_STATE: "android.permission.READ_PHONE_STATE";
+    readonly CALL_PHONE: "android.permission.CALL_PHONE";
+    readonly READ_CALL_LOG: "android.permission.READ_CALL_LOG";
+    readonly WRITE_CALL_LOG: "android.permission.WRITE_CALL_LOG";
+    readonly ADD_VOICEMAIL: "com.android.voicemail.permission.ADD_VOICEMAIL";
+    readonly READ_VOICEMAIL: "com.android.voicemail.permission.READ_VOICEMAIL";
+    readonly WRITE_VOICEMAIL: "com.android.voicemail.permission.WRITE_VOICEMAIL";
+    readonly USE_SIP: "android.permission.USE_SIP";
+    readonly PROCESS_OUTGOING_CALLS: "android.permission.PROCESS_OUTGOING_CALLS";
+    readonly BODY_SENSORS: "android.permission.BODY_SENSORS";
+    readonly BODY_SENSORS_BACKGROUND: "android.permission.BODY_SENSORS_BACKGROUND";
+    readonly SEND_SMS: "android.permission.SEND_SMS";
+    readonly RECEIVE_SMS: "android.permission.RECEIVE_SMS";
+    readonly READ_SMS: "android.permission.READ_SMS";
+    readonly RECEIVE_WAP_PUSH: "android.permission.RECEIVE_WAP_PUSH";
+    readonly RECEIVE_MMS: "android.permission.RECEIVE_MMS";
+    readonly READ_EXTERNAL_STORAGE: "android.permission.READ_EXTERNAL_STORAGE";
+    readonly READ_MEDIA_IMAGES: "android.permission.READ_MEDIA_IMAGES";
+    readonly READ_MEDIA_VIDEO: "android.permission.READ_MEDIA_VIDEO";
+    readonly READ_MEDIA_AUDIO: "android.permission.READ_MEDIA_AUDIO";
+    readonly READ_MEDIA_VISUAL_USER_SELECTED: "android.permission.READ_MEDIA_VISUAL_USER_SELECTED";
+    readonly WRITE_EXTERNAL_STORAGE: "android.permission.WRITE_EXTERNAL_STORAGE";
+    readonly BLUETOOTH_CONNECT: "android.permission.BLUETOOTH_CONNECT";
+    readonly BLUETOOTH_SCAN: "android.permission.BLUETOOTH_SCAN";
+    readonly BLUETOOTH_ADVERTISE: "android.permission.BLUETOOTH_ADVERTISE";
+    readonly ACCESS_MEDIA_LOCATION: "android.permission.ACCESS_MEDIA_LOCATION";
+    readonly ACCEPT_HANDOVER: "android.permission.ACCEPT_HANDOVER";
+    readonly ACTIVITY_RECOGNITION: "android.permission.ACTIVITY_RECOGNITION";
+    readonly ANSWER_PHONE_CALLS: "android.permission.ANSWER_PHONE_CALLS";
+    readonly READ_PHONE_NUMBERS: "android.permission.READ_PHONE_NUMBERS";
+    readonly UWB_RANGING: "android.permission.UWB_RANGING";
+    readonly POST_NOTIFICATIONS: "android.permission.POST_NOTIFICATIONS";
+    readonly NEARBY_WIFI_DEVICES: "android.permission.NEARBY_WIFI_DEVICES";
+}>;
+export type IPermission = (typeof PERMISSIONS)[keyof typeof PERMISSIONS];
+export type IRationale = {
+    title: string;
+    message: string;
+    buttonPositive?: string;
+    buttonNegative?: string;
+    buttonNeutral?: string;
+};
+export declare const PermissionsAndroid: {
+    PERMISSIONS: Readonly<{
+        readonly READ_CALENDAR: "android.permission.READ_CALENDAR";
+        readonly WRITE_CALENDAR: "android.permission.WRITE_CALENDAR";
+        readonly CAMERA: "android.permission.CAMERA";
+        readonly READ_CONTACTS: "android.permission.READ_CONTACTS";
+        readonly WRITE_CONTACTS: "android.permission.WRITE_CONTACTS";
+        readonly GET_ACCOUNTS: "android.permission.GET_ACCOUNTS";
+        readonly ACCESS_FINE_LOCATION: "android.permission.ACCESS_FINE_LOCATION";
+        readonly ACCESS_COARSE_LOCATION: "android.permission.ACCESS_COARSE_LOCATION";
+        readonly ACCESS_BACKGROUND_LOCATION: "android.permission.ACCESS_BACKGROUND_LOCATION";
+        readonly RECORD_AUDIO: "android.permission.RECORD_AUDIO";
+        readonly READ_PHONE_STATE: "android.permission.READ_PHONE_STATE";
+        readonly CALL_PHONE: "android.permission.CALL_PHONE";
+        readonly READ_CALL_LOG: "android.permission.READ_CALL_LOG";
+        readonly WRITE_CALL_LOG: "android.permission.WRITE_CALL_LOG";
+        readonly ADD_VOICEMAIL: "com.android.voicemail.permission.ADD_VOICEMAIL";
+        readonly READ_VOICEMAIL: "com.android.voicemail.permission.READ_VOICEMAIL";
+        readonly WRITE_VOICEMAIL: "com.android.voicemail.permission.WRITE_VOICEMAIL";
+        readonly USE_SIP: "android.permission.USE_SIP";
+        readonly PROCESS_OUTGOING_CALLS: "android.permission.PROCESS_OUTGOING_CALLS";
+        readonly BODY_SENSORS: "android.permission.BODY_SENSORS";
+        readonly BODY_SENSORS_BACKGROUND: "android.permission.BODY_SENSORS_BACKGROUND";
+        readonly SEND_SMS: "android.permission.SEND_SMS";
+        readonly RECEIVE_SMS: "android.permission.RECEIVE_SMS";
+        readonly READ_SMS: "android.permission.READ_SMS";
+        readonly RECEIVE_WAP_PUSH: "android.permission.RECEIVE_WAP_PUSH";
+        readonly RECEIVE_MMS: "android.permission.RECEIVE_MMS";
+        readonly READ_EXTERNAL_STORAGE: "android.permission.READ_EXTERNAL_STORAGE";
+        readonly READ_MEDIA_IMAGES: "android.permission.READ_MEDIA_IMAGES";
+        readonly READ_MEDIA_VIDEO: "android.permission.READ_MEDIA_VIDEO";
+        readonly READ_MEDIA_AUDIO: "android.permission.READ_MEDIA_AUDIO";
+        readonly READ_MEDIA_VISUAL_USER_SELECTED: "android.permission.READ_MEDIA_VISUAL_USER_SELECTED";
+        readonly WRITE_EXTERNAL_STORAGE: "android.permission.WRITE_EXTERNAL_STORAGE";
+        readonly BLUETOOTH_CONNECT: "android.permission.BLUETOOTH_CONNECT";
+        readonly BLUETOOTH_SCAN: "android.permission.BLUETOOTH_SCAN";
+        readonly BLUETOOTH_ADVERTISE: "android.permission.BLUETOOTH_ADVERTISE";
+        readonly ACCESS_MEDIA_LOCATION: "android.permission.ACCESS_MEDIA_LOCATION";
+        readonly ACCEPT_HANDOVER: "android.permission.ACCEPT_HANDOVER";
+        readonly ACTIVITY_RECOGNITION: "android.permission.ACTIVITY_RECOGNITION";
+        readonly ANSWER_PHONE_CALLS: "android.permission.ANSWER_PHONE_CALLS";
+        readonly READ_PHONE_NUMBERS: "android.permission.READ_PHONE_NUMBERS";
+        readonly UWB_RANGING: "android.permission.UWB_RANGING";
+        readonly POST_NOTIFICATIONS: "android.permission.POST_NOTIFICATIONS";
+        readonly NEARBY_WIFI_DEVICES: "android.permission.NEARBY_WIFI_DEVICES";
+    }>;
+    RESULTS: Readonly<{
+        readonly GRANTED: "granted";
+        readonly DENIED: "denied";
+        readonly NEVER_ASK_AGAIN: "never_ask_again";
+    }>;
+    check(permission: IPermission): Promise<boolean>;
+    request(permission: IPermission, rationale?: IRationale): Promise<IPermissionStatus>;
+    requestMultiple(permissions: IPermission[]): Promise<Record<string, IPermissionStatus>>;
+    shouldShowRequestPermissionRationale(permission: IPermission): Promise<boolean>;
+};

package/build/permissions-android/index.js

@@ -0,0 +1,185 @@
+// PermissionsAndroid module: JS wrapper over Android's runtime-permissions
+// model. Mirrors RN's Libraries/PermissionsAndroid/PermissionsAndroid.js,
+// exposing the modern API: check / request / requestMultiple /
+// shouldShowRequestPermissionRationale, plus the frozen PERMISSIONS and RESULTS
+// constant maps. Imperative JS->native calls with no Fabric view of their own,
+// like Vibration / Keyboard.
+//
+// symbiote is iOS-first and this module is Android-only, so it MUST degrade
+// gracefully when the native module is absent (on iOS, or headless). RN throws
+// "works only for Android"; we instead resolve a safe default + dlog so a
+// cross-platform smoke never hard-crashes the process. Never reject/throw
+// synchronously on a missing module.
+//
+// The native contract is confirmed from RN's TurboModule spec at
+// specs_DEPRECATED/modules/INativePermissionsAndroid.js (`'PermissionsAndroid'`):
+//   checkPermission(permission): Promise<boolean>
+//   requestPermission(permission): Promise<string>
+//   shouldShowRequestPermissionRationale(permission): Promise<boolean>
+//   requestMultiplePermissions(permissions): Promise<{[permission]: string}>
+import { getNativeModule } from '../native-modules';
+import { dlog } from '../debug';
+// The native module name RN registers this TurboModule under
+// (`TurboModuleRegistry.get<Spec>('PermissionsAndroid')`). NOTE: per the
+// symbiote invariant, a module name is only provable on a real host (a headless
+// fake answers to any name); this name is device-verify-pending. See
+// .docs/native-module-platform-routing.md.
+const PERMISSIONS_ANDROID_MODULE = 'PermissionsAndroid';
+// The runtime-permission result strings Android can return. Modeled as a frozen
+// `as const` map: the generated-style constant-map exception to "no magic
+// strings".
+export const RESULTS = Object.freeze({
+    GRANTED: 'granted',
+    DENIED: 'denied',
+    NEVER_ASK_AGAIN: 'never_ask_again',
+});
+// The full Android permission-string map, copied verbatim from RN's source.
+// Frozen `as const` constant map (the same string-map exception as RESULTS).
+export const PERMISSIONS = Object.freeze({
+    READ_CALENDAR: 'android.permission.READ_CALENDAR',
+    WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR',
+    CAMERA: 'android.permission.CAMERA',
+    READ_CONTACTS: 'android.permission.READ_CONTACTS',
+    WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS',
+    GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS',
+    ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION',
+    ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION',
+    ACCESS_BACKGROUND_LOCATION: 'android.permission.ACCESS_BACKGROUND_LOCATION',
+    RECORD_AUDIO: 'android.permission.RECORD_AUDIO',
+    READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE',
+    CALL_PHONE: 'android.permission.CALL_PHONE',
+    READ_CALL_LOG: 'android.permission.READ_CALL_LOG',
+    WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG',
+    ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL',
+    READ_VOICEMAIL: 'com.android.voicemail.permission.READ_VOICEMAIL',
+    WRITE_VOICEMAIL: 'com.android.voicemail.permission.WRITE_VOICEMAIL',
+    USE_SIP: 'android.permission.USE_SIP',
+    PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS',
+    BODY_SENSORS: 'android.permission.BODY_SENSORS',
+    BODY_SENSORS_BACKGROUND: 'android.permission.BODY_SENSORS_BACKGROUND',
+    SEND_SMS: 'android.permission.SEND_SMS',
+    RECEIVE_SMS: 'android.permission.RECEIVE_SMS',
+    READ_SMS: 'android.permission.READ_SMS',
+    RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH',
+    RECEIVE_MMS: 'android.permission.RECEIVE_MMS',
+    READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE',
+    READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES',
+    READ_MEDIA_VIDEO: 'android.permission.READ_MEDIA_VIDEO',
+    READ_MEDIA_AUDIO: 'android.permission.READ_MEDIA_AUDIO',
+    READ_MEDIA_VISUAL_USER_SELECTED: 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED',
+    WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE',
+    BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT',
+    BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN',
+    BLUETOOTH_ADVERTISE: 'android.permission.BLUETOOTH_ADVERTISE',
+    ACCESS_MEDIA_LOCATION: 'android.permission.ACCESS_MEDIA_LOCATION',
+    ACCEPT_HANDOVER: 'android.permission.ACCEPT_HANDOVER',
+    ACTIVITY_RECOGNITION: 'android.permission.ACTIVITY_RECOGNITION',
+    ANSWER_PHONE_CALLS: 'android.permission.ANSWER_PHONE_CALLS',
+    READ_PHONE_NUMBERS: 'android.permission.READ_PHONE_NUMBERS',
+    UWB_RANGING: 'android.permission.UWB_RANGING',
+    POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS',
+    NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES',
+});
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+// Narrow the native string result into a known RESULTS value. Any unrecognized
+// string is passed through as a IPermissionStatus only when it matches; otherwise
+// we fall back to DENIED: a runtime guard at the trust boundary, not an `as`.
+function toPermissionStatus(value) {
+    if (value === RESULTS.GRANTED || value === RESULTS.DENIED || value === RESULTS.NEVER_ASK_AGAIN) {
+        return value;
+    }
+    return RESULTS.DENIED;
+}
+// Narrow the native requestMultiplePermissions() return into a per-permission
+// status map. Each value is run through toPermissionStatus; non-object returns
+// yield an empty map.
+function toStatusMap(value) {
+    const result = {};
+    if (typeof value !== 'object' || value === null)
+        return result;
+    for (const key of Object.keys(value)) {
+        result[key] = toPermissionStatus(Reflect.get(value, key));
+    }
+    return result;
+}
+// Resolved FRESH on every call, deliberately NOT memoized at module load. The original
+// self-contained module resolved once at import, but moving it into the engine made it a
+// shared singleton; a cached null would survive a module being linked later (or the headless
+// smoke flipping a fake module on after its first import). getNativeModule is a cheap proxy
+// lookup, so per-call resolution costs nothing and stays correct. Returns null on iOS / headless.
+function getModule() {
+    const module = getNativeModule(PERMISSIONS_ANDROID_MODULE);
+    dlog(`PermissionsAndroid: module ${module ? 'resolved' : 'NOT resolved (null)'}`);
+    return module;
+}
+export const PermissionsAndroid = {
+    PERMISSIONS,
+    RESULTS,
+    // Resolve whether a permission has already been granted. Without a native
+    // module (iOS / headless) resolve false. Never throw.
+    async check(permission) {
+        const permissionsModule = getModule();
+        if (permissionsModule === null) {
+            dlog('PermissionsAndroid.check -> module unavailable, resolving false');
+            return false;
+        }
+        dlog(`PermissionsAndroid.check -> ${permission}`);
+        const granted = await permissionsModule.checkPermission(permission);
+        return isBoolean(granted) ? granted : false;
+    },
+    // Prompt the user for a permission, resolving a RESULTS status. If a rationale
+    // is supplied and DialogManagerAndroid is present, show it first; otherwise
+    // proceed straight to the native request (dlog the skip). Without the
+    // PermissionsAndroid module resolve RESULTS.DENIED. Never throw.
+    async request(permission, rationale) {
+        const permissionsModule = getModule();
+        if (permissionsModule === null) {
+            dlog('PermissionsAndroid.request -> module unavailable, resolving DENIED');
+            return RESULTS.DENIED;
+        }
+        dlog(`PermissionsAndroid.request -> ${permission}`);
+        if (rationale !== undefined) {
+            const shouldShow = await permissionsModule.shouldShowRequestPermissionRationale(permission);
+            const dialogModule = getNativeModule('DialogManagerAndroid');
+            if (isBoolean(shouldShow) && shouldShow && dialogModule !== null) {
+                return new Promise((resolve, reject) => {
+                    dialogModule.showAlert(rationale, () => reject(new Error('Error showing rationale')), () => {
+                        permissionsModule
+                            .requestPermission(permission)
+                            .then(status => resolve(toPermissionStatus(status)))
+                            .catch(reject);
+                    });
+                });
+            }
+            dlog('PermissionsAndroid.request -> rationale skipped (DialogManagerAndroid unavailable)');
+        }
+        const status = await permissionsModule.requestPermission(permission);
+        return toPermissionStatus(status);
+    },
+    // Prompt for several permissions at once, resolving a per-permission status
+    // map. Without a native module resolve an empty map. Never throw.
+    async requestMultiple(permissions) {
+        const permissionsModule = getModule();
+        if (permissionsModule === null) {
+            dlog('PermissionsAndroid.requestMultiple -> module unavailable, resolving {}');
+            return {};
+        }
+        dlog(`PermissionsAndroid.requestMultiple -> ${permissions.join(', ')}`);
+        const statuses = await permissionsModule.requestMultiplePermissions(permissions);
+        return toStatusMap(statuses);
+    },
+    // Whether the OS recommends showing a rationale before re-requesting. Without
+    // a native module resolve false. Never throw.
+    async shouldShowRequestPermissionRationale(permission) {
+        const permissionsModule = getModule();
+        if (permissionsModule === null) {
+            dlog('PermissionsAndroid.shouldShowRequestPermissionRationale -> module unavailable, resolving false');
+            return false;
+        }
+        dlog(`PermissionsAndroid.shouldShowRequestPermissionRationale -> ${permission}`);
+        const shouldShow = await permissionsModule.shouldShowRequestPermissionRationale(permission);
+        return isBoolean(shouldShow) ? shouldShow : false;
+    },
+};

package/build/pixel-ratio/index.d.ts

@@ -0,0 +1,8 @@
+export interface IPixelRatioStatic {
+    get(): number;
+    getFontScale(): number;
+    getPixelSizeForLayoutSize(layoutSize: number): number;
+    roundToNearestPixel(layoutSize: number): number;
+    startDetecting(): void;
+}
+export declare const PixelRatio: IPixelRatioStatic;