@pose-tracker/react-native-pose-estimation-light 0.1.0

package/lib/quality/profiles.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Camera / preprocess quality tiers for the WebView MoveNet runtime.
+ *
+ * Inspired by Sency's PoseModelChoice ladder (Prime → … → Basic), adapted to
+ * our stack: MoveNet Lightning always runs at 192×192; what changes is the
+ * **camera capture resolution**.
+ *
+ * FPS policy uses a **minimum target** (floor), not a single setpoint:
+ *   - iOS: min 30 — acceptable/ideal band roughly 30–50+ FPS
+ *   - Android: min from {@link ANDROID_MIN_TARGET_FPS} (experiment default 10)
+ *
+ * Warm-up benches estimate execute cost; AdaptiveChoice picks a capture
+ * profile before getUserMedia when the estimate is below the platform floor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUALITY_PROFILES = exports.QUALITY_SETTLE_MS = exports.LOW_FPS_STREAK_BEFORE_DOWNGRADE = exports.CRITICAL_FPS_THRESHOLD = exports.TARGET_MEDIAN_MS = exports.TARGET_FPS = exports.IDEAL_FPS_RANGE_ANDROID = exports.IDEAL_FPS_RANGE_IOS = exports.MIN_TARGET_FPS_DEFAULT = exports.MIN_TARGET_FPS_IOS = exports.MIN_TARGET_FPS_ANDROID = exports.QUALITY_LADDER = void 0;
+exports.getCriticalFpsThreshold = getCriticalFpsThreshold;
+exports.currentQualityPlatform = currentQualityPlatform;
+exports.getMinTargetFps = getMinTargetFps;
+exports.getIdealFpsRange = getIdealFpsRange;
+exports.minMedianMsForMinTarget = minMedianMsForMinTarget;
+exports.getQualityProfile = getQualityProfile;
+exports.nextLowerQualityProfile = nextLowerQualityProfile;
+exports.isQualityProfileId = isQualityProfileId;
+exports.qualityLadderIndex = qualityLadderIndex;
+exports.lowerQualityProfile = lowerQualityProfile;
+exports.profileFromWarmupMedianMs = profileFromWarmupMedianMs;
+exports.estimatedFpsFromMedianMs = estimatedFpsFromMedianMs;
+const react_native_1 = require("react-native");
+const captureMode_1 = require("./captureMode");
+/**
+ * Ordered highest → lowest. `nextLowerQualityProfile` walks this ladder.
+ */
+exports.QUALITY_LADDER = [
+    'prime',
+    'pro',
+    'lite',
+    'ultralite',
+    'basic',
+];
+/**
+ * Android minimum acceptable inference FPS (floor).
+ * Sourced from {@link ANDROID_MIN_TARGET_FPS} so the experiment flag is the
+ * single knob (see captureMode.ts).
+ */
+exports.MIN_TARGET_FPS_ANDROID = captureMode_1.ANDROID_MIN_TARGET_FPS;
+/**
+ * iOS minimum acceptable inference FPS (floor).
+ * Acceptable/ideal experience is typically 30–50+ on Apple GPU.
+ */
+exports.MIN_TARGET_FPS_IOS = 30;
+/** Fallback floor for unknown platforms. */
+exports.MIN_TARGET_FPS_DEFAULT = exports.MIN_TARGET_FPS_ANDROID;
+/**
+ * Documented “good experience” bands (not hard caps).
+ * Downgrades / warnings use the **min** only.
+ */
+exports.IDEAL_FPS_RANGE_IOS = { min: exports.MIN_TARGET_FPS_IOS, idealMax: 50 };
+exports.IDEAL_FPS_RANGE_ANDROID = { min: exports.MIN_TARGET_FPS_ANDROID, idealMax: 30 };
+/**
+ * @deprecated Use {@link getMinTargetFps} / {@link MIN_TARGET_FPS_ANDROID}.
+ * Kept as the Android floor so older imports keep a sensible number.
+ */
+exports.TARGET_FPS = exports.MIN_TARGET_FPS_ANDROID;
+/** @deprecated Use {@link minMedianMsForMinTarget}. */
+exports.TARGET_MEDIAN_MS = 1000 / exports.MIN_TARGET_FPS_ANDROID;
+/**
+ * Critical alert when FPS stays well below the platform minimum target
+ * (even on `basic`). Android: <10; iOS: <20.
+ */
+function getCriticalFpsThreshold(platform = currentQualityPlatform()) {
+    if (platform === 'ios')
+        return 20;
+    return 10;
+}
+/** @deprecated Prefer {@link getCriticalFpsThreshold}. */
+exports.CRITICAL_FPS_THRESHOLD = 10;
+/** Consecutive samples below min-target before auto-downgrade. */
+/** Sustained samples below the inference budget before a live downgrade. */
+exports.LOW_FPS_STREAK_BEFORE_DOWNGRADE = 4;
+/**
+ * Ignore live downgrade decisions for this long after ready / a quality swap
+ * (camera restart tanks the first 1 Hz stats samples).
+ */
+exports.QUALITY_SETTLE_MS = 5000;
+exports.QUALITY_PROFILES = {
+    prime: {
+        id: 'prime',
+        label: 'Prime (1280×720 @30)',
+        idealWidth: 1280,
+        idealHeight: 720,
+        idealFrameRate: 30,
+        minStableFps: exports.MIN_TARGET_FPS_ANDROID,
+    },
+    pro: {
+        id: 'pro',
+        label: 'Pro (960×540 @30)',
+        idealWidth: 960,
+        idealHeight: 540,
+        idealFrameRate: 30,
+        minStableFps: exports.MIN_TARGET_FPS_ANDROID,
+    },
+    lite: {
+        id: 'lite',
+        label: 'Lite (640×480 @30)',
+        idealWidth: 640,
+        idealHeight: 480,
+        idealFrameRate: 30,
+        minStableFps: exports.MIN_TARGET_FPS_ANDROID,
+    },
+    ultralite: {
+        id: 'ultralite',
+        label: 'UltraLite (480×360 @24)',
+        idealWidth: 480,
+        idealHeight: 360,
+        idealFrameRate: 24,
+        minStableFps: exports.MIN_TARGET_FPS_ANDROID,
+    },
+    basic: {
+        id: 'basic',
+        label: 'Basic (320×240 @20)',
+        idealWidth: 320,
+        idealHeight: 240,
+        idealFrameRate: 20,
+        minStableFps: exports.MIN_TARGET_FPS_ANDROID,
+    },
+};
+function currentQualityPlatform() {
+    if (react_native_1.Platform.OS === 'ios')
+        return 'ios';
+    if (react_native_1.Platform.OS === 'android')
+        return 'android';
+    return 'other';
+}
+/** Platform minimum target FPS (floor — not a setpoint). */
+function getMinTargetFps(platform = currentQualityPlatform()) {
+    if (platform === 'ios')
+        return exports.MIN_TARGET_FPS_IOS;
+    if (platform === 'android')
+        return captureMode_1.ANDROID_MIN_TARGET_FPS;
+    return exports.MIN_TARGET_FPS_DEFAULT;
+}
+function getIdealFpsRange(platform = currentQualityPlatform()) {
+    if (platform === 'ios')
+        return exports.IDEAL_FPS_RANGE_IOS;
+    if (platform === 'android')
+        return exports.IDEAL_FPS_RANGE_ANDROID;
+    return { min: exports.MIN_TARGET_FPS_DEFAULT, idealMax: 30 };
+}
+/** Max warm-up median ms that still meets a given min-target FPS. */
+function minMedianMsForMinTarget(minTargetFps) {
+    return 1000 / minTargetFps;
+}
+function getQualityProfile(id) {
+    return exports.QUALITY_PROFILES[id];
+}
+function nextLowerQualityProfile(id) {
+    const idx = exports.QUALITY_LADDER.indexOf(id);
+    if (idx < 0 || idx >= exports.QUALITY_LADDER.length - 1)
+        return null;
+    return exports.QUALITY_LADDER[idx + 1];
+}
+function isQualityProfileId(value) {
+    return Object.prototype.hasOwnProperty.call(exports.QUALITY_PROFILES, value);
+}
+function qualityLadderIndex(id) {
+    return exports.QUALITY_LADDER.indexOf(id);
+}
+/** Lower or equal quality (higher index) wins. */
+function lowerQualityProfile(a, b) {
+    return qualityLadderIndex(a) >= qualityLadderIndex(b) ? a : b;
+}
+/**
+ * Map warm-up execute median (zeros, no camera) → max safe capture profile.
+ *
+ * Thresholds scale with the platform **minimum target** FPS. Warm-up ignores
+ * bitmap cost, so anything over the floor budget must stay on `basic` —
+ * the old `≤ 1.3× budget → ultralite` band upgraded Mali devices that were
+ * already below the floor (e.g. 120 ms zeros → ultralite → live ~8 FPS).
+ */
+function profileFromWarmupMedianMs(medianMs, minTargetFps = getMinTargetFps()) {
+    if (medianMs == null || !Number.isFinite(medianMs))
+        return 'basic';
+    const budget = minMedianMsForMinTarget(minTargetFps);
+    // Over the floor on zeros alone → basic only (camera adds more cost).
+    if (medianMs > budget)
+        return 'basic';
+    // At / under the floor with headroom → higher capture ok
+    if (medianMs <= budget * 0.6)
+        return 'prime';
+    if (medianMs <= budget * 0.75)
+        return 'pro';
+    if (medianMs <= budget * 0.9)
+        return 'lite';
+    return 'ultralite';
+}
+function estimatedFpsFromMedianMs(medianMs) {
+    if (medianMs == null || !Number.isFinite(medianMs) || medianMs <= 0)
+        return null;
+    return 1000 / medianMs;
+}

package/lib/runtime/RuntimeCache.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Versioned filesystem cache of a remote pose-runtime payload (legacy
+ * stub-loader helper).
+ *
+ * The light SDK’s default path does **not** use this cache: TF.js loads from
+ * CDN and the model from a URL inside the WebView each boot. This class
+ * remains exported for advanced hosts that still want to download / verify
+ * Strapi `/api/sdk/pose-runtime` parts.
+ *
+ * Guarantees when used:
+ * - sha256 is verified BEFORE a part is committed to the cache.
+ * - `purge()` on revocation signals.
+ */
+import type { PoseRuntimeDescriptor } from '../types/manifest';
+import { type FileStore } from '../engine/EngineLoader';
+/** Decoded, ready-to-inject runtime parts. */
+export interface PoseRuntimeParts {
+    version: string;
+    /** TF.js bundle (core + converter + webgl + wasm backends). */
+    tfjsJs: string;
+    /** XNNPACK wasm binaries (base64). */
+    tfjsWasmB64: {
+        plain: string;
+        simd: string;
+        threadedSimd: string;
+    };
+    /** MoveNet graph model topology (raw model.json). */
+    modelJson: string;
+    /** Weight shards (base64, manifest order). */
+    weightsB64: string[];
+    /** Proprietary pose pipeline wasm (base64), null when not deployed. */
+    pipelineWasmB64: string | null;
+    /** Page runtime (camera, presets, inference loop, events). */
+    runtimeJs: string;
+}
+export interface RuntimeCacheProgress {
+    part: string;
+    completedParts: number;
+    totalParts: number;
+    /** Bytes of the part being downloaded (from the manifest). */
+    partBytes: number;
+}
+export interface RuntimeCacheOptions {
+    fileStore?: FileStore | null;
+    /** Injectable for tests. */
+    fetchFn?: typeof fetch;
+}
+export declare class RuntimeCache {
+    private readonly files;
+    private readonly fetchFn;
+    private memoryParts;
+    /** True when no persistent FS module is installed (memory-only fallback). */
+    readonly persistent: boolean;
+    constructor(options?: RuntimeCacheOptions);
+    /** Version currently committed to the cache, or null when cold/empty. */
+    getCachedVersion(): Promise<string | null>;
+    /**
+     * Ensure the cache holds the version described by the manifest. Downloads
+     * only what is missing/outdated; every part is checksum-verified BEFORE
+     * being committed. The previous version keeps serving until the new one is
+     * fully committed (atomic flip of `current.json`, then best-effort GC).
+     *
+     * Returns true when the cache is warm (either already up-to-date or
+     * successfully updated); false when it could not be warmed (offline...) —
+     * the caller decides whether a stale/absent cache is acceptable.
+     */
+    warm(descriptor: PoseRuntimeDescriptor | null, onProgress?: (progress: RuntimeCacheProgress) => void): Promise<boolean>;
+    /** Load (and decode) the committed runtime parts; null when cache is cold. */
+    load(): Promise<PoseRuntimeParts | null>;
+    /** Wipe the whole runtime cache (revocation / recovery). */
+    purge(): Promise<void>;
+    private isKnownPart;
+    private readCurrent;
+    private readVerified;
+}

package/lib/runtime/RuntimeCache.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Versioned filesystem cache of a remote pose-runtime payload (legacy
+ * stub-loader helper).
+ *
+ * The light SDK’s default path does **not** use this cache: TF.js loads from
+ * CDN and the model from a URL inside the WebView each boot. This class
+ * remains exported for advanced hosts that still want to download / verify
+ * Strapi `/api/sdk/pose-runtime` parts.
+ *
+ * Guarantees when used:
+ * - sha256 is verified BEFORE a part is committed to the cache.
+ * - `purge()` on revocation signals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeCache = void 0;
+const js_sha256_1 = require("js-sha256");
+const EngineLoader_1 = require("../engine/EngineLoader");
+/** Part names, as declared by the backend runtime manifest. */
+const PART_NAMES = ['tfjs', 'tfjs-wasm', 'model', 'weights', 'pipeline', 'runtime'];
+/** Required parts — `pipeline` is optional (JS fallback lives in the runtime part). */
+const REQUIRED_PARTS = ['tfjs', 'tfjs-wasm', 'model', 'weights', 'runtime'];
+const CURRENT_KEY = 'current.json';
+class RuntimeCache {
+    constructor(options = {}) {
+        this.memoryParts = null;
+        let files = options.fileStore !== undefined
+            ? options.fileStore
+            : (0, EngineLoader_1.createNativeFileStore)('posetracker-runtime');
+        this.persistent = files !== null;
+        if (files === null) {
+            // Bare RN without any filesystem lib: stay functional with an
+            // in-memory store — online works, but every cold start re-downloads.
+            files = (0, EngineLoader_1.createMemoryFileStore)();
+        }
+        this.files = files;
+        this.fetchFn = options.fetchFn ?? fetch;
+    }
+    /** Version currently committed to the cache, or null when cold/empty. */
+    async getCachedVersion() {
+        const current = await this.readCurrent();
+        return current?.version ?? null;
+    }
+    /**
+     * Ensure the cache holds the version described by the manifest. Downloads
+     * only what is missing/outdated; every part is checksum-verified BEFORE
+     * being committed. The previous version keeps serving until the new one is
+     * fully committed (atomic flip of `current.json`, then best-effort GC).
+     *
+     * Returns true when the cache is warm (either already up-to-date or
+     * successfully updated); false when it could not be warmed (offline...) —
+     * the caller decides whether a stale/absent cache is acceptable.
+     */
+    async warm(descriptor, onProgress) {
+        if (!this.files) {
+            return false;
+        }
+        const current = await this.readCurrent();
+        if (!descriptor) {
+            // Offline handshake: the existing cache (if any) is served as-is.
+            return current !== null;
+        }
+        if (current && current.version === descriptor.version) {
+            return true;
+        }
+        const wanted = Object.entries(descriptor.parts);
+        const next = { version: descriptor.version, parts: {} };
+        let completed = 0;
+        try {
+            for (const [name, part] of wanted) {
+                if (!this.isKnownPart(name)) {
+                    continue;
+                }
+                onProgress?.({
+                    part: name,
+                    completedParts: completed,
+                    totalParts: wanted.length,
+                    partBytes: part.bytes,
+                });
+                const key = `${name}@${descriptor.version}`;
+                // Reuse without network when the exact content is already cached
+                // (same key from an interrupted warm, or same sha in the previous
+                // version under another key).
+                let content = await this.readVerified(key, part.sha256);
+                if (content === null) {
+                    const previous = current?.parts[name];
+                    if (previous && previous.sha256 === part.sha256) {
+                        content = await this.readVerified(previous.key, part.sha256);
+                    }
+                }
+                if (content === null) {
+                    const response = await this.fetchFn(part.url);
+                    if (!response.ok) {
+                        throw new Error(`pose-runtime part '${name}' HTTP ${response.status}`);
+                    }
+                    content = await response.text();
+                    // Integrity gate BEFORE commit: a truncated/corrupted download
+                    // never reaches the cache.
+                    if ((0, js_sha256_1.sha256)(content) !== part.sha256) {
+                        throw new Error(`pose-runtime part '${name}' failed sha256 verification`);
+                    }
+                }
+                await this.files.write(key, content);
+                next.parts[name] = { key, sha256: part.sha256 };
+                completed += 1;
+            }
+            for (const required of REQUIRED_PARTS) {
+                if (!next.parts[required]) {
+                    throw new Error(`pose-runtime manifest is missing required part '${required}'`);
+                }
+            }
+            // Commit point: flip the pointer only once every part is verified.
+            await this.files.write(CURRENT_KEY, JSON.stringify(next));
+            this.memoryParts = null;
+            // Best-effort GC of the previous version's files.
+            if (current) {
+                for (const entry of Object.values(current.parts)) {
+                    if (entry && !Object.values(next.parts).some((p) => p && p.key === entry.key)) {
+                        await this.files.remove(entry.key).catch(() => { });
+                    }
+                }
+            }
+            return true;
+        }
+        catch {
+            // Warm failed: the previous committed version stays intact.
+            return current !== null;
+        }
+    }
+    /** Load (and decode) the committed runtime parts; null when cache is cold. */
+    async load() {
+        if (this.memoryParts) {
+            return this.memoryParts;
+        }
+        if (!this.files) {
+            return null;
+        }
+        const current = await this.readCurrent();
+        if (!current) {
+            return null;
+        }
+        const read = async (name) => {
+            const entry = current.parts[name];
+            if (!entry) {
+                return null;
+            }
+            return this.readVerified(entry.key, entry.sha256);
+        };
+        const [tfjsJs, tfjsWasmRaw, modelJson, weightsRaw, pipelineWasmB64, runtimeJs] = await Promise.all([
+            read('tfjs'),
+            read('tfjs-wasm'),
+            read('model'),
+            read('weights'),
+            read('pipeline'),
+            read('runtime'),
+        ]);
+        if (!tfjsJs || !tfjsWasmRaw || !modelJson || !weightsRaw || !runtimeJs) {
+            // A part is missing or failed integrity: treat the cache as cold.
+            return null;
+        }
+        try {
+            this.memoryParts = {
+                version: current.version,
+                tfjsJs,
+                tfjsWasmB64: JSON.parse(tfjsWasmRaw),
+                modelJson,
+                weightsB64: JSON.parse(weightsRaw),
+                pipelineWasmB64: pipelineWasmB64 ?? null,
+                runtimeJs,
+            };
+            return this.memoryParts;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Wipe the whole runtime cache (revocation / recovery). */
+    async purge() {
+        this.memoryParts = null;
+        if (!this.files) {
+            return;
+        }
+        const current = await this.readCurrent();
+        if (current) {
+            for (const entry of Object.values(current.parts)) {
+                if (entry) {
+                    await this.files.remove(entry.key).catch(() => { });
+                }
+            }
+        }
+        await this.files.remove(CURRENT_KEY).catch(() => { });
+    }
+    // -------------------------------------------------------------------------
+    isKnownPart(name) {
+        return PART_NAMES.includes(name);
+    }
+    async readCurrent() {
+        try {
+            const raw = await this.files?.read(CURRENT_KEY);
+            if (!raw) {
+                return null;
+            }
+            const parsed = JSON.parse(raw);
+            if (!parsed.version || !parsed.parts) {
+                return null;
+            }
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readVerified(key, expectedSha) {
+        try {
+            const content = await this.files?.read(key);
+            if (content === null || content === undefined) {
+                return null;
+            }
+            if ((0, js_sha256_1.sha256)(content) !== expectedSha) {
+                await this.files?.remove(key).catch(() => { });
+                return null;
+            }
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.RuntimeCache = RuntimeCache;

package/lib/sdkVersion.d.ts

@@ -0,0 +1,2 @@
+/** AUTO-GENERATED by scripts/sync-sdk-version.mjs — do not edit. */
+export declare const SDK_VERSION = "0.1.0";

package/lib/sdkVersion.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+/** AUTO-GENERATED by scripts/sync-sdk-version.mjs — do not edit. */
+exports.SDK_VERSION = '0.1.0';

package/lib/support/optionalModules.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Guarded access to the OPTIONAL native modules used by the Apple Vision
+ * backend: react-native-vision-camera + react-native-worklets-core.
+ *
+ * They are `peerDependenciesMeta.optional` — a host that only uses the
+ * WebView runtime (the default, Expo Go compatible) does not install them.
+ *
+ * 1. Every `require` is wrapped in try/catch. Metro marks dependencies
+ *    required inside a try block as *optional* when
+ *    `transformer.allowOptionalDependencies` is enabled (the Expo default),
+ *    so bundling never fails when a module is absent.
+ * 2. The SDK must not depend on these packages' TypeScript types, so the
+ *    interfaces below are minimal *structural* typings of the APIs we
+ *    consume (react-native-vision-camera 4.x, worklets-core 1.x).
+ */
+/**
+ * Expo Go has no vision-camera native binaries. Requiring them there throws
+ * (and React Native LogBox still surfaces it even when wrapped in
+ * try/catch). Detect Expo Go *before* any of those requires.
+ */
+export declare function isExpoGo(): boolean;
+/** react-native-vision-camera 4.x — subset used by PoseCameraView. */
+export interface VisionCameraFrame {
+    width: number;
+    height: number;
+    orientation: string;
+    timestamp: number;
+}
+export interface VisionCameraModule {
+    Camera: any;
+    useCameraDevice(position: 'front' | 'back'): unknown | undefined;
+    useCameraPermission(): {
+        hasPermission: boolean;
+        requestPermission: () => Promise<boolean>;
+    };
+    useFrameProcessor(processor: (frame: VisionCameraFrame) => void, deps: unknown[]): unknown;
+}
+/** react-native-worklets-core 1.x — subset used by PoseCameraView. */
+export interface WorkletsCoreModule {
+    useSharedValue<T>(initial: T): {
+        value: T;
+    };
+    useRunOnJS<A extends unknown[]>(fn: (...args: A) => void, deps: unknown[]): (...args: A) => void;
+}
+export declare function getVisionCamera(): VisionCameraModule | null;
+export declare function getWorkletsCore(): WorkletsCoreModule | null;

package/lib/support/optionalModules.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Guarded access to the OPTIONAL native modules used by the Apple Vision
+ * backend: react-native-vision-camera + react-native-worklets-core.
+ *
+ * They are `peerDependenciesMeta.optional` — a host that only uses the
+ * WebView runtime (the default, Expo Go compatible) does not install them.
+ *
+ * 1. Every `require` is wrapped in try/catch. Metro marks dependencies
+ *    required inside a try block as *optional* when
+ *    `transformer.allowOptionalDependencies` is enabled (the Expo default),
+ *    so bundling never fails when a module is absent.
+ * 2. The SDK must not depend on these packages' TypeScript types, so the
+ *    interfaces below are minimal *structural* typings of the APIs we
+ *    consume (react-native-vision-camera 4.x, worklets-core 1.x).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpoGo = isExpoGo;
+exports.getVisionCamera = getVisionCamera;
+exports.getWorkletsCore = getWorkletsCore;
+/**
+ * Expo Go has no vision-camera native binaries. Requiring them there throws
+ * (and React Native LogBox still surfaces it even when wrapped in
+ * try/catch). Detect Expo Go *before* any of those requires.
+ */
+function isExpoGo() {
+    try {
+        // Avoid a hard dependency on expo-constants: same signal Nitro uses.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { NativeModules } = require('react-native');
+        return (NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants
+            ?.appOwnership === 'expo');
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Guarded requires (cached; `undefined` = not probed yet, `null` = missing)
+// ---------------------------------------------------------------------------
+// NOTE: every `require` below uses a STRING LITERAL — Metro cannot resolve
+// dynamic `require(variable)` calls and would fail the build.
+let visionCamera;
+let workletsCore;
+function getVisionCamera() {
+    if (visionCamera === undefined) {
+        if (isExpoGo()) {
+            visionCamera = null;
+        }
+        else {
+            try {
+                visionCamera = require('react-native-vision-camera');
+            }
+            catch {
+                visionCamera = null;
+            }
+            if (visionCamera && typeof visionCamera.useFrameProcessor !== 'function') {
+                visionCamera = null;
+            }
+        }
+    }
+    return visionCamera;
+}
+function getWorkletsCore() {
+    if (workletsCore === undefined) {
+        if (isExpoGo()) {
+            workletsCore = null;
+        }
+        else {
+            try {
+                workletsCore = require('react-native-worklets-core');
+            }
+            catch {
+                workletsCore = null;
+            }
+            if (workletsCore && typeof workletsCore.useRunOnJS !== 'function') {
+                workletsCore = null;
+            }
+        }
+    }
+    return workletsCore;
+}