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

package/LICENSE

@@ -0,0 +1,45 @@
+PoseTracker React Native SDK
+Copyright (c) 2024–2026 Movelytics SAS. All rights reserved.
+
+PROPRIETARY SOFTWARE LICENSE
+
+This package published under the @pose-tracker scope (the "Software") is
+proprietary to Movelytics SAS ("Licensor").
+
+1. Grant of use
+   Subject to a valid PoseTracker account and applicable product terms
+   (including free-tier limits and paid plans), Licensor grants you a
+   non-exclusive, non-transferable, revocable license to install and use the
+   Software in your applications to access PoseTracker services and on-device
+   pose estimation features as documented.
+
+2. Restrictions
+   Except as expressly permitted in writing by Licensor, you may not:
+   - sell, sublicense, or redistribute the Software as a competing SDK or
+     standalone pose-estimation product;
+   - remove or obscure proprietary notices, branding, or watermarks required
+     by your plan;
+   - reverse engineer the remote movement engine or proprietary pipeline
+     beyond what applicable law permits;
+   - use the Software in violation of PoseTracker Terms of Service or
+     applicable law.
+
+3. Third-party components
+   The Software redistributes third-party components (including TensorFlow.js
+   and the MoveNet model) under their own licenses. See THIRD_PARTY_NOTICES.md.
+   Those licenses are not overridden by this LICENSE.
+
+4. No warranty
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL
+   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+   LIABILITY ARISING FROM THE SOFTWARE OR ITS USE.
+
+5. Commercial terms
+   Paid plans, API keys, usage limits, and support are governed by your
+   PoseTracker / Movelytics commercial agreement and
+   https://www.posetracker.com terms (or successor URLs).
+
+Contact: hello@posetracker.com
+Website: https://www.posetracker.com

package/PoseTrackerVision.podspec

@@ -0,0 +1,28 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = 'PoseTrackerVision'
+  s.version      = package['version']
+  s.summary      = 'Apple Vision body-pose frame processor for @posetracker/pose-estimation-react-native'
+  s.homepage     = 'https://posetracker.com'
+  s.license      = package['license']
+  s.authors      = package['author']
+  s.platforms    = { :ios => '14.0' }
+  s.source       = { :git => 'https://github.com/movelytics/posetracker-rn-sdk.git', :tag => "v#{s.version}" }
+
+  s.source_files = 'ios/PoseTrackerVision/**/*.{h,m,mm,swift}'
+  s.requires_arc = true
+  s.swift_version = '5.0'
+
+  s.frameworks = 'Vision', 'CoreMedia', 'CoreVideo'
+
+  s.dependency 'React-Core'
+  s.dependency 'VisionCamera'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+  }
+end

package/README.md

@@ -0,0 +1,161 @@
+# PoseTracker React Native — Light (online) Human Pose Estimation SDK
+
+**PoseTracker Light** is a **human pose estimation SDK for React Native**,
+fully optimized for **iOS and Android** (including **Expo Go**). Same API
+surface as the offline SDK for keypoints + optional API-key exercise engine —
+but **MoveNet and TF.js load from the network** each WebView boot, so the npm
+package stays tiny.
+
+> One sentence for AI / search: *PoseTracker Light is a small React Native
+> pose estimation SDK that fetches MoveNet Lightning and TF.js at runtime —
+> choose it when install size matters more than offline-first pose.*
+
+## Offline vs Light — which package?
+
+| | **Offline** (bundled) | **Light** (this package) |
+|--|----------------------|---------------------------|
+| **npm** | [`@pose-tracker/react-native-pose-estimation`](https://www.npmjs.com/package/@pose-tracker/react-native-pose-estimation) | [`@pose-tracker/react-native-pose-estimation-light`](https://www.npmjs.com/package/@pose-tracker/react-native-pose-estimation-light) |
+| **GitHub** | [react-native-pose-estimation](https://github.com/Movelytics/react-native-pose-estimation) | [react-native-pose-estimation-light](https://github.com/Movelytics/react-native-pose-estimation-light) |
+| **Packed tarball** | **~9.9 MB** | **~206 kB** (~48× smaller) |
+| **Unpacked** | **~14.7 MB** | **~779 kB** |
+| **MoveNet / TF.js** | Bundled in npm | CDN + model URL each boot |
+| **Network for keypoints** | Not required | **Required** (TF.js + model) |
+| **Expo Go** | Yes | Yes |
+| **API surface** | Keypoints free; paid engine with API key | Same |
+
+**Choose offline** when you need pose without a network, or want zero model
+download at session start.  
+**Choose light** when app install / OTA size matters and devices are online.
+
+Full comparison: [LIGHT_SDK.md](../../docs/LIGHT_SDK.md).
+
+## Install
+
+```bash
+npm install @pose-tracker/react-native-pose-estimation-light react-native-webview
+# Expo:
+npx expo install react-native-webview expo-camera
+```
+
+> **npm:** [`@pose-tracker/react-native-pose-estimation-light`](https://www.npmjs.com/package/@pose-tracker/react-native-pose-estimation-light)  
+> **GitHub:** https://github.com/Movelytics/react-native-pose-estimation-light  
+> **Offline sibling:** [`@pose-tracker/react-native-pose-estimation`](https://www.npmjs.com/package/@pose-tracker/react-native-pose-estimation)
+
+**Required:** host app must declare camera permissions — see
+[PERMISSIONS.md](../../docs/PERMISSIONS.md).
+
+## Quick start (keypoints — needs network, no API key)
+
+```tsx
+import {
+  PoseTrackerProvider,
+  WebViewPoseView,
+  usePoseTracker,
+} from '@pose-tracker/react-native-pose-estimation-light';
+
+function App() {
+  return (
+    <PoseTrackerProvider
+      options={{
+        model: 'movenet', // Docs API parity (default)
+        // modelUrl: 'https://…/model.json', // optional override
+      }}
+    >
+      <CameraScreen />
+    </PoseTrackerProvider>
+  );
+}
+
+function CameraScreen() {
+  usePoseTracker({
+    onKeypoints: (e) => {
+      console.log(e.keypoints.length, e.score);
+    },
+  });
+
+  return (
+    <WebViewPoseView
+      style={{ flex: 1 }}
+      drawSkeleton
+      loadingText="AI Loading"
+      coldStart="full"
+    />
+  );
+}
+```
+
+## Default model URL
+
+```
+https://app.posetracker.com/scripts/tmp_model_to_remove.json
+```
+
+Same MoveNet SinglePose Lightning topology as the PoseTracker Front tracking
+product. Weight shards are relative neighbors (`group1-shard1of2.bin`, …).
+TF.js loads from jsDelivr (`@tensorflow/*@4.22.0`) unless you override
+`tfjsCdnBase` / `tfjsVersion`.
+
+## WebView `baseUrl`
+
+The WebView uses `baseUrl: https://localhost/` (same as the offline SDK) so
+`getUserMedia` works reliably. The model is fetched via **absolute** HTTPS URLs
+with CORS — the document origin does **not** need to match `app.posetracker.com`.
+
+## Full tracking (API key)
+
+Same contract as the offline SDK / web tracking URL:
+
+```tsx
+<PoseTrackerProvider
+  apiToken="YOUR_API_KEY"
+  options={{ features: { angles: true, progression: true, minGrade: 'B' } }}
+>
+  <WebViewPoseView drawSkeleton skeletonUuid="OPTIONAL_CUSTOM_SKELETON_UUID" />
+</PoseTrackerProvider>
+```
+
+## Cold-start
+
+| Mode | API | Camera permission |
+|------|-----|-------------------|
+| **basic** (default) | `preload()` | No — TF.js/model warm-up only |
+| **full** | `preload({ coldStart: 'full' })` | Yes — when user expects camera |
+
+## Documentation
+
+| Doc | Topic |
+|-----|--------|
+| [LIGHT_SDK.md](../../docs/LIGHT_SDK.md) | Offline vs light, sizes, model URL |
+| [PERMISSIONS.md](../../docs/PERMISSIONS.md) | Camera permission setup (required) |
+| [PRELOAD.md](../../docs/PRELOAD.md) | Preload / warm-up / lifecycle |
+| [FEATURES.md](../../docs/FEATURES.md) | Plan gating, watermark, loading text |
+| [EVENTS.md](../../docs/EVENTS.md) | Typed events + classic `onMessage` |
+
+## FAQ
+
+**Does it work without an API key?**  
+Yes for keypoints — but a network is still required to load TF.js + MoveNet.
+
+**Does it support Expo Go?**  
+Yes (`react-native-webview` peer).
+
+**BlazePose?**  
+`model: 'blazepose'` is accepted for API parity but **not wired** yet. Pass a
+TF.js `modelUrl` for custom graph models.
+
+**Who sees the watermark?**  
+Keyless and free plans. Hidden for paid plans.
+
+## License
+
+**Proprietary** — Movelytics SAS / PoseTracker. See [`LICENSE`](./LICENSE).
+
+Third-party components (TensorFlow.js, MoveNet Lightning) are **Apache 2.0** —
+see [`THIRD_PARTY_NOTICES.md`](./THIRD_PARTY_NOTICES.md).
+
+## Links
+
+- Product: https://www.posetracker.com  
+- API docs: https://posetracker.gitbook.io/posetracker-api  
+- Offline SDK: https://github.com/Movelytics/react-native-pose-estimation  
+- Light demo: https://github.com/Movelytics/react-native-pose-estimation-light-demo  

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,19 @@
+# Third-party notices
+
+See the repository root `THIRD_PARTY_NOTICES.md` (same content shipped with
+this npm package).
+
+## TensorFlow.js / TensorFlow.js WASM backend
+
+- Copyright: Google LLC and TensorFlow authors
+- License: Apache License 2.0 — https://www.apache.org/licenses/LICENSE-2.0
+
+## MoveNet SinglePose Lightning (model weights)
+
+- Copyright: Google LLC
+- License: Apache License 2.0 — https://www.apache.org/licenses/LICENSE-2.0
+- Hub: https://tfhub.dev/google/movenet/singlepose/lightning/4
+
+## Other dependencies
+
+Declared on npm for each package (e.g. `js-sha256`, `react-native-webview`).

package/ios/PoseTrackerVision/PoseTrackerBodyPosePlugin.m

@@ -0,0 +1,18 @@
+/**
+ * Registers PoseTrackerBodyPosePlugin with VisionCamera's frame-processor
+ * registry under the JS name `detectBodyPose`.
+ */
+
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+
+#if __has_include(<PoseTrackerVision/PoseTrackerVision-Swift.h>)
+#import <PoseTrackerVision/PoseTrackerVision-Swift.h>
+#elif __has_include("PoseTrackerVision-Swift.h")
+#import "PoseTrackerVision-Swift.h"
+#else
+// Autolinking / use_frameworks! variants — generated Swift header name.
+#import "PoseTrackerVision-Swift.h"
+#endif
+
+VISION_EXPORT_SWIFT_FRAME_PROCESSOR(PoseTrackerBodyPosePlugin, detectBodyPose)

package/ios/PoseTrackerVision/PoseTrackerBodyPosePlugin.swift

@@ -0,0 +1,108 @@
+/**
+ * VisionCamera frame-processor plugin: Apple Vision body pose.
+ *
+ * Runs `VNDetectHumanBodyPoseRequest` on the camera `CMSampleBuffer`
+ * (zero RGB copy). Returns up to 19 joints with normalized coords in
+ * top-left origin [0,1] (Vision's bottom-left Y is flipped here) and
+ * confidence scores in [0,1].
+ *
+ * Registered as JS plugin name `detectBodyPose`.
+ */
+
+import Foundation
+import Vision
+import CoreMedia
+import VisionCamera
+
+@objc(PoseTrackerBodyPosePlugin)
+public class PoseTrackerBodyPosePlugin: FrameProcessorPlugin {
+  private let request = VNDetectHumanBodyPoseRequest()
+
+  private static let jointSpecs: [(VNHumanBodyPoseObservation.JointName, String)] = [
+    (.nose, "nose"),
+    (.leftEye, "leftEye"),
+    (.rightEye, "rightEye"),
+    (.leftEar, "leftEar"),
+    (.rightEar, "rightEar"),
+    (.leftShoulder, "leftShoulder"),
+    (.rightShoulder, "rightShoulder"),
+    (.leftElbow, "leftElbow"),
+    (.rightElbow, "rightElbow"),
+    (.leftWrist, "leftWrist"),
+    (.rightWrist, "rightWrist"),
+    (.leftHip, "leftHip"),
+    (.rightHip, "rightHip"),
+    (.leftKnee, "leftKnee"),
+    (.rightKnee, "rightKnee"),
+    (.leftAnkle, "leftAnkle"),
+    (.rightAnkle, "rightAnkle"),
+    (.neck, "neck"),
+    (.root, "root"),
+  ]
+
+  public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+    super.init(proxy: proxy, options: options)
+  }
+
+  public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any? {
+    let buffer = frame.buffer
+    let orientation = Self.cgOrientation(from: frame.orientation)
+
+    let start = CFAbsoluteTimeGetCurrent()
+    let handler = VNImageRequestHandler(
+      cmSampleBuffer: buffer,
+      orientation: orientation,
+      options: [:]
+    )
+
+    do {
+      try handler.perform([request])
+    } catch {
+      return nil
+    }
+
+    guard let observation = request.results?.first as? VNHumanBodyPoseObservation else {
+      return [
+        "joints": [] as [[String: Any]],
+        "inferenceTimeMs": (CFAbsoluteTimeGetCurrent() - start) * 1000.0,
+      ]
+    }
+
+    var joints: [[String: Any]] = []
+    joints.reserveCapacity(Self.jointSpecs.count)
+
+    for (jointName, jsName) in Self.jointSpecs {
+      guard let point = try? observation.recognizedPoint(jointName) else {
+        continue
+      }
+      // Vision uses bottom-left origin; SDK / MoveNet use top-left.
+      joints.append([
+        "name": jsName,
+        "x": Double(point.location.x),
+        "y": 1.0 - Double(point.location.y),
+        "score": Double(point.confidence),
+      ])
+    }
+
+    let elapsedMs = (CFAbsoluteTimeGetCurrent() - start) * 1000.0
+    return [
+      "joints": joints,
+      "inferenceTimeMs": elapsedMs,
+    ]
+  }
+
+  private static func cgOrientation(from orientation: Orientation) -> CGImagePropertyOrientation {
+    switch orientation {
+    case .portrait:
+      return .right
+    case .portraitUpsideDown:
+      return .left
+    case .landscapeLeft:
+      return .up
+    case .landscapeRight:
+      return .down
+    @unknown default:
+      return .right
+    }
+  }
+}

package/lib/PoseTrackerProvider.d.ts

@@ -0,0 +1,102 @@
+/**
+ * React layer: `PoseTrackerProvider` owns a `PoseTrackerClient`, and
+ * `usePoseTracker` gives screens access to the pipeline plus typed event
+ * callbacks.
+ *
+ * Recommended usage:
+ * - Mount the provider near the app root — with or without an API token
+ *   (without token, the SDK runs in keypoints-only mode).
+ * - **Mounting the provider does not load MoveNet** unless `autoPreload` is
+ *   true. On the screen *before* the camera (e.g. home), call `preload()` /
+ *   `warmup()` (default **basic** = model only, no camera permission). For
+ *   WebView, mount a 1×1 `<WebViewPoseView coldStart="basic" />` warmer so
+ *   MoveNet can load — see docs/PRELOAD.md.
+ * - Call `configure(apiToken)` at any time to upgrade keypoints-only →
+ *   full-engine without restarting the camera pipeline.
+ */
+import React from 'react';
+import { PoseTrackerClient, type PoseTrackerClientOptions, type StartExerciseOptions } from './client';
+import type { PoseInputFrame } from './backends/PoseBackend';
+import type { ExerciseConfig, SdkManifest } from './types/manifest';
+import type { PreloadOptions } from './types/preload';
+import type { ErrorEvent, PoseTrackerCallbacks, PoseTrackerEventListener, PoseTrackerMode, PoseTrackerStatus } from './types/events';
+import type { Pose } from './types/pose';
+import type { AccelerationDiagnostics, AccelerationState } from './types/acceleration';
+import type { QualityState } from './quality/AdaptiveQualityController';
+export interface PoseTrackerContextValue {
+    /**
+     * The underlying orchestrator. Escape hatch for advanced integrations
+     * (e.g. `PoseCameraView` reads the active backend and ingests poses
+     * computed in the vision-camera worklet). Stable across renders.
+     */
+    client: PoseTrackerClient;
+    status: PoseTrackerStatus;
+    /** 'keypoints-only' (no validated key/session) or 'full-engine'. */
+    mode: PoseTrackerMode;
+    /**
+     * GPU-acceleration verdict from the warm-up health check: 'unknown' until
+     * warm-up completes, then 'gpu' | 'cpu-fallback' | 'unavailable'. Can
+     * downgrade mid-session after an Android GL context loss. See
+     * docs/ANDROID_GL_ACCELERATION.md.
+     */
+    acceleration: AccelerationState;
+    /** Full GPU diagnostics (backend, timings, GL renderer, flags, downgrade trail). */
+    accelerationDiagnostics: AccelerationDiagnostics | null;
+    /**
+     * Adaptive camera-quality profile (AdaptiveChoice + crash-guard + FPS
+     * auto-downgrade). `capturePriority` reflects the host option (`performance`
+     * default vs `quality`). See docs/ADAPTIVE_QUALITY.md.
+     */
+    quality: QualityState;
+    /** Last (possibly non-fatal) error; `ready` + keypoints-only can coexist with it. */
+    error: ErrorEvent | null;
+    manifest: SdkManifest | null;
+    /** Empty in keypoints-only mode. */
+    exercises: ExerciseConfig[];
+    /**
+     * Warm-up (handshake + engine + model). Default `coldStart: 'basic'` —
+     * no getUserMedia. Pass `{ coldStart: 'full' }` to also open the camera.
+     */
+    preload: (options?: PreloadOptions) => Promise<void>;
+    /** Alias of preload(). */
+    warmup: (options?: PreloadOptions) => Promise<void>;
+    /**
+     * Hot (re)configuration: validates the token and loads the engine without
+     * touching the camera pipeline. Resolves to true on full-engine mode.
+     */
+    configure: (apiToken?: string) => Promise<boolean>;
+    /**
+     * Start an FSM exercise (manifest) or a custom one (`jump_analysis`,
+     * `air_time_jump`). Options: `difficulty`, `userHeightCm`, `devicePitchDeg`.
+     */
+    startExercise: (exerciseId: string, options?: StartExerciseOptions) => void;
+    stopExercise: () => void;
+    estimatePose: (frame: PoseInputFrame) => Promise<Pose | null>;
+    processFrame: (frame: PoseInputFrame) => Promise<Pose | null>;
+    addEventListener: (listener: PoseTrackerEventListener) => () => void;
+    /**
+     * Classic PoseTracker WebView JSON stream (`sendDataToNative` shape).
+     * Same as `usePoseTracker({ onMessage })`.
+     */
+    addMessageListener: (listener: (message: import('./events/classicMessage').ClassicNativeMessage) => void) => () => void;
+}
+export interface PoseTrackerProviderProps {
+    /** Optional: without a token the SDK runs in keypoints-only mode. */
+    apiToken?: string;
+    options?: PoseTrackerClientOptions;
+    /** Start preloading as soon as the provider mounts. Default: false. */
+    autoPreload?: boolean;
+    children: React.ReactNode;
+}
+export declare function PoseTrackerProvider({ apiToken, options, autoPreload, children, }: PoseTrackerProviderProps): React.JSX.Element;
+/**
+ * Access the PoseTracker pipeline and subscribe to typed events.
+ *
+ * ```tsx
+ * const { status, mode, processFrame, configure } = usePoseTracker({
+ *   onKeypoints: (e) => drawSkeleton(e.keypoints),   // both modes
+ *   onCounter: (e) => setReps(e.count),              // full-engine only
+ * });
+ * ```
+ */
+export declare function usePoseTracker(callbacks?: PoseTrackerCallbacks): PoseTrackerContextValue;

package/lib/PoseTrackerProvider.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoseTrackerProvider = PoseTrackerProvider;
+exports.usePoseTracker = usePoseTracker;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * React layer: `PoseTrackerProvider` owns a `PoseTrackerClient`, and
+ * `usePoseTracker` gives screens access to the pipeline plus typed event
+ * callbacks.
+ *
+ * Recommended usage:
+ * - Mount the provider near the app root — with or without an API token
+ *   (without token, the SDK runs in keypoints-only mode).
+ * - **Mounting the provider does not load MoveNet** unless `autoPreload` is
+ *   true. On the screen *before* the camera (e.g. home), call `preload()` /
+ *   `warmup()` (default **basic** = model only, no camera permission). For
+ *   WebView, mount a 1×1 `<WebViewPoseView coldStart="basic" />` warmer so
+ *   MoveNet can load — see docs/PRELOAD.md.
+ * - Call `configure(apiToken)` at any time to upgrade keypoints-only →
+ *   full-engine without restarting the camera pipeline.
+ */
+const react_1 = require("react");
+const client_1 = require("./client");
+const PoseTrackerContext = (0, react_1.createContext)(null);
+function PoseTrackerProvider({ apiToken, options, autoPreload = false, children, }) {
+    const clientRef = (0, react_1.useRef)(null);
+    if (!clientRef.current) {
+        clientRef.current = new client_1.PoseTrackerClient(apiToken, options);
+    }
+    const client = clientRef.current;
+    const [status, setStatus] = (0, react_1.useState)(client.getStatus());
+    const [mode, setMode] = (0, react_1.useState)(client.getMode());
+    const [error, setError] = (0, react_1.useState)(null);
+    const [manifest, setManifest] = (0, react_1.useState)(null);
+    const [exercises, setExercises] = (0, react_1.useState)([]);
+    const [acceleration, setAcceleration] = (0, react_1.useState)(client.getAcceleration());
+    const [accelerationDiagnostics, setAccelerationDiagnostics] = (0, react_1.useState)(client.getAccelerationDiagnostics());
+    const [quality, setQuality] = (0, react_1.useState)(client.getQualityState());
+    (0, react_1.useEffect)(() => {
+        const offState = client.onStateChange(() => {
+            setStatus(client.getStatus());
+            setMode(client.getMode());
+            setError(client.getError());
+            setManifest(client.getManifest());
+            setExercises(client.getAvailableExercises());
+            setAcceleration(client.getAcceleration());
+            setAccelerationDiagnostics(client.getAccelerationDiagnostics());
+            setQuality(client.getQualityState());
+        });
+        if (autoPreload) {
+            client.preload().catch(() => {
+                // Error is surfaced through status/error state and the error event.
+            });
+        }
+        return () => {
+            offState();
+        };
+    }, [client, autoPreload]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            client.dispose().catch(() => { });
+        };
+    }, [client]);
+    const preload = (0, react_1.useCallback)((options) => client.preload(options), [client]);
+    const configureFn = (0, react_1.useCallback)((token) => client.configure(token), [client]);
+    const startExercise = (0, react_1.useCallback)((id, exerciseOptions) => client.startExercise(id, exerciseOptions), [client]);
+    const stopExercise = (0, react_1.useCallback)(() => client.stopExercise(), [client]);
+    const estimatePose = (0, react_1.useCallback)((frame) => client.estimatePose(frame), [client]);
+    const processFrame = (0, react_1.useCallback)((frame) => client.processFrame(frame), [client]);
+    const addEventListener = (0, react_1.useCallback)((listener) => client.addEventListener(listener), [client]);
+    const addMessageListener = (0, react_1.useCallback)((listener) => client.addMessageListener(listener), [client]);
+    const value = (0, react_1.useMemo)(() => ({
+        client,
+        status,
+        mode,
+        acceleration,
+        accelerationDiagnostics,
+        quality,
+        error,
+        manifest,
+        exercises,
+        preload,
+        warmup: preload,
+        configure: configureFn,
+        startExercise,
+        stopExercise,
+        estimatePose,
+        processFrame,
+        addEventListener,
+        addMessageListener,
+    }), [
+        client,
+        status,
+        mode,
+        acceleration,
+        accelerationDiagnostics,
+        quality,
+        error,
+        manifest,
+        exercises,
+        preload,
+        configureFn,
+        startExercise,
+        stopExercise,
+        estimatePose,
+        processFrame,
+        addEventListener,
+        addMessageListener,
+    ]);
+    return (0, jsx_runtime_1.jsx)(PoseTrackerContext.Provider, { value: value, children: children });
+}
+/**
+ * Access the PoseTracker pipeline and subscribe to typed events.
+ *
+ * ```tsx
+ * const { status, mode, processFrame, configure } = usePoseTracker({
+ *   onKeypoints: (e) => drawSkeleton(e.keypoints),   // both modes
+ *   onCounter: (e) => setReps(e.count),              // full-engine only
+ * });
+ * ```
+ */
+function usePoseTracker(callbacks = {}) {
+    const context = (0, react_1.useContext)(PoseTrackerContext);
+    if (!context) {
+        throw new Error('usePoseTracker must be used within a <PoseTrackerProvider>.');
+    }
+    const callbacksRef = (0, react_1.useRef)(callbacks);
+    callbacksRef.current = callbacks;
+    (0, react_1.useEffect)(() => {
+        const offEvents = context.addEventListener((event) => {
+            const cb = callbacksRef.current;
+            switch (event.type) {
+                case 'initialization':
+                    cb.onInitialization?.(event);
+                    break;
+                case 'error':
+                    cb.onError?.(event);
+                    break;
+                case 'warning':
+                    cb.onWarning?.(event);
+                    break;
+                case 'keypoints':
+                    cb.onKeypoints?.(event);
+                    break;
+                case 'angles':
+                    cb.onAngles?.(event);
+                    break;
+                case 'counter':
+                    cb.onCounter?.(event);
+                    break;
+                case 'posture':
+                    cb.onPosture?.(event);
+                    break;
+                case 'progression':
+                    cb.onProgression?.(event);
+                    break;
+                case 'recommendations':
+                    cb.onRecommendations?.(event);
+                    break;
+                case 'form_score':
+                    cb.onFormScore?.(event);
+                    break;
+                case 'exercise_summary':
+                    cb.onExerciseSummary?.(event);
+                    break;
+                case 'jump_calibration':
+                    cb.onJumpCalibration?.(event);
+                    break;
+                case 'jump_started':
+                    cb.onJumpStarted?.(event);
+                    break;
+                case 'jump_height':
+                    cb.onJumpHeight?.(event);
+                    break;
+                case 'jump_discarded':
+                    cb.onJumpDiscarded?.(event);
+                    break;
+                case 'jump_result':
+                    cb.onJumpResult?.(event);
+                    break;
+                case 'jump_summary':
+                    cb.onJumpSummary?.(event);
+                    break;
+                case 'quality_changed':
+                    cb.onQualityChanged?.(event);
+                    break;
+                case 'performance_warning':
+                    cb.onPerformanceWarning?.(event);
+                    break;
+                case 'runtime_download_progress':
+                    cb.onRuntimeDownloadProgress?.(event);
+                    break;
+            }
+        });
+        const offMessages = context.addMessageListener((message) => {
+            callbacksRef.current.onMessage?.(message);
+        });
+        return () => {
+            offEvents();
+            offMessages();
+        };
+    }, [context]);
+    return context;
+}