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

package/lib/quality/RuntimeGuard.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Crash-loop guard for quality / runtime profiles.
+ *
+ * Analog of Sency's `TfliteRuntimeGuard` (PROBING → PASSED | FAILED):
+ *   1. Before activating a profile, `markProbing(key)`.
+ *   2. After a healthy ready signal, `markPassed(key)`.
+ *   3. If the app is killed/crashes while still PROBING, the next launch
+ *      sees PROBING → treats it as FAILED → caller must pick a lower profile.
+ *
+ * Persisted via {@link KeyValueStore} (AsyncStorage when available). Without
+ * a store the guard is in-memory only (still useful within one process for
+ * the 30s same-process timeout).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeGuard = void 0;
+const KEY_PREFIX = 'posetracker.quality.guard.';
+/** Same-process: if still probing after this, treat as failed. */
+const PROBING_TIMEOUT_MS = 30000;
+class RuntimeGuard {
+    constructor(kv, sdkVersion) {
+        this.kv = kv;
+        this.sdkVersion = sdkVersion;
+        this.memory = new Map();
+    }
+    storageKey(profileKey) {
+        return `${KEY_PREFIX}${this.sdkVersion}.${profileKey}`;
+    }
+    async getState(profileKey) {
+        const key = this.storageKey(profileKey);
+        let record = this.memory.get(key) ?? null;
+        if (!record && this.kv) {
+            try {
+                const raw = await this.kv.getItem(key);
+                if (raw)
+                    record = JSON.parse(raw);
+            }
+            catch {
+                record = null;
+            }
+        }
+        if (!record)
+            return 'unknown';
+        if (record.state === 'probing' &&
+            Date.now() - record.updatedAt > PROBING_TIMEOUT_MS) {
+            await this.write(profileKey, 'failed');
+            return 'failed';
+        }
+        return record.state;
+    }
+    /**
+     * If previous launch died while probing this key, mark failed and return true.
+     */
+    async consumeCrashIfProbing(profileKey) {
+        const state = await this.getState(profileKey);
+        if (state === 'probing') {
+            await this.write(profileKey, 'failed');
+            return true;
+        }
+        return false;
+    }
+    async markProbing(profileKey) {
+        await this.write(profileKey, 'probing');
+    }
+    async markPassed(profileKey) {
+        await this.write(profileKey, 'passed');
+    }
+    async markFailed(profileKey) {
+        await this.write(profileKey, 'failed');
+    }
+    async isFailed(profileKey) {
+        return (await this.getState(profileKey)) === 'failed';
+    }
+    /** Clear persisted/memory state for a profile (recover from stale FAILED). */
+    async clear(profileKey) {
+        const key = this.storageKey(profileKey);
+        this.memory.delete(key);
+        if (!this.kv)
+            return;
+        try {
+            await this.kv.removeItem(key);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    async write(profileKey, state) {
+        const key = this.storageKey(profileKey);
+        const record = {
+            state,
+            updatedAt: Date.now(),
+            sdkVersion: this.sdkVersion,
+        };
+        this.memory.set(key, record);
+        if (!this.kv)
+            return;
+        try {
+            await this.kv.setItem(key, JSON.stringify(record));
+        }
+        catch {
+            /* persistence best-effort */
+        }
+    }
+}
+exports.RuntimeGuard = RuntimeGuard;

package/lib/quality/captureMode.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Camera capture + Android perf experiment knobs (WebView getUserMedia / MoveNet).
+ *
+ * iOS is never mutated by the Android-only flags below — {@link buildPoseHtml}
+ * forces frame-skip / soft-cap / preprocess overrides off on iOS.
+ *
+ * ## Experiment stack 2026-08-06
+ * 1. `device-native` cold open (Front-aligned) + optional Android soft-cap
+ * 2. Android frame-skip between inferences
+ * 3. Android lighter preprocess (`canvas-direct`)
+ * 4. Android min-target floor 10 FPS (downgrade only when truly needed)
+ * 5. Verbose perf debug in WebView stats / HUD
+ *
+ * ## REVERT to previous stable behaviour
+ * 1. `CAPTURE_CONSTRAINT_MODE = 'profile-constrained'`
+ * 2. `ENABLE_MALI_HARD_CAP = true`
+ * 3. `ANDROID_INFER_FRAME_SKIP = 0`
+ * 4. `ANDROID_PREPROCESS_PATH = 'imagebitmap'`
+ * 5. `ANDROID_SOFT_CAP_PROFILE = null` (experiment currently pins `'basic'`)
+ * 6. `ANDROID_MIN_TARGET_FPS = 15`
+ * 7. `ANDROID_PERF_DEBUG = false`
+ * 8. Rebuild: `npm run build:runtime-payload && npm run build`
+ * 9. Refresh testapp link + `npx expo start -c`
+ *
+ * You also have a zip archive of the previous SDK as a full rollback.
+ */
+/** How getUserMedia chooses resolution on cold open. */
+export type CaptureConstraintMode = 'device-native' | 'profile-constrained';
+/**
+ * Letterbox preprocess path inside the WebView (Android experiment only).
+ * - `imagebitmap` — draw 192² canvas → createImageBitmap → fromPixels (legacy)
+ * - `canvas-direct` — draw 192² canvas → fromPixels(canvas) (skips ImageBitmap)
+ */
+export type AndroidPreprocessPath = 'imagebitmap' | 'canvas-direct';
+/** Soft-cap ladder ids (mirrors QualityProfileId; kept local to avoid import cycles). */
+export type AndroidSoftCapProfile = 'prime' | 'pro' | 'lite' | 'ultralite' | 'basic';
+/**
+ * - `device-native` — facingMode only (like PoseTrackerFront). Preview = device default (often HD).
+ * - `profile-constrained` — ideal width/height/frameRate from the AdaptiveChoice ladder.
+ */
+export declare const CAPTURE_CONSTRAINT_MODE: CaptureConstraintMode;
+/**
+ * When true, Mali GL renderers are hard-capped to UltraLite at capability score
+ * time (previous SDK default). Disable for the Front-aligned experiment so RN
+ * does not immediately setQuality() back down to 480×360 after a native HD open.
+ */
+export declare const ENABLE_MALI_HARD_CAP = false;
+/**
+ * Android-only: ready rAF ticks to skip between MoveNet inferences.
+ * Preview stays at full capture quality.
+ *
+ * - `0` — off
+ * - `1` — every other ready tick
+ * - `2` — every 3rd, etc.
+ */
+export declare const ANDROID_INFER_FRAME_SKIP = 1;
+/**
+ * Android-only preprocess path. iOS always uses `imagebitmap` (unchanged).
+ */
+export declare const ANDROID_PREPROCESS_PATH: AndroidPreprocessPath;
+/**
+ * Android-only cold-open soft cap. When set, getUserMedia uses this profile’s
+ * width/height as ideal+max even in `device-native` mode (so the device cannot
+ * open unrestricted 1080p). Set `null` for fully unconstrained facingMode-only.
+ *
+ * Mali-G52 evidence (2026-08-06): `basic` 240×320 ≈ 10 FPS median; `ultralite`
+ * 360×480 ≈ 8 FPS — pin soft-cap to `basic` to hold the 10 FPS floor.
+ * Live `setQuality` cannot go lower than basic.
+ */
+export declare const ANDROID_SOFT_CAP_PROFILE: AndroidSoftCapProfile | null;
+/**
+ * Android AdaptiveChoice floor (min target FPS). Downgrade when median
+ * inference ms stays above ~1.2 × (1000/floor). iOS stays on
+ * {@link MIN_TARGET_FPS_IOS} (30).
+ */
+export declare const ANDROID_MIN_TARGET_FPS = 10;
+/**
+ * When true (Android), WebView posts rich `experiments` + `leverHints` on each
+ * 1 Hz stats tick and mirrors a compact line on the HUD. RN logs the same via
+ * the existing diagnostic listener. iOS ignores this flag.
+ */
+export declare const ANDROID_PERF_DEBUG = true;

package/lib/quality/captureMode.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Camera capture + Android perf experiment knobs (WebView getUserMedia / MoveNet).
+ *
+ * iOS is never mutated by the Android-only flags below — {@link buildPoseHtml}
+ * forces frame-skip / soft-cap / preprocess overrides off on iOS.
+ *
+ * ## Experiment stack 2026-08-06
+ * 1. `device-native` cold open (Front-aligned) + optional Android soft-cap
+ * 2. Android frame-skip between inferences
+ * 3. Android lighter preprocess (`canvas-direct`)
+ * 4. Android min-target floor 10 FPS (downgrade only when truly needed)
+ * 5. Verbose perf debug in WebView stats / HUD
+ *
+ * ## REVERT to previous stable behaviour
+ * 1. `CAPTURE_CONSTRAINT_MODE = 'profile-constrained'`
+ * 2. `ENABLE_MALI_HARD_CAP = true`
+ * 3. `ANDROID_INFER_FRAME_SKIP = 0`
+ * 4. `ANDROID_PREPROCESS_PATH = 'imagebitmap'`
+ * 5. `ANDROID_SOFT_CAP_PROFILE = null` (experiment currently pins `'basic'`)
+ * 6. `ANDROID_MIN_TARGET_FPS = 15`
+ * 7. `ANDROID_PERF_DEBUG = false`
+ * 8. Rebuild: `npm run build:runtime-payload && npm run build`
+ * 9. Refresh testapp link + `npx expo start -c`
+ *
+ * You also have a zip archive of the previous SDK as a full rollback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANDROID_PERF_DEBUG = exports.ANDROID_MIN_TARGET_FPS = exports.ANDROID_SOFT_CAP_PROFILE = exports.ANDROID_PREPROCESS_PATH = exports.ANDROID_INFER_FRAME_SKIP = exports.ENABLE_MALI_HARD_CAP = exports.CAPTURE_CONSTRAINT_MODE = void 0;
+/**
+ * - `device-native` — facingMode only (like PoseTrackerFront). Preview = device default (often HD).
+ * - `profile-constrained` — ideal width/height/frameRate from the AdaptiveChoice ladder.
+ */
+exports.CAPTURE_CONSTRAINT_MODE = 'device-native';
+/**
+ * When true, Mali GL renderers are hard-capped to UltraLite at capability score
+ * time (previous SDK default). Disable for the Front-aligned experiment so RN
+ * does not immediately setQuality() back down to 480×360 after a native HD open.
+ */
+exports.ENABLE_MALI_HARD_CAP = false;
+/**
+ * Android-only: ready rAF ticks to skip between MoveNet inferences.
+ * Preview stays at full capture quality.
+ *
+ * - `0` — off
+ * - `1` — every other ready tick
+ * - `2` — every 3rd, etc.
+ */
+exports.ANDROID_INFER_FRAME_SKIP = 1;
+/**
+ * Android-only preprocess path. iOS always uses `imagebitmap` (unchanged).
+ */
+exports.ANDROID_PREPROCESS_PATH = 'canvas-direct';
+/**
+ * Android-only cold-open soft cap. When set, getUserMedia uses this profile’s
+ * width/height as ideal+max even in `device-native` mode (so the device cannot
+ * open unrestricted 1080p). Set `null` for fully unconstrained facingMode-only.
+ *
+ * Mali-G52 evidence (2026-08-06): `basic` 240×320 ≈ 10 FPS median; `ultralite`
+ * 360×480 ≈ 8 FPS — pin soft-cap to `basic` to hold the 10 FPS floor.
+ * Live `setQuality` cannot go lower than basic.
+ */
+exports.ANDROID_SOFT_CAP_PROFILE = 'basic';
+/**
+ * Android AdaptiveChoice floor (min target FPS). Downgrade when median
+ * inference ms stays above ~1.2 × (1000/floor). iOS stays on
+ * {@link MIN_TARGET_FPS_IOS} (30).
+ */
+exports.ANDROID_MIN_TARGET_FPS = 10;
+/**
+ * When true (Android), WebView posts rich `experiments` + `leverHints` on each
+ * 1 Hz stats tick and mirrors a compact line on the HUD. RN logs the same via
+ * the existing diagnostic listener. iOS ignores this flag.
+ */
+exports.ANDROID_PERF_DEBUG = true;

package/lib/quality/deviceCapability.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Lightweight device capability score → initial quality profile.
+ *
+ * Sency's AdaptiveChoice uses RAM / CPU freq / first API level. In Expo Go we
+ * only have a subset of signals without extra native deps; we combine:
+ *   - Platform (iOS is typically 3–5× faster on WebGL MoveNet)
+ *   - Android API level
+ *   - Optional RAM via expo-device / react-native DeviceInfo when present
+ *   - GL renderer hint (Mali mid-range) once known from the WebView
+ *
+ * Score is 0–100; mapped to a QualityProfileId. Brand/year caps from Sency
+ * are approximated via API level + Mali detection.
+ */
+import type { QualityProfileId } from './profiles';
+export interface DeviceCapabilitySnapshot {
+    platform: 'ios' | 'android' | 'other';
+    /** Android API level or iOS major version when available. */
+    osVersion: number | null;
+    /** Total device RAM in GiB when a probe is available. */
+    totalMemoryGiB: number | null;
+    /** WebGL UNMASKED_RENDERER when known (after first WebView ready). */
+    glRenderer: string | null;
+    /** 0–100 composite score. */
+    score: number;
+    /** Profile suggested by the score (before crash-guard / caps). */
+    suggestedProfile: QualityProfileId;
+    reasons: string[];
+}
+export declare function isMaliRenderer(renderer: string | null | undefined): boolean;
+/**
+ * Map capability score → profile (before Mali / crash-guard caps).
+ * Thresholds calibrated so mid-range Android (Mali-G52 era) lands on UltraLite.
+ */
+export declare function profileFromScore(score: number): QualityProfileId;
+export declare function scoreDeviceCapability(options?: {
+    glRenderer?: string | null;
+}): DeviceCapabilitySnapshot;

package/lib/quality/deviceCapability.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Lightweight device capability score → initial quality profile.
+ *
+ * Sency's AdaptiveChoice uses RAM / CPU freq / first API level. In Expo Go we
+ * only have a subset of signals without extra native deps; we combine:
+ *   - Platform (iOS is typically 3–5× faster on WebGL MoveNet)
+ *   - Android API level
+ *   - Optional RAM via expo-device / react-native DeviceInfo when present
+ *   - GL renderer hint (Mali mid-range) once known from the WebView
+ *
+ * Score is 0–100; mapped to a QualityProfileId. Brand/year caps from Sency
+ * are approximated via API level + Mali detection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMaliRenderer = isMaliRenderer;
+exports.profileFromScore = profileFromScore;
+exports.scoreDeviceCapability = scoreDeviceCapability;
+const react_native_1 = require("react-native");
+const captureMode_1 = require("./captureMode");
+function probeTotalMemoryGiB() {
+    // Optional peers — never required.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const Device = require('expo-device');
+        const bytes = Device.totalMemory;
+        if (typeof bytes === 'number' && bytes > 0)
+            return bytes / (1024 * 1024 * 1024);
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const DeviceInfo = require('react-native-device-info');
+        // sync API may exist
+        if (typeof DeviceInfo.getTotalMemorySync === 'function') {
+            const bytes = DeviceInfo.getTotalMemorySync();
+            if (typeof bytes === 'number' && bytes > 0)
+                return bytes / (1024 * 1024 * 1024);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+function parseOsVersion() {
+    const v = react_native_1.Platform.Version;
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'string') {
+        const major = parseInt(v.split('.')[0] ?? '', 10);
+        return Number.isFinite(major) ? major : null;
+    }
+    return null;
+}
+function isMaliRenderer(renderer) {
+    return !!(renderer && /mali/i.test(renderer));
+}
+/**
+ * Map capability score → profile (before Mali / crash-guard caps).
+ * Thresholds calibrated so mid-range Android (Mali-G52 era) lands on UltraLite.
+ */
+function profileFromScore(score) {
+    if (score >= 78)
+        return 'prime';
+    if (score >= 62)
+        return 'pro';
+    if (score >= 48)
+        return 'lite';
+    if (score >= 32)
+        return 'ultralite';
+    return 'basic';
+}
+function scoreDeviceCapability(options) {
+    const reasons = [];
+    const platform = react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'other';
+    const osVersion = parseOsVersion();
+    const totalMemoryGiB = probeTotalMemoryGiB();
+    const glRenderer = options?.glRenderer ?? null;
+    let score = 0;
+    if (platform === 'ios') {
+        // Apple GPU WebGL MoveNet is typically <20 ms — start high.
+        score += 55;
+        reasons.push('platform=ios (+55)');
+        if (osVersion != null) {
+            if (osVersion >= 17) {
+                score += 15;
+                reasons.push(`ios>=17 (+15)`);
+            }
+            else if (osVersion >= 15) {
+                score += 10;
+                reasons.push(`ios>=15 (+10)`);
+            }
+            else {
+                score += 5;
+                reasons.push(`ios legacy (+5)`);
+            }
+        }
+    }
+    else if (platform === 'android') {
+        score += 18;
+        reasons.push('platform=android (+18)');
+        if (osVersion != null) {
+            if (osVersion >= 34) {
+                score += 14;
+                reasons.push(`api>=34 (+14)`);
+            }
+            else if (osVersion >= 31) {
+                score += 10;
+                reasons.push(`api>=31 (+10)`);
+            }
+            else if (osVersion >= 28) {
+                score += 6;
+                reasons.push(`api>=28 (+6)`);
+            }
+            else {
+                reasons.push(`api=${osVersion} (+0)`);
+            }
+        }
+    }
+    else {
+        score += 20;
+        reasons.push('platform=other (+20)');
+    }
+    if (totalMemoryGiB != null) {
+        if (totalMemoryGiB >= 8) {
+            score += 20;
+            reasons.push(`ram>=8GiB (+20)`);
+        }
+        else if (totalMemoryGiB >= 6) {
+            score += 14;
+            reasons.push(`ram>=6GiB (+14)`);
+        }
+        else if (totalMemoryGiB >= 4) {
+            score += 8;
+            reasons.push(`ram>=4GiB (+8)`);
+        }
+        else {
+            reasons.push(`ram=${totalMemoryGiB.toFixed(1)}GiB (+0)`);
+        }
+    }
+    else {
+        // Neutral default when RAM unknown: don't assume high-end.
+        score += 6;
+        reasons.push('ram=unknown (+6)');
+    }
+    if (isMaliRenderer(glRenderer)) {
+        // Mali mid-range: HD camera preprocess alone can cost ~100 ms/frame.
+        score = Math.min(score, 40);
+        reasons.push('gl=Mali cap score≤40');
+    }
+    score = Math.max(0, Math.min(100, score));
+    let suggested = profileFromScore(score);
+    // Hard caps (Sency-style).
+    if (platform === 'android' && suggested === 'prime') {
+        suggested = 'pro';
+        reasons.push('android cap: prime→pro');
+    }
+    // Mali → ultralite hard cap: gated by captureMode (see captureMode.ts REVERT).
+    if (captureMode_1.ENABLE_MALI_HARD_CAP &&
+        isMaliRenderer(glRenderer) &&
+        (suggested === 'prime' || suggested === 'pro')) {
+        suggested = 'ultralite';
+        reasons.push('mali cap: →ultralite');
+    }
+    return {
+        platform,
+        osVersion,
+        totalMemoryGiB,
+        glRenderer,
+        score,
+        suggestedProfile: suggested,
+        reasons,
+    };
+}

package/lib/quality/profiles.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 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.
+ */
+export type QualityProfileId = 'prime' | 'pro' | 'lite' | 'ultralite' | 'basic';
+/** Host-facing choice, mirrors Sency's AdaptiveChoice + explicit override. */
+export type QualityChoice = 'AdaptiveChoice' | QualityProfileId;
+/**
+ * Host trade-off between pose FPS and camera preview sharpness.
+ *
+ * - `performance` (default) — AdaptiveChoice may lower capture (esp. Android
+ *   soft-cap / warm-up / live downgrade) so inference stays near the platform
+ *   FPS floor. Preview can look soft on mid-range Android.
+ * - `quality` — keep high capture / skip FPS-driven capture downgrades.
+ *   Preview stays sharp; pose FPS may drop well below the floor. The SDK still
+ *   emits `performance_warning` when slow.
+ *
+ * Explicit {@link QualityChoice} profile ids still pin the starting tier;
+ * `quality` only disables automatic FPS-driven drops.
+ */
+export type CapturePriority = 'performance' | 'quality';
+export type QualityPlatform = 'ios' | 'android' | 'other';
+export interface FpsRange {
+    /** Soft lower bound of the “good experience” band (same as min target on that OS). */
+    min: number;
+    /**
+     * Soft upper reference for docs / UI (“we’re happy around here”).
+     * Not a hard cap — exceeding it is fine.
+     */
+    idealMax: number;
+}
+export interface QualityProfile {
+    id: QualityProfileId;
+    /** Human label for diagnostics / docs. */
+    label: string;
+    /** getUserMedia ideal width (CSS pixels / sensor). */
+    idealWidth: number;
+    /** getUserMedia ideal height. */
+    idealHeight: number;
+    /** getUserMedia ideal frameRate. */
+    idealFrameRate: number;
+    /**
+     * Per-profile floor used when AdaptiveChoice has not overridden via platform.
+     * Live controller uses {@link getMinTargetFps} instead.
+     */
+    minStableFps: number;
+}
+/**
+ * Ordered highest → lowest. `nextLowerQualityProfile` walks this ladder.
+ */
+export declare const QUALITY_LADDER: readonly QualityProfileId[];
+/**
+ * Android minimum acceptable inference FPS (floor).
+ * Sourced from {@link ANDROID_MIN_TARGET_FPS} so the experiment flag is the
+ * single knob (see captureMode.ts).
+ */
+export declare const MIN_TARGET_FPS_ANDROID = 10;
+/**
+ * iOS minimum acceptable inference FPS (floor).
+ * Acceptable/ideal experience is typically 30–50+ on Apple GPU.
+ */
+export declare const MIN_TARGET_FPS_IOS = 30;
+/** Fallback floor for unknown platforms. */
+export declare const MIN_TARGET_FPS_DEFAULT = 10;
+/**
+ * Documented “good experience” bands (not hard caps).
+ * Downgrades / warnings use the **min** only.
+ */
+export declare const IDEAL_FPS_RANGE_IOS: FpsRange;
+export declare const IDEAL_FPS_RANGE_ANDROID: FpsRange;
+/**
+ * @deprecated Use {@link getMinTargetFps} / {@link MIN_TARGET_FPS_ANDROID}.
+ * Kept as the Android floor so older imports keep a sensible number.
+ */
+export declare const TARGET_FPS = 10;
+/** @deprecated Use {@link minMedianMsForMinTarget}. */
+export declare const TARGET_MEDIAN_MS: number;
+/**
+ * Critical alert when FPS stays well below the platform minimum target
+ * (even on `basic`). Android: <10; iOS: <20.
+ */
+export declare function getCriticalFpsThreshold(platform?: QualityPlatform): number;
+/** @deprecated Prefer {@link getCriticalFpsThreshold}. */
+export declare const CRITICAL_FPS_THRESHOLD = 10;
+/** Consecutive samples below min-target before auto-downgrade. */
+/** Sustained samples below the inference budget before a live downgrade. */
+export declare const 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).
+ */
+export declare const QUALITY_SETTLE_MS = 5000;
+export declare const QUALITY_PROFILES: Record<QualityProfileId, QualityProfile>;
+export declare function currentQualityPlatform(): QualityPlatform;
+/** Platform minimum target FPS (floor — not a setpoint). */
+export declare function getMinTargetFps(platform?: QualityPlatform): number;
+export declare function getIdealFpsRange(platform?: QualityPlatform): FpsRange;
+/** Max warm-up median ms that still meets a given min-target FPS. */
+export declare function minMedianMsForMinTarget(minTargetFps: number): number;
+export declare function getQualityProfile(id: QualityProfileId): QualityProfile;
+export declare function nextLowerQualityProfile(id: QualityProfileId): QualityProfileId | null;
+export declare function isQualityProfileId(value: string): value is QualityProfileId;
+export declare function qualityLadderIndex(id: QualityProfileId): number;
+/** Lower or equal quality (higher index) wins. */
+export declare function lowerQualityProfile(a: QualityProfileId, b: QualityProfileId): QualityProfileId;
+/**
+ * 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).
+ */
+export declare function profileFromWarmupMedianMs(medianMs: number | null, minTargetFps?: number): QualityProfileId;
+export declare function estimatedFpsFromMedianMs(medianMs: number | null): number | null;