@pose-tracker/pose-estimation-web 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2607 @@
+'use strict';
+
+var jsSha256 = require('js-sha256');
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_NAME = "posetracker-web";
+
+// src/api/configure.ts
+var DEFAULT_BASE_URL = "https://movelytics-strapi-c78a339b7070.herokuapp.com";
+var ConfigureError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConfigureError";
+  }
+};
+async function configure(apiToken, options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const body = {
+    ...apiToken ? { apiToken } : {},
+    sdkName: SDK_NAME,
+    sdkVersion: SDK_VERSION,
+    targetPlatform: "web",
+    poseModelProfile: options.poseModelProfile ?? "AdaptiveChoice",
+    locale: options.locale,
+    localVersions: options.localVersions
+  };
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/api/sdk/configure`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new ConfigureError("network", `Handshake request failed: ${String(err)}`);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new ConfigureError("invalid_token", "Invalid, revoked or unauthorized API token.");
+  }
+  if (response.status === 429) {
+    throw new ConfigureError("quota_exceeded", "API call quota exceeded for the current plan.");
+  }
+  if (!response.ok) {
+    throw new ConfigureError("internal", `Handshake failed with HTTP ${response.status}.`);
+  }
+  return await response.json();
+}
+var MAGIC = "ptc1:";
+function deriveCacheSecret(apiToken) {
+  return jsSha256.sha256(`posetracker-sdk-cache:${apiToken}`);
+}
+function utf8Encode(text) {
+  const escaped = unescape(encodeURIComponent(text));
+  const bytes = new Uint8Array(escaped.length);
+  for (let i = 0; i < escaped.length; i++) {
+    bytes[i] = escaped.charCodeAt(i);
+  }
+  return bytes;
+}
+function utf8Decode(bytes) {
+  let escaped = "";
+  for (let i = 0; i < bytes.length; i++) {
+    escaped += String.fromCharCode(bytes[i]);
+  }
+  return decodeURIComponent(escape(escaped));
+}
+function toHex(bytes) {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function fromHex(hex) {
+  if (hex.length % 2 !== 0 || /[^0-9a-f]/.test(hex)) {
+    return null;
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function xorWithKeystream(bytes, secret) {
+  const out = new Uint8Array(bytes.length);
+  let counter = 0;
+  let offset = 0;
+  while (offset < bytes.length) {
+    const block = jsSha256.sha256.array(`${secret}:${counter++}`);
+    for (let i = 0; i < block.length && offset < bytes.length; i++, offset++) {
+      out[offset] = bytes[offset] ^ block[i];
+    }
+  }
+  return out;
+}
+function sealString(plain, secret) {
+  return MAGIC + toHex(xorWithKeystream(utf8Encode(plain), secret));
+}
+function openString(sealed, secret) {
+  if (!sealed.startsWith(MAGIC)) {
+    return null;
+  }
+  const bytes = fromHex(sealed.slice(MAGIC.length));
+  if (!bytes) {
+    return null;
+  }
+  try {
+    return utf8Decode(xorWithKeystream(bytes, secret));
+  } catch {
+    return null;
+  }
+}
+
+// src/engine/EngineLoader.ts
+var LS_PREFIX = "posetracker.web.";
+function createLocalKeyValueStore() {
+  if (typeof localStorage === "undefined") return null;
+  return {
+    async getItem(key) {
+      try {
+        return localStorage.getItem(LS_PREFIX + key);
+      } catch {
+        return null;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        localStorage.setItem(LS_PREFIX + key, value);
+      } catch {
+      }
+    },
+    async removeItem(key) {
+      try {
+        localStorage.removeItem(LS_PREFIX + key);
+      } catch {
+      }
+    }
+  };
+}
+function createLocalFileStore() {
+  const kv = createLocalKeyValueStore();
+  if (!kv) return null;
+  return {
+    read: (key) => kv.getItem(`file.${key}`),
+    write: (key, contents) => kv.setItem(`file.${key}`, contents),
+    remove: (key) => kv.removeItem(`file.${key}`)
+  };
+}
+function createMemoryFileStore() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    async read(key) {
+      return entries.has(key) ? entries.get(key) : null;
+    },
+    async write(key, contents) {
+      entries.set(key, contents);
+    },
+    async remove(key) {
+      entries.delete(key);
+    }
+  };
+}
+function createWebFileStore() {
+  return createLocalFileStore() ?? createMemoryFileStore();
+}
+var GUARD_KEY_PREFIX = "posetracker.engine.guard.";
+var EngineLoader = class {
+  constructor(options = {}) {
+    this.lastError = null;
+    this.files = options.fileStore !== void 0 ? options.fileStore : createWebFileStore();
+    this.kv = options.keyValueStore !== void 0 ? options.keyValueStore : createLocalKeyValueStore();
+    this.fetchFn = options.fetchFn ?? fetch;
+    this.onDiagnostic = options.onDiagnostic;
+    this.onDiagnostic?.(
+      `[posetracker-web] EngineLoader fileStore=${this.files ? "yes" : "none"} kv=${this.kv ? "localStorage" : "none"}`
+    );
+  }
+  async clearGuard(descriptor) {
+    if (!descriptor || !this.kv) return;
+    const guardKey = `${GUARD_KEY_PREFIX}${descriptor.version}.${descriptor.sha256}`;
+    await this.kv.removeItem(guardKey).catch(() => {
+    });
+  }
+  async load(descriptor, cacheSecret, options) {
+    this.lastError = null;
+    if (!descriptor) {
+      this.lastError = "manifest has no engine descriptor";
+      return null;
+    }
+    const guardKey = `${GUARD_KEY_PREFIX}${descriptor.version}.${descriptor.sha256}`;
+    if (options?.forceRetry) {
+      await this.kv?.removeItem(guardKey).catch(() => {
+      });
+    }
+    const guardState = await this.kv?.getItem(guardKey);
+    if (guardState === "probing" || guardState === "failed") {
+      await this.kv?.setItem(guardKey, "failed");
+      this.lastError = `engine crash-guard blocked version=${descriptor.version} (state=${guardState}) \u2014 call configure() again to force retry`;
+      this.onDiagnostic?.(`[posetracker-web] ${this.lastError}`);
+      return null;
+    }
+    const cacheKey = `engine-${descriptor.version}.sealed`;
+    const sealed = await this.files?.read(cacheKey);
+    if (sealed !== null && sealed !== void 0) {
+      const code = openString(sealed, cacheSecret);
+      if (code !== null && jsSha256.sha256(code) === descriptor.sha256) {
+        const engine = await this.evaluate(code, guardKey);
+        if (engine) {
+          this.onDiagnostic?.(
+            `[posetracker-web] engine loaded from cache version=${descriptor.version}`
+          );
+          return { engine, source: "remote-cache" };
+        }
+      } else {
+        this.onDiagnostic?.(
+          `[posetracker-web] engine cache purged (unseal/integrity mismatch) key=${cacheKey}`
+        );
+        await this.files?.remove(cacheKey);
+      }
+    }
+    try {
+      this.onDiagnostic?.(
+        `[posetracker-web] downloading engine version=${descriptor.version}\u2026`
+      );
+      const response = await this.fetchFn(descriptor.signedUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const code = await response.text();
+      const digest = jsSha256.sha256(code);
+      if (digest !== descriptor.sha256) {
+        throw new Error(
+          `integrity check failed (got ${digest.slice(0, 12)}\u2026 expected ${descriptor.sha256.slice(0, 12)}\u2026, bytes=${code.length})`
+        );
+      }
+      const engine = await this.evaluate(code, guardKey);
+      if (engine) {
+        try {
+          await this.files?.write(cacheKey, sealString(code, cacheSecret));
+        } catch (err) {
+          this.onDiagnostic?.(
+            `[posetracker-web] engine cache write failed (non-fatal): ` + (err instanceof Error ? err.message : String(err))
+          );
+        }
+        this.onDiagnostic?.(
+          `[posetracker-web] engine loaded from download version=${descriptor.version} bytes=${code.length}`
+        );
+        return { engine, source: "remote-download" };
+      }
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      this.onDiagnostic?.(`[posetracker-web] engine download/load failed: ${this.lastError}`);
+    }
+    if (!this.lastError) {
+      this.lastError = "engine evaluate returned null";
+    }
+    return null;
+  }
+  async evaluate(code, guardKey) {
+    await this.kv?.setItem(guardKey, "probing");
+    try {
+      const moduleRef = { exports: {} };
+      const run = new Function("module", "exports", code);
+      run(moduleRef, moduleRef.exports);
+      const factory = moduleRef.exports.createEngine;
+      if (typeof factory !== "function") {
+        throw new Error(
+          `engine bundle does not export createEngine() (got ${typeof factory}, keys=${Object.keys(moduleRef.exports).join(",")})`
+        );
+      }
+      const engine = factory();
+      await this.kv?.setItem(guardKey, "passed");
+      return engine;
+    } catch (err) {
+      this.lastError = "engine evaluate failed: " + (err instanceof Error ? err.message : String(err));
+      this.onDiagnostic?.(`[posetracker-web] ${this.lastError}`);
+      await this.kv?.setItem(guardKey, "failed");
+      return null;
+    }
+  }
+};
+
+// src/api/track.ts
+var QUEUE_KEY = "posetracker.track.queue";
+var QUEUE_LIMIT = 100;
+var TrackError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TrackError";
+  }
+};
+var UsageTracker = class {
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.kv = options.keyValueStore !== void 0 ? options.keyValueStore : createLocalKeyValueStore();
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async trackMetered(request) {
+    return this.post({
+      event: request.event ?? "camera_start",
+      apiToken: request.apiToken,
+      platform: "web",
+      sdkVersion: SDK_VERSION,
+      params: request.params
+    });
+  }
+  async trackAnonymous(request = {}) {
+    const payload = {
+      event: request.event ?? "camera_start",
+      platform: "web",
+      sdkVersion: SDK_VERSION,
+      params: request.params,
+      queuedAtMs: Date.now()
+    };
+    try {
+      await this.post({ ...payload });
+      void this.flushQueue();
+    } catch {
+      await this.enqueue(payload);
+    }
+  }
+  async flushQueue() {
+    const queue = await this.readQueue();
+    if (queue.length === 0) return;
+    const remaining = [];
+    for (const item of queue) {
+      try {
+        await this.post({
+          ...item,
+          params: { ...item.params ?? {}, queuedAtMs: item.queuedAtMs }
+        });
+      } catch {
+        remaining.push(item);
+      }
+    }
+    await this.writeQueue(remaining);
+  }
+  async post(body) {
+    let response;
+    try {
+      response = await this.fetchFn(`${this.baseUrl}/api/sdk/track`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new TrackError("network", `Usage tracking request failed: ${String(err)}`);
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new TrackError("invalid_token", "Invalid, revoked or unauthorized API token.");
+    }
+    if (response.status === 429) {
+      throw new TrackError("quota_exceeded", "API call quota exceeded for the current plan.");
+    }
+    if (!response.ok) {
+      throw new TrackError("internal", `Usage tracking failed with HTTP ${response.status}.`);
+    }
+    return await response.json();
+  }
+  async readQueue() {
+    try {
+      const raw = await this.kv?.getItem(QUEUE_KEY);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async writeQueue(queue) {
+    try {
+      if (queue.length === 0) {
+        await this.kv?.removeItem(QUEUE_KEY);
+      } else {
+        await this.kv?.setItem(QUEUE_KEY, JSON.stringify(queue.slice(-QUEUE_LIMIT)));
+      }
+    } catch {
+    }
+  }
+  async enqueue(item) {
+    const queue = await this.readQueue();
+    queue.push(item);
+    await this.writeQueue(queue);
+  }
+};
+
+// src/api/skeleton.ts
+var SkeletonFetchError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SkeletonFetchError";
+  }
+};
+async function fetchSkeletonDefinition(uuid, options = {}) {
+  const id = uuid.trim();
+  if (!id || id === "true" || id === "false") {
+    throw new SkeletonFetchError("invalid", "skeleton uuid is required");
+  }
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/api/sdk/skeleton?uuid=${encodeURIComponent(id)}`);
+  } catch (err) {
+    throw new SkeletonFetchError("network", `Skeleton fetch failed: ${String(err)}`);
+  }
+  if (response.status === 404) {
+    throw new SkeletonFetchError("not_found", `Skeleton '${id}' not found`);
+  }
+  if (!response.ok) {
+    throw new SkeletonFetchError("network", `Skeleton fetch HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  if (!body?.keypoints || !body?.keypoint_lines || !body?.circles || !body?.lines) {
+    throw new SkeletonFetchError("invalid", "Skeleton payload incomplete");
+  }
+  return {
+    keypoints: body.keypoints,
+    keypoint_lines: body.keypoint_lines,
+    keypoint_angles: body.keypoint_angles ?? [],
+    circles: body.circles,
+    lines: body.lines,
+    angles: body.angles
+  };
+}
+
+// src/camera/getUserMedia.ts
+async function openCameraStream(options = {}) {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+    throw new Error("getUserMedia is not available in this environment");
+  }
+  const facingMode = options.facingMode ?? "user";
+  const constraints = {
+    audio: false,
+    video: {
+      facingMode,
+      width: options.idealWidth ? { ideal: options.idealWidth } : void 0,
+      height: options.idealHeight ? { ideal: options.idealHeight } : void 0,
+      frameRate: options.idealFrameRate ? { ideal: options.idealFrameRate } : void 0
+    }
+  };
+  try {
+    return await navigator.mediaDevices.getUserMedia(constraints);
+  } catch {
+    return navigator.mediaDevices.getUserMedia({
+      audio: false,
+      video: { facingMode }
+    });
+  }
+}
+function stopMediaStream(stream) {
+  if (!stream) return;
+  for (const track of stream.getTracks()) {
+    try {
+      track.stop();
+    } catch {
+    }
+  }
+}
+
+// src/exercises/aliases.ts
+var EXERCISE_ALIASES = {
+  face_squat: "squat",
+  face_pushup: "push_up",
+  face_plank: "plank",
+  face_lunge: "lunge",
+  face_jumping_jack: "jumping_jack",
+  face_low_impact_jack: "low_impact_jack",
+  face_balance_leg: "balance_leg",
+  face_balance_leg_left: "balance_leg_left",
+  face_balance_leg_right: "balance_leg_right",
+  jump: "air_time_jump"
+};
+function resolveExerciseName(name) {
+  return EXERCISE_ALIASES[name] ?? name;
+}
+function findExerciseByIdOrAlias(exerciseId, exercises) {
+  const exact = exercises.find((e) => e.id === exerciseId);
+  if (exact) return exact;
+  const canonical = resolveExerciseName(exerciseId);
+  const legacyIds = Object.entries(EXERCISE_ALIASES).filter(([, v3]) => v3 === canonical).map(([legacy]) => legacy);
+  for (const legacy of legacyIds) {
+    const hit = exercises.find((e) => e.id === legacy);
+    if (hit) return hit;
+  }
+  return exercises.find((e) => resolveExerciseName(e.id) === canonical);
+}
+
+// src/events/classicMessage.ts
+var ANGLE_RELATIONS = {
+  left_knee: "from_hip_to_ankle",
+  right_knee: "from_hip_to_ankle",
+  left_hip: "from_knee_to_shoulder",
+  right_hip: "from_knee_to_shoulder",
+  left_shoulder: "from_hip_to_elbow",
+  right_shoulder: "from_hip_to_elbow",
+  left_elbow: "from_shoulder_to_wrist",
+  right_elbow: "from_shoulder_to_wrist"
+};
+function anglesToClassicTree(angles) {
+  const data = {
+    left_side: {},
+    right_side: {}
+  };
+  for (const a of angles) {
+    if (a.side !== "left" && a.side !== "right") continue;
+    const side = a.side === "left" ? data.left_side : data.right_side;
+    const joint = a.id.replace(/^(left_|right_)/, "");
+    const angleType = `${joint}_angle`;
+    const relation = ANGLE_RELATIONS[a.id] ?? "value";
+    if (!side[angleType]) side[angleType] = {};
+    side[angleType][relation] = a.degrees;
+    side[angleType][`score_${relation}`] = a.score;
+  }
+  return data;
+}
+function toClassicNativeMessage(event) {
+  switch (event.type) {
+    case "initialization":
+      return {
+        type: "initialization",
+        // WebView-literal parity: TrackingAppV3 emits exactly
+        // "checking you plan and access" (sic) while the plan loads — hosts
+        // migrating from the WebView may string-match it.
+        message: event.step === "configuring" ? "checking you plan and access" : event.message ?? humanInitStep(event.step),
+        ready: event.ready,
+        step: event.step,
+        ...event.mode != null ? { mode: event.mode } : {},
+        ...event.acceleration != null ? { acceleration: event.acceleration } : {}
+      };
+    case "error":
+      return {
+        type: "error",
+        error: event.code,
+        message: event.message
+      };
+    case "warning":
+      return {
+        type: "warning",
+        error: event.code,
+        message: event.message
+      };
+    case "keypoints":
+      return {
+        type: "keypoints",
+        data: event.keypoints.map((k) => ({
+          name: k.name,
+          x: k.x,
+          y: k.y,
+          ...k.z != null ? { z: k.z } : {},
+          score: k.score
+        })),
+        score: event.score,
+        timestampMs: event.timestampMs
+      };
+    case "stats":
+      return {
+        type: "stats",
+        fps: event.fps,
+        medianInferenceMs: event.medianInferenceMs,
+        backend: event.backend,
+        keypointsAbove03: event.keypointsAbove03,
+        meanScore: event.meanScore,
+        videoSize: event.videoSize,
+        timestampMs: event.timestampMs
+      };
+    case "angles":
+      return {
+        type: "angles",
+        // WebView V3 shape: nested left_side / right_side tree (not the typed flat array).
+        data: anglesToClassicTree(event.angles),
+        timestampMs: event.timestampMs
+      };
+    case "counter":
+      return {
+        type: "counter",
+        current_count: event.count,
+        // GitBook: authoritative grade for a counted rep lives on counter.form_score.
+        ...event.formScore != null ? {
+          form_score: {
+            score: event.formScore.score,
+            avg_score: event.formScore.average,
+            grade: event.formScore.grade
+          }
+        } : {},
+        ...event.referenceScore != null ? { reference_score: { overallScore: event.referenceScore } } : {},
+        timestampMs: event.timestampMs
+      };
+    case "posture":
+      return {
+        type: "posture",
+        message: event.hint,
+        ready: event.ready,
+        direction: event.direction ?? "",
+        requirements: { missingKeypoints: event.missingKeypoints },
+        timestampMs: event.timestampMs
+      };
+    case "progression":
+      return {
+        type: "progression",
+        value: event.value,
+        timestampMs: event.timestampMs
+      };
+    case "recommendations":
+      return {
+        type: "recommendations",
+        data: event.recommendations,
+        timestampMs: event.timestampMs
+      };
+    case "form_score":
+      return {
+        type: "form_score",
+        score: event.score,
+        avg_score: event.average,
+        grade: event.grade,
+        timestampMs: event.timestampMs
+      };
+    case "exercise_summary":
+      return {
+        type: "exercise_summary",
+        exercise: event.exercise,
+        counter: event.counter,
+        avg_rep_score: event.averageFormScore,
+        avg_similarity: event.averageSimilarity,
+        grade: event.grade,
+        history: event.history,
+        durationMs: event.durationMs,
+        timestampMs: event.timestampMs
+      };
+    // Custom jump exercises: the classic contract already uses these exact
+    // type strings and camelCase field names — pass through minus timestampMs
+    // restructuring (front payloads have no timestampMs, but extra fields are
+    // harmless for string-matching hosts).
+    case "jump_calibration":
+      return {
+        type: "jump_calibration",
+        calibrated: event.calibrated,
+        cmPerPixel: event.cmPerPixel,
+        baselineY: event.baselineY,
+        visibleHips: event.visibleHips,
+        message: event.message,
+        timestampMs: event.timestampMs
+      };
+    case "jump_started":
+      return {
+        type: "jump_started",
+        message: event.message,
+        timestampMs: event.timestampMs
+      };
+    case "jump_height": {
+      const { type, timestampMs, ...rest } = event;
+      return { type, ...rest, timestampMs };
+    }
+    case "jump_discarded":
+      return {
+        type: "jump_discarded",
+        reason: event.reason,
+        userMessage: event.userMessage,
+        timestampMs: event.timestampMs
+      };
+    case "jump_result": {
+      const { type, timestampMs, ...rest } = event;
+      return { type, ...rest, timestampMs };
+    }
+    case "jump_summary": {
+      const { type, timestampMs, ...rest } = event;
+      return { type, ...rest, timestampMs };
+    }
+    case "performance_warning":
+      return {
+        type: "error",
+        error: event.code,
+        message: event.message,
+        meanFps: event.meanFps,
+        thresholdFps: event.thresholdFps,
+        activeProfile: event.activeProfile,
+        medianInferenceMs: event.medianInferenceMs,
+        videoSize: event.videoSize,
+        timestampMs: event.timestampMs
+      };
+    case "quality_changed":
+      return {
+        type: "warning",
+        error: "quality_downgraded",
+        message: event.detail,
+        previousProfile: event.previousProfile,
+        activeProfile: event.activeProfile,
+        reason: event.reason,
+        timestampMs: event.timestampMs
+      };
+    case "runtime_download_progress":
+      return {
+        type: "initialization",
+        message: `downloading pose runtime ${event.completedParts + 1}/${event.totalParts}`,
+        ready: false,
+        step: "downloading",
+        part: event.part,
+        completedParts: event.completedParts,
+        totalParts: event.totalParts,
+        timestampMs: event.timestampMs
+      };
+    default: {
+      const _exhaustive = event;
+      return { type: "unknown", event: _exhaustive };
+    }
+  }
+}
+function humanInitStep(step) {
+  switch (step) {
+    case "configuring":
+      return "checking you plan and access";
+    case "downloading":
+      return "downloading engine";
+    case "warming":
+      return "loading pose model";
+    case "ready":
+      return "running";
+    default:
+      return step;
+  }
+}
+
+// src/types/pose.ts
+var COCO_KEYPOINT_NAMES = [
+  "nose",
+  "left_eye",
+  "right_eye",
+  "left_ear",
+  "right_ear",
+  "left_shoulder",
+  "right_shoulder",
+  "left_elbow",
+  "right_elbow",
+  "left_wrist",
+  "right_wrist",
+  "left_hip",
+  "right_hip",
+  "left_knee",
+  "right_knee",
+  "left_ankle",
+  "right_ankle"
+];
+
+// src/tf/loadTf.ts
+var ONLINE_TFJS_VERSION = "4.22.0";
+var JSDELIVR = "https://cdn.jsdelivr.net/npm";
+function defaultTfjsCdnUrls(cdnBase = JSDELIVR, tfjsVersion = ONLINE_TFJS_VERSION) {
+  const base = cdnBase.replace(/\/$/, "");
+  return {
+    scriptUrls: [
+      `${base}/@tensorflow/tfjs-core@${tfjsVersion}/dist/tf-core.min.js`,
+      `${base}/@tensorflow/tfjs-converter@${tfjsVersion}/dist/tf-converter.min.js`,
+      `${base}/@tensorflow/tfjs-backend-webgl@${tfjsVersion}/dist/tf-backend-webgl.min.js`,
+      `${base}/@tensorflow/tfjs-backend-wasm@${tfjsVersion}/dist/tf-backend-wasm.min.js`
+    ],
+    wasmPath: `${base}/@tensorflow/tfjs-backend-wasm@${tfjsVersion}/dist/`
+  };
+}
+var cached = null;
+function applyProductFlags(tf) {
+  try {
+    tf.env().set("WEBGL_CPU_FORWARD", false);
+  } catch {
+  }
+  try {
+    tf.env().set("WEBGL_PACK", false);
+  } catch {
+  }
+  try {
+    tf.env().set("WEBGL_FORCE_F16_TEXTURES", false);
+  } catch {
+  }
+  try {
+    tf.env().set("WEBGL_RENDER_FLOAT32_ENABLED", false);
+  } catch {
+  }
+  try {
+    tf.env().set("WEBGL_FLUSH_THRESHOLD", 1.75);
+  } catch {
+  }
+}
+function importTfPeer() {
+  const importer = new Function("s", "return import(s)");
+  return importer("@tensorflow/tfjs");
+}
+async function resolveTf() {
+  if (cached) return cached;
+  if (typeof window !== "undefined" && window.tf) {
+    cached = window.tf;
+    return window.tf;
+  }
+  try {
+    const mod = await importTfPeer();
+    cached = mod;
+    return mod;
+  } catch {
+  }
+  throw new Error(
+    "TensorFlow.js not found. Install peer `@tensorflow/tfjs` or load CDN scripts (see README) so `window.tf` is available."
+  );
+}
+async function initWebGlBackend(tf) {
+  applyProductFlags(tf);
+  try {
+    const ok = await tf.setBackend("webgl");
+    await tf.ready();
+    if (ok !== false && tf.getBackend() === "webgl") return "webgl";
+  } catch {
+  }
+  await tf.setBackend("cpu");
+  await tf.ready();
+  return "cpu";
+}
+
+// src/tf/loadPoseDetection.ts
+var ONLINE_POSE_DETECTION_VERSION = "2.1.3";
+var JSDELIVR2 = "https://cdn.jsdelivr.net/npm";
+var cached2 = null;
+var injectPromise = null;
+function defaultPoseDetectionCdnUrl(cdnBase = JSDELIVR2, version = ONLINE_POSE_DETECTION_VERSION) {
+  const base = cdnBase.replace(/\/$/, "");
+  return `${base}/@tensorflow-models/pose-detection@${version}/dist/pose-detection.min.js`;
+}
+function importPoseDetectionPeer() {
+  const importer = new Function("s", "return import(s)");
+  return importer("@tensorflow-models/pose-detection");
+}
+function readGlobal() {
+  if (typeof window === "undefined") return null;
+  const g = window.poseDetection;
+  if (g && typeof g.createDetector === "function" && g.SupportedModels?.BlazePose) {
+    return g;
+  }
+  return null;
+}
+function injectCdnScript(url) {
+  if (typeof document === "undefined") {
+    return Promise.reject(new Error("Cannot inject pose-detection outside a browser document"));
+  }
+  const existing = readGlobal();
+  if (existing) return Promise.resolve(existing);
+  if (injectPromise) return injectPromise;
+  injectPromise = new Promise((resolve, reject) => {
+    const selector = 'script[data-pt-pose-detection="1"]';
+    const prior = document.querySelector(selector);
+    const finish = () => {
+      const mod = readGlobal();
+      if (mod) {
+        resolve(mod);
+        return;
+      }
+      reject(
+        new Error(
+          "pose-detection CDN script loaded but `window.poseDetection` is missing. Check script order (TF.js first) and network."
+        )
+      );
+    };
+    if (prior) {
+      if (prior.dataset.ptLoaded === "1") {
+        finish();
+        return;
+      }
+      prior.addEventListener("load", finish, { once: true });
+      prior.addEventListener(
+        "error",
+        () => reject(new Error(`Failed to load pose-detection from ${prior.src}`)),
+        { once: true }
+      );
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = url;
+    script.async = true;
+    script.dataset.ptPoseDetection = "1";
+    script.onload = () => {
+      script.dataset.ptLoaded = "1";
+      finish();
+    };
+    script.onerror = () => {
+      injectPromise = null;
+      reject(new Error(`Failed to load pose-detection from ${url}`));
+    };
+    document.head.appendChild(script);
+  });
+  return injectPromise;
+}
+async function resolvePoseDetection(options) {
+  if (cached2) return cached2;
+  const fromWindow = readGlobal();
+  if (fromWindow) {
+    cached2 = fromWindow;
+    return fromWindow;
+  }
+  try {
+    const mod = await importPoseDetectionPeer();
+    cached2 = mod;
+    return mod;
+  } catch {
+  }
+  const allowCdn = options?.allowCdn !== false;
+  if (allowCdn && typeof window !== "undefined" && typeof document !== "undefined") {
+    const url = defaultPoseDetectionCdnUrl(options?.cdnBase, options?.version);
+    const mod = await injectCdnScript(url);
+    cached2 = mod;
+    return mod;
+  }
+  throw new Error(
+    'BlazePose requires optional peer `@tensorflow-models/pose-detection`. Install it, load the CDN script so `window.poseDetection` exists, or use model="movenet" / pass a TF.js modelUrl.'
+  );
+}
+
+// src/models/adapters/blazepose.ts
+var BLAZE_TO_COCO = {
+  nose: "nose",
+  left_eye: "left_eye",
+  right_eye: "right_eye",
+  left_ear: "left_ear",
+  right_ear: "right_ear",
+  left_shoulder: "left_shoulder",
+  right_shoulder: "right_shoulder",
+  left_elbow: "left_elbow",
+  right_elbow: "right_elbow",
+  left_wrist: "left_wrist",
+  right_wrist: "right_wrist",
+  left_hip: "left_hip",
+  right_hip: "right_hip",
+  left_knee: "left_knee",
+  right_knee: "right_knee",
+  left_ankle: "left_ankle",
+  right_ankle: "right_ankle"
+};
+var BlazePoseAdapter = class {
+  constructor(_ctx) {
+    this.modelId = "blazepose";
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.detector = null;
+    this.backend = null;
+    this.modelType = "lite";
+  }
+  getBackend() {
+    return this.backend;
+  }
+  async load() {
+    const tf = await resolveTf();
+    this.backend = await initWebGlBackend(tf);
+    const poseDetection = await resolvePoseDetection();
+    this.detector = await poseDetection.createDetector(
+      poseDetection.SupportedModels.BlazePose,
+      {
+        runtime: "tfjs",
+        modelType: this.modelType,
+        enableSmoothing: true
+      }
+    );
+  }
+  async estimate(video, options) {
+    if (!this.detector) throw new Error("BlazePose adapter not loaded");
+    if (!(video.videoWidth > 0 && video.videoHeight > 0)) return null;
+    const t0 = performance.now();
+    const poses = await this.detector.estimatePoses(video, {
+      flipHorizontal: false,
+      maxPoses: 1
+    });
+    const inferenceMs = performance.now() - t0;
+    const pose = poses[0];
+    if (!pose?.keypoints?.length) {
+      return {
+        keypoints: COCO_KEYPOINT_NAMES.map((name) => ({ name, x: 0, y: 0, score: 0 })),
+        score: 0,
+        inferenceMs,
+        videoKeypoints: COCO_KEYPOINT_NAMES.map((name) => ({
+          name,
+          xPx: 0,
+          yPx: 0,
+          score: 0
+        })),
+        letterbox: {
+          offsetX: 0,
+          offsetY: 0,
+          drawW: video.videoWidth,
+          drawH: video.videoHeight,
+          vw: video.videoWidth,
+          vh: video.videoHeight
+        }
+      };
+    }
+    const vw = video.videoWidth || 1;
+    const vh = video.videoHeight || 1;
+    const dispW = options.displayWidth || 1;
+    const dispH = options.displayHeight || 1;
+    const byName = /* @__PURE__ */ new Map();
+    for (const kp of pose.keypoints) {
+      const name = String(kp.name || "").toLowerCase();
+      const coco = BLAZE_TO_COCO[name];
+      if (!coco) continue;
+      byName.set(coco, {
+        x: kp.x,
+        y: kp.y,
+        score: typeof kp.score === "number" ? kp.score : 0
+      });
+    }
+    const videoKeypoints = COCO_KEYPOINT_NAMES.map((name) => {
+      const k = byName.get(name);
+      return {
+        name,
+        xPx: k?.x ?? 0,
+        yPx: k?.y ?? 0,
+        score: k?.score ?? 0
+      };
+    });
+    const scale = Math.max(dispW / vw, dispH / vh);
+    const ox = (dispW - vw * scale) / 2;
+    const oy = (dispH - vh * scale) / 2;
+    let scoreSum = 0;
+    const keypoints = videoKeypoints.map((k) => {
+      const dx = k.xPx * scale + ox;
+      const dy = k.yPx * scale + oy;
+      let nx = dispW > 0 ? dx / dispW : 0;
+      const ny = dispH > 0 ? dy / dispH : 0;
+      if (options.facingMode === "user") nx = 1 - nx;
+      scoreSum += k.score;
+      return {
+        name: k.name,
+        x: Math.min(1, Math.max(0, nx)),
+        y: Math.min(1, Math.max(0, ny)),
+        score: k.score
+      };
+    });
+    return {
+      keypoints,
+      score: scoreSum / 17,
+      inferenceMs,
+      videoKeypoints,
+      letterbox: {
+        offsetX: 0,
+        offsetY: 0,
+        drawW: vw,
+        drawH: vh,
+        vw,
+        vh
+      }
+    };
+  }
+  dispose() {
+    try {
+      this.detector?.dispose?.();
+    } catch {
+    }
+    this.detector = null;
+  }
+};
+
+// src/models/adapters/movenet.ts
+var INPUT_SIZE = 192;
+var SMOOTH_ALPHA = 0.5;
+function modelNormToVideo(xNorm, yNorm, lb) {
+  const xSq = xNorm * INPUT_SIZE;
+  const ySq = yNorm * INPUT_SIZE;
+  return {
+    x: (xSq - lb.offsetX) * (lb.vw / lb.drawW),
+    y: (ySq - lb.offsetY) * (lb.vh / lb.drawH)
+  };
+}
+function videoToCover(vx, vy, dispW, dispH, lb) {
+  const scale = Math.max(dispW / lb.vw, dispH / lb.vh);
+  const ox = (dispW - lb.vw * scale) / 2;
+  const oy = (dispH - lb.vh * scale) / 2;
+  return { x: vx * scale + ox, y: vy * scale + oy };
+}
+var MoveNetGraphAdapter = class {
+  constructor(ctx) {
+    this.tf = null;
+    this.model = null;
+    this.backend = null;
+    this.offscreen = null;
+    this.offCtx = null;
+    this.smoothed = null;
+    this.letterbox = {
+      offsetX: 0,
+      offsetY: 0,
+      drawW: INPUT_SIZE,
+      drawH: INPUT_SIZE,
+      vw: 1,
+      vh: 1
+    };
+    if (!ctx.resolved.modelUrl) {
+      throw new Error(ctx.resolved.unsupportedReason ?? "MoveNet requires a modelUrl");
+    }
+    this.modelId = ctx.resolved.modelId;
+    this.modelUrl = ctx.resolved.modelUrl;
+  }
+  getBackend() {
+    return this.backend;
+  }
+  async load() {
+    this.tf = await resolveTf();
+    this.backend = await initWebGlBackend(this.tf);
+    this.model = await this.tf.loadGraphModel(this.modelUrl);
+    const z = this.tf.zeros([1, INPUT_SIZE, INPUT_SIZE, 3], "int32");
+    const out = this.model.execute(z);
+    const tensor = Array.isArray(out) ? out[0] : out;
+    tensor.dataSync();
+    z.dispose();
+    if (Array.isArray(out)) out.forEach((t) => t.dispose());
+    else out.dispose();
+  }
+  poseCanvasCtx() {
+    if (!this.offscreen) {
+      this.offscreen = document.createElement("canvas");
+      this.offscreen.width = INPUT_SIZE;
+      this.offscreen.height = INPUT_SIZE;
+      this.offCtx = this.offscreen.getContext("2d", { willReadFrequently: true });
+    }
+    if (!this.offCtx) throw new Error("2d context unavailable");
+    return this.offCtx;
+  }
+  prepareInput(video) {
+    const vw = video.videoWidth || 1;
+    const vh = video.videoHeight || 1;
+    const scale = Math.min(INPUT_SIZE / vw, INPUT_SIZE / vh);
+    const drawW = vw * scale;
+    const drawH = vh * scale;
+    const offsetX = (INPUT_SIZE - drawW) / 2;
+    const offsetY = (INPUT_SIZE - drawH) / 2;
+    this.letterbox = { offsetX, offsetY, drawW, drawH, vw, vh };
+    const c2d = this.poseCanvasCtx();
+    c2d.fillStyle = "#000";
+    c2d.fillRect(0, 0, INPUT_SIZE, INPUT_SIZE);
+    c2d.drawImage(video, 0, 0, vw, vh, offsetX, offsetY, drawW, drawH);
+    return this.offscreen;
+  }
+  smooth(raw) {
+    if (!this.smoothed) {
+      this.smoothed = raw.map((k) => ({ ...k }));
+      return this.smoothed;
+    }
+    for (let i = 0; i < raw.length; i++) {
+      if (raw[i].score < 0.1) continue;
+      this.smoothed[i].xPx = SMOOTH_ALPHA * raw[i].xPx + (1 - SMOOTH_ALPHA) * this.smoothed[i].xPx;
+      this.smoothed[i].yPx = SMOOTH_ALPHA * raw[i].yPx + (1 - SMOOTH_ALPHA) * this.smoothed[i].yPx;
+      this.smoothed[i].score = raw[i].score;
+    }
+    return this.smoothed;
+  }
+  async estimate(video, options) {
+    if (!this.tf || !this.model) throw new Error("MoveNet adapter not loaded");
+    if (!(video.videoWidth > 0 && video.videoHeight > 0)) return null;
+    const t0 = performance.now();
+    const canvas = this.prepareInput(video);
+    const input = this.tf.tidy(() => this.tf.expandDims(this.tf.browser.fromPixels(canvas), 0));
+    const out = this.model.execute(input);
+    const tensor = Array.isArray(out) ? out[0] : out;
+    const data = tensor.dataSync();
+    input.dispose();
+    if (Array.isArray(out)) out.forEach((t) => t.dispose());
+    else out.dispose();
+    const inferenceMs = performance.now() - t0;
+    const lb = this.letterbox;
+    const dispW = options.displayWidth || 1;
+    const dispH = options.displayHeight || 1;
+    const drawRaw = [];
+    let scoreSum = 0;
+    for (let i = 0; i < 17; i++) {
+      const yNorm = Math.min(1, Math.max(0, data[i * 3]));
+      const xNorm = Math.min(1, Math.max(0, data[i * 3 + 1]));
+      const score = data[i * 3 + 2];
+      const vid = modelNormToVideo(xNorm, yNorm, lb);
+      drawRaw.push({
+        name: COCO_KEYPOINT_NAMES[i],
+        xPx: vid.x,
+        yPx: vid.y,
+        score
+      });
+      scoreSum += score;
+    }
+    const sm = this.smooth(drawRaw);
+    const videoKeypoints = sm.map((k, i) => ({
+      name: COCO_KEYPOINT_NAMES[i],
+      xPx: k.xPx,
+      yPx: k.yPx,
+      score: k.score
+    }));
+    const keypoints = videoKeypoints.map((k) => {
+      const d = videoToCover(k.xPx, k.yPx, dispW, dispH, lb);
+      let nx = dispW > 0 ? d.x / dispW : 0;
+      const ny = dispH > 0 ? d.y / dispH : 0;
+      if (options.facingMode === "user") nx = 1 - nx;
+      return {
+        name: k.name,
+        x: Math.min(1, Math.max(0, nx)),
+        y: Math.min(1, Math.max(0, ny)),
+        score: k.score
+      };
+    });
+    return {
+      raw: data,
+      keypoints,
+      score: scoreSum / 17,
+      inferenceMs,
+      videoKeypoints,
+      letterbox: lb
+    };
+  }
+  dispose() {
+    try {
+      this.model?.dispose();
+    } catch {
+    }
+    this.model = null;
+    this.smoothed = null;
+    this.offscreen = null;
+    this.offCtx = null;
+  }
+};
+function mapVideoKeypointsToDisplay(videoKeypoints, letterbox, dispW, dispH) {
+  return videoKeypoints.map((k) => {
+    const d = videoToCover(k.xPx, k.yPx, dispW, dispH, letterbox);
+    return { name: k.name, dx: d.x, dy: d.y, score: k.score };
+  });
+}
+
+// src/models/adapters/createAdapter.ts
+function createPoseAdapter(ctx) {
+  const { resolved } = ctx;
+  if (resolved.kind === "unsupported" || !resolved.modelUrl && resolved.kind !== "blazepose") {
+    throw new Error(
+      resolved.unsupportedReason ?? `Model "${resolved.modelId}" is unavailable.`
+    );
+  }
+  if (resolved.kind === "blazepose") {
+    return new BlazePoseAdapter(ctx);
+  }
+  return new MoveNetGraphAdapter(ctx);
+}
+
+// src/models/poseModels.ts
+var DEFAULT_MOVENET_LIGHTNING_URL = "https://app.posetracker.com/scripts/tmp_model_to_remove.json";
+function resolvePoseModel(options = {}) {
+  const explicit = typeof options.modelUrl === "string" && options.modelUrl.trim().length > 0 ? options.modelUrl.trim() : null;
+  if (explicit) {
+    const alias = typeof options.model === "string" && options.model.trim().length > 0 ? options.model.trim() : "custom";
+    return { modelId: alias, kind: "custom-graph", modelUrl: explicit };
+  }
+  const key = (options.model ?? "movenet").trim().toLowerCase();
+  if (key === "movenet" || key === "movenet-singlepose-lightning" || key === "lightning") {
+    return {
+      modelId: "movenet-singlepose-lightning",
+      kind: "movenet-graph",
+      modelUrl: DEFAULT_MOVENET_LIGHTNING_URL
+    };
+  }
+  if (key === "blazepose") {
+    return {
+      modelId: "blazepose",
+      kind: "blazepose",
+      modelUrl: null
+    };
+  }
+  return {
+    modelId: key,
+    kind: "unsupported",
+    modelUrl: null,
+    unsupportedReason: `Unknown model "${options.model}". Use "movenet" (default), "blazepose", or pass modelUrl.`
+  };
+}
+
+// src/brand.ts
+var DEFAULT_LOADING_TEXT = "AI Loading";
+var POSETRACKER_LOGO_URL = "https://docs.posetracker.com/logo/light.png";
+var BRAND_COLORS = {
+  navy: "#010A73",
+  gold: "#FFC300",
+  bootBg: "#0a0a0a",
+  logoPad: "#3a3a3a"
+};
+
+// src/overlay/domShell.ts
+var SHELL_CSS = `
+.pt-root {
+  position: relative; width: 100%; height: 100%; min-height: 240px;
+  background: #000; overflow: hidden; isolation: isolate;
+}
+.pt-root video, .pt-root canvas.pt-overlay {
+  position: absolute; inset: 0; width: 100%; height: 100%;
+  object-fit: cover; opacity: 0; transition: opacity 180ms ease-out;
+}
+.pt-root video { z-index: 1; background: #000; }
+.pt-root canvas.pt-overlay { z-index: 2; pointer-events: none; }
+.pt-boot {
+  position: absolute; inset: 0; z-index: 4;
+  display: flex; flex-direction: column; align-items: center; justify-content: center;
+  background: #0a0a0a; color: #fff;
+  font: 15px/1.4 -apple-system, system-ui, sans-serif;
+  transition: opacity 180ms ease-out; gap: 0; padding: 24px; box-sizing: border-box;
+}
+.pt-boot.hide { opacity: 0; pointer-events: none; }
+.pt-boot .pt-boot-powered {
+  color: rgba(255,255,255,0.55); font-size: 11px; font-weight: 600;
+  letter-spacing: 0.14em; text-transform: uppercase; margin-bottom: 10px;
+}
+.pt-boot .pt-boot-logo {
+  width: min(220px, 62%); height: auto; margin-bottom: 22px; display: block;
+  box-sizing: border-box; background: #3a3a3a; padding: 14px 16px; border-radius: 10px;
+}
+.pt-boot .pt-boot-spinner {
+  width: 28px; height: 28px; margin-bottom: 16px;
+  border: 2px solid #333; border-top-color: #ffc300; border-radius: 50%;
+  animation: ptspin 0.8s linear infinite;
+}
+.pt-boot .pt-boot-msg {
+  color: #e8e8e8; font-size: 14px; font-weight: 500;
+  text-align: center; padding: 0 12px; min-height: 1.2em;
+}
+.pt-boot .pt-boot-msg.is-error { color: #FE8370; font-size: 13px; }
+@keyframes ptspin { to { transform: rotate(360deg); } }
+.pt-wm {
+  position: absolute; right: 10px; bottom: 10px; z-index: 3;
+  display: none; flex-direction: column; align-items: flex-end;
+  pointer-events: none; text-shadow: 0 1px 2px rgba(0,0,0,0.55);
+}
+.pt-wm.show { display: flex; }
+.pt-wm .pt-wm-powered {
+  color: rgba(255,255,255,0.7); font: 600 11px/1.2 -apple-system, system-ui, sans-serif;
+  letter-spacing: 0.12em; text-transform: uppercase; margin-bottom: 4px;
+}
+.pt-wm .pt-wm-logo {
+  width: 130px; height: auto; display: block; opacity: 0.92;
+  filter: drop-shadow(0 1px 2px rgba(0,0,0,0.45));
+}
+.pt-hud {
+  position: absolute; left: 8px; right: 8px; bottom: 8px; z-index: 3;
+  color: #fff; font: 11px/1.35 ui-monospace, monospace;
+  text-shadow: 0 1px 2px #000; pointer-events: none; display: none;
+}
+.pt-hud.debug { display: block; }
+.pt-placement {
+  position: absolute; z-index: 2; pointer-events: none; display: none;
+  border: 2px dashed rgba(255, 195, 0, 0.85);
+  box-sizing: border-box;
+  border-radius: 4px;
+}
+.pt-placement.show { display: block; }
+`;
+var styleInjected = false;
+function ensureStyles() {
+  if (styleInjected || typeof document === "undefined") return;
+  const el = document.createElement("style");
+  el.setAttribute("data-posetracker", "shell");
+  el.textContent = SHELL_CSS;
+  document.head.appendChild(el);
+  styleInjected = true;
+}
+function mountDomShell(host, options = {}) {
+  ensureStyles();
+  const loadingText = options.loadingText && options.loadingText.trim() || DEFAULT_LOADING_TEXT;
+  const logoUrl = options.logoUrl ?? POSETRACKER_LOGO_URL;
+  const root = document.createElement("div");
+  root.className = "pt-root";
+  root.innerHTML = `
+    <video playsinline muted autoplay></video>
+    <canvas class="pt-overlay"></canvas>
+    <div class="pt-boot">
+      <div class="pt-boot-powered">Powered by</div>
+      <img class="pt-boot-logo" alt="PoseTracker" src="${logoUrl}" />
+      <div class="pt-boot-spinner" aria-hidden="true"></div>
+      <div class="pt-boot-msg">${loadingText}</div>
+    </div>
+    <div class="pt-placement" aria-hidden="true"></div>
+    <div class="pt-wm">
+      <div class="pt-wm-powered">Powered by</div>
+      <img class="pt-wm-logo" alt="PoseTracker" src="${logoUrl}" />
+    </div>
+    <div class="pt-hud"></div>
+  `;
+  host.appendChild(root);
+  const video = root.querySelector("video");
+  const canvas = root.querySelector("canvas.pt-overlay");
+  const boot = root.querySelector(".pt-boot");
+  const bootMsg = root.querySelector(".pt-boot-msg");
+  const watermark = root.querySelector(".pt-wm");
+  const hud = root.querySelector(".pt-hud");
+  const placement = root.querySelector(".pt-placement");
+  return {
+    root,
+    video,
+    canvas,
+    boot,
+    bootMsg,
+    watermark,
+    hud,
+    placement,
+    setBootMessage(text, isError = false) {
+      bootMsg.textContent = text;
+      bootMsg.classList.toggle("is-error", isError);
+    },
+    setCameraVisible(visible) {
+      video.style.opacity = visible ? "1" : "0";
+      canvas.style.opacity = visible ? "1" : "0";
+      boot.classList.toggle("hide", visible);
+      if (!visible) {
+        bootMsg.textContent = loadingText;
+        bootMsg.classList.remove("is-error");
+      }
+    },
+    setWatermarkVisible(visible) {
+      watermark.classList.toggle("show", visible);
+    },
+    setHud(text, debug) {
+      hud.classList.toggle("debug", debug);
+      hud.textContent = text;
+    },
+    setPlacementVisible(visible, paddingPercent = 10) {
+      placement.classList.toggle("show", visible);
+      if (visible) {
+        const p = Math.max(0, Math.min(40, paddingPercent));
+        placement.style.left = `${p}%`;
+        placement.style.top = `${p}%`;
+        placement.style.right = `${p}%`;
+        placement.style.bottom = `${p}%`;
+      }
+    },
+    applyMirror(facingMode) {
+      const t = facingMode === "user" ? "scaleX(-1)" : "none";
+      video.style.transform = t;
+      canvas.style.transform = t;
+    },
+    destroy() {
+      root.remove();
+    }
+  };
+}
+
+// src/types/skeleton.ts
+var DEFAULT_SKELETON_DEFINITION = {
+  keypoints: [
+    "nose",
+    "left_eye",
+    "right_eye",
+    "left_ear",
+    "right_ear",
+    "left_shoulder",
+    "right_shoulder",
+    "left_elbow",
+    "right_elbow",
+    "left_wrist",
+    "right_wrist",
+    "left_hip",
+    "right_hip",
+    "left_knee",
+    "right_knee",
+    "left_ankle",
+    "right_ankle"
+  ],
+  keypoint_lines: [
+    "right_shoulder||left_shoulder",
+    "right_hip||left_hip",
+    "right_hip||right_shoulder",
+    "right_hip||right_knee",
+    "right_ankle||right_knee",
+    "right_shoulder||right_elbow",
+    "right_wrist||right_elbow",
+    "left_hip||left_shoulder",
+    "left_hip||left_knee",
+    "left_ankle||left_knee",
+    "left_shoulder||left_elbow",
+    "left_wrist||left_elbow"
+  ],
+  keypoint_angles: [],
+  angles: { fontColor: "#000000", strokeColor: "#FFC300" },
+  circles: {
+    circleFillColor: "#010A73",
+    circleStrokeColor: "#FFC300",
+    strokeWidth: "4",
+    radius: "8"
+  },
+  lines: { lineStrokeColor: "#010A73", strokeWidth: "4" }
+};
+
+// src/overlay/skeleton.ts
+var DEFAULT_SKELETON = DEFAULT_SKELETON_DEFINITION;
+var SKELETON_SCORE = 0.3;
+function drawSkeleton(ctx, kps, dispW, dispH, enabled = true, def) {
+  if (ctx.canvas.width !== dispW) ctx.canvas.width = dispW;
+  if (ctx.canvas.height !== dispH) ctx.canvas.height = dispH;
+  ctx.clearRect(0, 0, dispW, dispH);
+  if (!enabled) return;
+  const sk = def ?? DEFAULT_SKELETON_DEFINITION;
+  const byName = {};
+  for (const kp of kps) byName[kp.name] = kp;
+  const lineStroke = sk.lines.lineStrokeColor;
+  const lineWidth = Number(sk.lines.strokeWidth);
+  for (const edge of sk.keypoint_lines) {
+    const [aName, bName] = String(edge).split("||");
+    const a = byName[aName];
+    const b = byName[bName];
+    if (!a || !b || a.score <= SKELETON_SCORE || b.score <= SKELETON_SCORE) continue;
+    ctx.beginPath();
+    ctx.moveTo(a.dx, a.dy);
+    ctx.lineTo(b.dx, b.dy);
+    ctx.lineWidth = lineWidth;
+    ctx.strokeStyle = lineStroke;
+    ctx.stroke();
+  }
+  const fill = sk.circles.circleFillColor;
+  const stroke = sk.circles.circleStrokeColor;
+  const circleStrokeW = Number(sk.circles.strokeWidth);
+  const radius = Number(sk.circles.radius);
+  const allowed = new Set(sk.keypoints);
+  for (const kp of kps) {
+    if (!allowed.has(kp.name) || kp.score <= SKELETON_SCORE) continue;
+    ctx.beginPath();
+    ctx.arc(kp.dx, kp.dy, radius, 0, Math.PI * 2);
+    ctx.fillStyle = fill;
+    ctx.fill();
+    ctx.lineWidth = circleStrokeW;
+    ctx.strokeStyle = stroke;
+    ctx.stroke();
+  }
+}
+
+// src/types/features.ts
+var DEFAULT_FEATURES = {
+  angles: false,
+  recommendations: false,
+  progression: false,
+  keypoints: false,
+  minGrade: null
+};
+var KNOWN_FEATURE_KEYS = /* @__PURE__ */ new Set([
+  "angles",
+  "recommendations",
+  "progression",
+  "keypoints",
+  "minGrade"
+]);
+var UNSUPPORTED_FEATURE_HINTS = {
+  blazepose: 'BlazePose as a features flag (use options.model = "blazepose" instead)',
+  poseEngine: "pose engine selection (MediaPipe/PoseLandmarker)",
+  mediapipeModel: "MediaPipe model selection",
+  poseBackend: "pose backend selection",
+  runInWorker: "worker thread selection"
+};
+var FREE_PLAN_FEATURES_MESSAGE = "You cannot use developer features. (visit: https://posetracker.gitbook.io/posetracker-api/tracking-endpoint)";
+var INVALID_TOKEN_MESSAGE = "Invalid params. Please refer to the documentation and set token=YOUR API_KEY et exercise=A correct exercise. (visit: https://posetracker.gitbook.io/posetracker-api/tracking-endpoint)";
+var COMBINED_REFERENCE_EXERCISE_MESSAGE = "You cannot combine reference & exercise. Please check the documentation.";
+function featureNotSupportedMessage(key) {
+  const hint = UNSUPPORTED_FEATURE_HINTS[key] ?? `'${key}'`;
+  return `The '${key}' option (${hint}) is not available as a features flag. Remove the option, or use options.model / modelUrl for model selection. (visit: https://posetracker.gitbook.io/posetracker-api/tracking-endpoint)`;
+}
+function resolveFeatures(input) {
+  if (!input) {
+    return { features: { ...DEFAULT_FEATURES }, unsupportedKeys: [] };
+  }
+  const unsupportedKeys = Object.keys(input).filter((k) => !KNOWN_FEATURE_KEYS.has(k));
+  return {
+    features: {
+      angles: input.angles === true,
+      recommendations: input.recommendations === true,
+      progression: input.progression === true,
+      keypoints: input.keypoints === true,
+      minGrade: input.minGrade ?? null
+    },
+    unsupportedKeys
+  };
+}
+function freeBlockedFeatures(features, options) {
+  const blocked = [];
+  if (features.angles) blocked.push("angles");
+  if (features.recommendations) blocked.push("recommendations");
+  if (features.progression) blocked.push("progression");
+  if (features.keypoints && options.withExercise) blocked.push("keypoints");
+  return blocked;
+}
+function isPaidPlan(planType) {
+  return typeof planType === "string" && planType.length > 0 && planType !== "free";
+}
+function shouldShowWatermark(planType) {
+  return !isPaidPlan(planType);
+}
+
+// src/createPoseTracker.ts
+var MANIFEST_CACHE_KEY = "session.sealed";
+var ENGINE_VERSION_KEY = "engine.version";
+var SESSION_ERROR_STREAK_LIMIT = 30;
+function resolveElement(target) {
+  if (typeof target === "string") {
+    const el = document.querySelector(target);
+    if (!el) throw new Error(`PoseTracker mount target not found: ${target}`);
+    return el;
+  }
+  return target;
+}
+function median(arr) {
+  if (!arr.length) return null;
+  const s = [...arr].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)] ?? null;
+}
+function facingFromOptions(opts) {
+  if (opts.facingMode) return opts.facingMode;
+  if (opts.position === "back") return "environment";
+  return "user";
+}
+var PoseTrackerClient = class {
+  constructor(apiToken, options = {}) {
+    this.status = "idle";
+    this.mode = "keypoints-only";
+    this.lastError = null;
+    this.manifest = null;
+    this.engine = null;
+    this.engineSource = null;
+    this.session = null;
+    this.currentExerciseId = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.typedListeners = /* @__PURE__ */ new Map();
+    this.messageListeners = /* @__PURE__ */ new Set();
+    this.stateListeners = /* @__PURE__ */ new Set();
+    this.preloadPromise = null;
+    this.coldStartMode = "basic";
+    this.configurePromise = null;
+    this.handshakePromise = null;
+    this.meteredSessionState = "idle";
+    this.lastCameraStartInfo = null;
+    this.sessionErrorStreak = 0;
+    this.featureGateReported = { unsupported: false, freeBlock: false, missingToken: false };
+    this.keypointsSuppressionLogged = false;
+    this.shell = null;
+    this.stream = null;
+    this.adapter = null;
+    this.running = false;
+    this.busy = false;
+    this.loopToken = 0;
+    this.cameraRevealed = false;
+    this.disposed = false;
+    this.skeletonDef = null;
+    this.acceleration = {
+      state: "unknown",
+      runtime: "unknown",
+      backend: null,
+      glRenderer: null,
+      medianInferenceMs: null
+    };
+    this.inferMs = [];
+    this.fpsWindow = 0;
+    this.fpsTimer = 0;
+    const token = apiToken ?? (typeof options.apiToken === "string" ? options.apiToken : null) ?? null;
+    this.opts = { ...options, onDiagnostic: options.onDiagnostic };
+    this.apiToken = token;
+    const resolved = resolveFeatures(options.features);
+    this.features = resolved.features;
+    this.unsupportedFeatureKeys = resolved.unsupportedKeys;
+    this.resolved = resolvePoseModel({ model: options.model, modelUrl: options.modelUrl });
+    this.skeletonDef = options.skeletonDef ?? null;
+    this.coldStartMode = options.coldStart === "full" ? "full" : "basic";
+    this.files = options.fileStore !== void 0 ? options.fileStore : createWebFileStore();
+    this.engineLoader = options.engineLoader ?? new EngineLoader({
+      fileStore: this.files,
+      onDiagnostic: this.opts.onDiagnostic
+    });
+    this.tracker = options.usageTracker ?? new UsageTracker({ baseUrl: options.baseUrl });
+    this.opts.onDiagnostic?.(
+      `[posetracker-web] client created hasApiToken=${Boolean(this.apiToken)} features=${JSON.stringify(this.features)}`
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Introspection
+  // -------------------------------------------------------------------------
+  getStatus() {
+    return this.status;
+  }
+  getMode() {
+    return this.mode;
+  }
+  getError() {
+    return this.lastError;
+  }
+  getManifest() {
+    return this.manifest;
+  }
+  getPlanType() {
+    return this.manifest?.plan?.plan ?? null;
+  }
+  getFeatures() {
+    return { ...this.features };
+  }
+  getEngineSource() {
+    return this.engineSource;
+  }
+  getAcceleration() {
+    return this.acceleration.state;
+  }
+  getAccelerationDiagnostics() {
+    return { ...this.acceleration };
+  }
+  getResolvedModel() {
+    return this.resolved;
+  }
+  getColdStartMode() {
+    return this.coldStartMode;
+  }
+  addEventListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  on(type, listener) {
+    if (type === "*") {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    }
+    let set = this.typedListeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typedListeners.set(type, set);
+    }
+    set.add(listener);
+    return () => set.delete(listener);
+  }
+  addMessageListener(listener) {
+    this.messageListeners.add(listener);
+    return () => this.messageListeners.delete(listener);
+  }
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  // -------------------------------------------------------------------------
+  // DOM mount / camera / inference
+  // -------------------------------------------------------------------------
+  mount(target) {
+    if (this.disposed) throw new Error("PoseTracker disposed");
+    if (this.shell) this.shell.destroy();
+    const host = resolveElement(target);
+    host.innerHTML = "";
+    this.shell = mountDomShell(host, {
+      loadingText: this.opts.loadingText ?? DEFAULT_LOADING_TEXT
+    });
+    this.shell.setCameraVisible(false);
+    this.cameraRevealed = false;
+    void this.resolveSkeletonFromOptions();
+  }
+  /**
+   * Warm model (and optionally camera). Default coldStart = basic (no gUM).
+   * Alias: {@link warmup}.
+   */
+  preload(options) {
+    const mode = options?.coldStart === "full" ? "full" : "basic";
+    this.coldStartMode = mode;
+    if (this.status === "ready" && this.preloadPromise) {
+      return this.preloadPromise.then(() => this.ensureColdStartMode(mode));
+    }
+    if (!this.preloadPromise) {
+      this.preloadPromise = this.doPreload().then(() => this.ensureColdStartMode(mode)).catch((err) => {
+        this.preloadPromise = null;
+        throw err;
+      });
+    } else if (mode === "full") {
+      return this.preloadPromise.then(() => this.ensureColdStartMode("full"));
+    }
+    return this.preloadPromise;
+  }
+  warmup(options) {
+    return this.preload(options);
+  }
+  /** Mount + load model + open camera + start loop (camera-screen convenience). */
+  async start() {
+    if (this.disposed) throw new Error("PoseTracker disposed");
+    if (!this.shell) throw new Error("Call mount() before start()");
+    await this.preload({ coldStart: this.opts.coldStart === "basic" ? "basic" : "full" });
+    if (this.coldStartMode === "basic") {
+      await this.ensureColdStartMode("full");
+    }
+    this.beginLoop();
+  }
+  stop() {
+    this.running = false;
+    this.loopToken += 1;
+    this.busy = false;
+    stopMediaStream(this.stream);
+    this.stream = null;
+    if (this.shell) {
+      this.shell.video.srcObject = null;
+      this.shell.setCameraVisible(false);
+      this.shell.setPlacementVisible(false);
+      this.cameraRevealed = false;
+      this.applyWatermark();
+    }
+    if (this.status !== "error") this.setStatus("idle");
+  }
+  async dispose() {
+    this.stopExercise();
+    this.stop();
+    this.adapter?.dispose();
+    this.adapter = null;
+    this.shell?.destroy();
+    this.shell = null;
+    this.listeners.clear();
+    this.typedListeners.clear();
+    this.messageListeners.clear();
+    this.stateListeners.clear();
+    this.preloadPromise = null;
+    this.configurePromise = null;
+    this.handshakePromise = null;
+    this.meteredSessionState = "idle";
+    this.lastCameraStartInfo = null;
+    this.featureGateReported = { unsupported: false, freeBlock: false, missingToken: false };
+    this.keypointsSuppressionLogged = false;
+    this.engine = null;
+    this.engineSource = null;
+    this.manifest = null;
+    this.mode = "keypoints-only";
+    this.setStatus("idle");
+    this.disposed = true;
+  }
+  // -------------------------------------------------------------------------
+  // Configure / engine
+  // -------------------------------------------------------------------------
+  configure(apiToken) {
+    if (apiToken !== void 0 && apiToken !== this.apiToken) {
+      this.apiToken = apiToken;
+      this.opts.apiToken = apiToken;
+      this.configurePromise = null;
+      this.handshakePromise = null;
+      this.featureGateReported.freeBlock = false;
+      this.featureGateReported.missingToken = false;
+    }
+    if (this.mode !== "full-engine") {
+      this.configurePromise = null;
+    }
+    if (!this.configurePromise) {
+      this.configurePromise = this.tryConfigure({
+        silentStatus: this.status === "ready",
+        forceEngineRetry: true
+      }).then((ok) => {
+        if (!ok) this.configurePromise = null;
+        this.retryMeteredSessionIfRefused();
+        return ok;
+      }).catch(() => {
+        this.configurePromise = null;
+        return false;
+      });
+    }
+    return this.configurePromise;
+  }
+  getAvailableExercises() {
+    return this.mode === "full-engine" ? this.manifest?.exercises ?? [] : [];
+  }
+  getAvailableCustomExercises() {
+    if (this.mode !== "full-engine" || !this.engine?.listCustomExercises) return [];
+    return this.engine.listCustomExercises();
+  }
+  startExercise(exerciseId, options = {}) {
+    if (this.status !== "ready") {
+      throw new Error(`Cannot start exercise while status is '${this.status}' \u2014 call preload()/start() first.`);
+    }
+    if (this.mode !== "full-engine" || !this.engine) {
+      throw new Error(
+        "Exercises require full-engine mode (validated API key). The SDK is running keypoints-only \u2014 call configure(apiToken) first."
+      );
+    }
+    if (this.meteredSessionState === "refused") {
+      throw new Error(
+        "API-key features are not available offline: PoseTracker could not track this session. Reconnect and retry."
+      );
+    }
+    if (this.unsupportedFeatureKeys.length > 0) {
+      const message = featureNotSupportedMessage(this.unsupportedFeatureKeys[0]);
+      this.reportError({ type: "error", code: "feature_not_supported", message });
+      throw new Error(message);
+    }
+    if (this.getPlanType() === "free") {
+      const blocked = freeBlockedFeatures(this.features, { withExercise: true });
+      if (blocked.length > 0) {
+        this.reportError({
+          type: "error",
+          code: "free_plan_feature_blocked",
+          message: FREE_PLAN_FEATURES_MESSAGE
+        });
+        throw new Error(FREE_PLAN_FEATURES_MESSAGE);
+      }
+    }
+    const available = this.getAvailableExercises();
+    const exercise = findExerciseByIdOrAlias(exerciseId, available);
+    if (!exercise) {
+      const customs = this.getAvailableCustomExercises();
+      const custom = customs.find((e) => e.id === exerciseId) ?? findExerciseByIdOrAlias(exerciseId, customs);
+      if (custom) {
+        this.startCustomExercise(custom, options);
+        return;
+      }
+      const message = `Exercise '${exerciseId}' is not available in V3 engine`;
+      this.reportError({ type: "error", code: "invalid_exercise", message });
+      throw new Error(message);
+    }
+    this.stopExercise();
+    this.currentExerciseId = exerciseId;
+    this.keypointsSuppressionLogged = false;
+    this.session = this.engine.createSession(
+      {
+        exercise,
+        locale: this.opts.locale ?? "en",
+        difficulty: options.difficulty,
+        minGrade: this.features.minGrade ?? void 0,
+        features: {
+          angles: this.features.angles,
+          recommendations: this.features.recommendations,
+          progression: this.features.progression
+        }
+      },
+      (event) => this.emitFromSession(event)
+    );
+  }
+  startCustomExercise(custom, options) {
+    if (!this.engine?.createCustomSession) {
+      throw new Error(
+        `The cached engine bundle is too old for custom exercise '${custom.id}' \u2014 reconnect so the SDK can update it.`
+      );
+    }
+    if (custom.id === "jump_analysis" && (!options.userHeightCm || options.userHeightCm <= 0)) {
+      const message = "User height (userHeightCm) must be provided for jump_analysis exercise";
+      this.reportError({ type: "error", code: "jump_analysis_missing_height", message });
+      throw new Error(message);
+    }
+    this.stopExercise();
+    this.currentExerciseId = custom.id;
+    this.keypointsSuppressionLogged = false;
+    this.session = this.engine.createCustomSession(
+      {
+        exerciseId: custom.id,
+        locale: this.opts.locale ?? "en",
+        userHeightCm: options.userHeightCm,
+        devicePitchDeg: options.devicePitchDeg
+      },
+      (event) => this.emitFromSession(event)
+    );
+  }
+  stopExercise() {
+    try {
+      this.session?.end();
+    } catch (err) {
+      this.opts.onDiagnostic?.(
+        "[posetracker-web] engine session end() threw: " + (err instanceof Error ? err.message : String(err))
+      );
+    }
+    this.session = null;
+    this.currentExerciseId = null;
+    this.sessionErrorStreak = 0;
+    this.shell?.setPlacementVisible(false);
+  }
+  getCurrentExerciseId() {
+    return this.currentExerciseId;
+  }
+  fetchSkeleton(uuid) {
+    return fetchSkeletonDefinition(uuid, { baseUrl: this.opts.baseUrl });
+  }
+  async setModel(model, modelUrl) {
+    const wasRunning = this.running;
+    if (wasRunning) {
+      this.running = false;
+      this.loopToken += 1;
+      this.busy = false;
+    }
+    this.adapter?.dispose();
+    this.adapter = null;
+    if (model !== void 0) this.opts.model = model;
+    if (modelUrl !== void 0) this.opts.modelUrl = modelUrl;
+    this.resolved = resolvePoseModel({ model: this.opts.model, modelUrl: this.opts.modelUrl });
+    await this.ensureAdapter();
+    if (wasRunning) this.beginLoop();
+  }
+  updateOptions(partial) {
+    this.opts = { ...this.opts, ...partial };
+    if (partial.skeletonDef !== void 0) this.skeletonDef = partial.skeletonDef;
+    if (partial.skeletonUuid) void this.resolveSkeletonFromOptions();
+    this.applyWatermark();
+    if (this.shell && (partial.facingMode || partial.position)) {
+      this.shell.applyMirror(facingFromOptions(this.opts));
+    }
+  }
+  ingestPose(pose) {
+    if (!this.session || this.features.keypoints) {
+      this.emit({
+        type: "keypoints",
+        keypoints: pose.keypoints,
+        score: pose.score,
+        timestampMs: pose.timestampMs
+      });
+    } else if (!this.keypointsSuppressionLogged) {
+      this.keypointsSuppressionLogged = true;
+      this.opts.onDiagnostic?.(
+        "[posetracker-web] keypoints events paused during exercise (features.keypoints=false)"
+      );
+    }
+    if (this.session) {
+      try {
+        this.session.processPose(pose);
+        this.sessionErrorStreak = 0;
+      } catch (err) {
+        this.sessionErrorStreak += 1;
+        const message = err instanceof Error ? err.message : String(err);
+        if (this.sessionErrorStreak === 1) {
+          this.opts.onDiagnostic?.(`[posetracker-web] processPose threw: ${message}`);
+        }
+        if (this.sessionErrorStreak >= SESSION_ERROR_STREAK_LIMIT) {
+          const exerciseId = this.currentExerciseId;
+          this.session = null;
+          this.currentExerciseId = null;
+          this.sessionErrorStreak = 0;
+          this.reportError({
+            type: "error",
+            code: "internal",
+            message: `Exercise session '${exerciseId ?? "?"}' failed repeatedly (${message}) \u2014 session stopped.`
+          });
+        }
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  async doPreload() {
+    this.setStatus("configuring");
+    await this.resolveManifestOnce();
+    this.setStatus("downloading");
+    await this.tryConfigure({ silentStatus: true });
+    void this.tracker.flushQueue();
+    try {
+      this.setStatus("warming");
+      await this.ensureAdapter();
+      this.acceleration = {
+        ...this.acceleration,
+        state: "gpu",
+        runtime: "tfjs-webgl",
+        backend: "webgl"
+      };
+    } catch (err) {
+      this.reportError({
+        type: "error",
+        code: "model_load_failed",
+        message: err instanceof Error ? err.message : String(err)
+      });
+      this.setStatus("error");
+      throw err;
+    }
+    this.setStatus("ready");
+    this.emit({
+      type: "initialization",
+      step: "ready",
+      message: "running",
+      ready: true,
+      mode: this.mode,
+      acceleration: this.getAcceleration()
+    });
+  }
+  async ensureColdStartMode(mode) {
+    if (mode !== "full") return;
+    if (!this.shell) return;
+    await this.ensureCamera();
+  }
+  async ensureAdapter() {
+    if (this.adapter) return;
+    this.resolved = resolvePoseModel({ model: this.opts.model, modelUrl: this.opts.modelUrl });
+    if (this.resolved.kind === "unsupported") {
+      throw new Error(this.resolved.unsupportedReason ?? "Unsupported model");
+    }
+    this.emit({
+      type: "initialization",
+      step: "loading_pose_model",
+      message: "loading pose model",
+      ready: false
+    });
+    this.adapter = createPoseAdapter({ resolved: this.resolved });
+    await this.adapter.load();
+  }
+  async ensureCamera() {
+    if (!this.shell) throw new Error("Call mount() before opening the camera");
+    if (this.stream) return;
+    this.emit({
+      type: "initialization",
+      step: "accessing_webcam",
+      message: "accessing webcam",
+      ready: false
+    });
+    try {
+      this.stream = await openCameraStream({
+        facingMode: facingFromOptions(this.opts),
+        idealWidth: this.opts.idealWidth,
+        idealHeight: this.opts.idealHeight
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const denied = /NotAllowed|Permission|denied/i.test(msg);
+      this.reportError({
+        type: "error",
+        code: denied ? "camera_denied" : "camera_unavailable",
+        message: msg
+      });
+      this.shell.setBootMessage(
+        denied ? "Camera permission denied \u2014 allow access in the browser" : "Camera unavailable",
+        true
+      );
+      throw err;
+    }
+    this.shell.video.srcObject = this.stream;
+    this.shell.applyMirror(facingFromOptions(this.opts));
+    try {
+      await this.shell.video.play();
+    } catch {
+    }
+    const started = Date.now();
+    const tick = () => {
+      this.revealCamera();
+      if (this.cameraRevealed) return;
+      if (Date.now() - started > 8e3) {
+        this.shell?.setBootMessage(
+          "camera started but preview is empty \u2014 check permissions",
+          true
+        );
+        return;
+      }
+      setTimeout(tick, 120);
+    };
+    setTimeout(tick, 60);
+    void this.handleCameraStart({
+      backend: this.acceleration.backend ?? "webgl",
+      profileId: null
+    });
+  }
+  beginLoop() {
+    this.running = true;
+    this.fpsTimer = performance.now();
+    void this.loop(++this.loopToken);
+  }
+  async loop(token) {
+    if (token !== this.loopToken || !this.running || !this.adapter || !this.shell || this.disposed) {
+      return;
+    }
+    const video = this.shell.video;
+    if (!this.busy && video.readyState >= 2 && video.videoWidth > 0) {
+      this.busy = true;
+      try {
+        const dispW = this.shell.canvas.clientWidth || this.shell.root.clientWidth || 1;
+        const dispH = this.shell.canvas.clientHeight || this.shell.root.clientHeight || 1;
+        const result = await this.adapter.estimate(video, {
+          facingMode: facingFromOptions(this.opts),
+          displayWidth: dispW,
+          displayHeight: dispH
+        });
+        if (result) {
+          const ctx = this.shell.canvas.getContext("2d");
+          if (ctx && this.opts.drawSkeleton !== false) {
+            const mapped = mapVideoKeypointsToDisplay(
+              result.videoKeypoints,
+              result.letterbox,
+              dispW,
+              dispH
+            );
+            drawSkeleton(ctx, mapped, dispW, dispH, true, this.skeletonDef);
+          } else if (ctx && this.opts.drawSkeleton === false) {
+            ctx.clearRect(0, 0, dispW, dispH);
+          }
+          const pose = {
+            keypoints: result.keypoints,
+            score: result.score,
+            timestampMs: Date.now()
+          };
+          this.ingestPose(pose);
+          this.inferMs.push(result.inferenceMs);
+          if (this.inferMs.length > 30) this.inferMs.shift();
+          this.fpsWindow += 1;
+          const now = performance.now();
+          if (now - this.fpsTimer >= 1e3) {
+            const fps = this.fpsWindow;
+            this.fpsWindow = 0;
+            this.fpsTimer = now;
+            const med = median(this.inferMs);
+            this.acceleration.medianInferenceMs = med;
+            const above = result.keypoints.filter((k) => k.score >= 0.3).length;
+            const backend = "getBackend" in this.adapter && typeof this.adapter.getBackend === "function" ? this.adapter.getBackend() : null;
+            this.acceleration.backend = backend;
+            if (this.opts.debugHud) {
+              this.shell.setHud(
+                `${this.resolved.modelId} \xB7 ${backend ?? "?"} \xB7 ${fps} fps \xB7 ${med != null ? Math.round(med) + " ms" : "?"} \xB7 kp\u22650.3=${above}/17`,
+                true
+              );
+            }
+            this.emit({
+              type: "stats",
+              fps,
+              medianInferenceMs: med,
+              backend,
+              keypointsAbove03: above,
+              meanScore: result.score,
+              videoSize: `${video.videoWidth}x${video.videoHeight}`,
+              timestampMs: Date.now()
+            });
+          }
+        }
+        this.revealCamera();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.emit({ type: "error", code: "internal", message: `inference: ${message}` });
+      }
+      this.busy = false;
+    }
+    requestAnimationFrame(() => {
+      void this.loop(token);
+    });
+  }
+  async resolveSkeletonFromOptions() {
+    if (this.opts.skeletonDef) {
+      this.skeletonDef = this.opts.skeletonDef;
+      return;
+    }
+    const uuid = this.opts.skeletonUuid?.trim();
+    if (!uuid || uuid === "true" || uuid === "false") {
+      this.skeletonDef = null;
+      return;
+    }
+    try {
+      this.skeletonDef = await this.fetchSkeleton(uuid);
+    } catch {
+      this.skeletonDef = null;
+    }
+  }
+  resolveManifestOnce() {
+    if (!this.handshakePromise) {
+      this.handshakePromise = this.doResolveManifestOnce().then((manifest) => {
+        if (!manifest) this.handshakePromise = null;
+        return manifest;
+      });
+    }
+    return this.handshakePromise;
+  }
+  async doResolveManifestOnce() {
+    const localVersions = {
+      poseRuntime: null,
+      engine: await this.files?.read(ENGINE_VERSION_KEY).catch(() => null) ?? null
+    };
+    if (this.apiToken) {
+      const manifest = await this.resolveManifest(this.apiToken, localVersions);
+      if (manifest) {
+        this.manifest = manifest;
+        if (manifest.revoked === true) {
+          await this.handleRevocation("Access revoked by the backend.");
+        }
+      }
+      return manifest;
+    }
+    try {
+      const manifest = await configure(null, { ...this.opts, localVersions });
+      this.manifest = manifest;
+      return manifest;
+    } catch {
+      return null;
+    }
+  }
+  async handleRevocation(message) {
+    const engineVersion = await this.files?.read(ENGINE_VERSION_KEY).catch(() => null);
+    if (engineVersion) {
+      await this.files?.remove(`engine-${engineVersion}.sealed`).catch(() => {
+      });
+      await this.files?.remove(ENGINE_VERSION_KEY).catch(() => {
+      });
+    }
+    await this.files?.remove(MANIFEST_CACHE_KEY).catch(() => {
+    });
+    this.engine = null;
+    this.engineSource = null;
+    this.stopExercise();
+    this.setMode("keypoints-only");
+    this.reportError({ type: "error", code: "invalid_token", message });
+    this.applyWatermark();
+  }
+  async handleCameraStart(info) {
+    this.lastCameraStartInfo = info;
+    const params = {
+      backend: info.backend,
+      profileId: info.profileId,
+      poseModelProfile: this.opts.poseModelProfile ?? "AdaptiveChoice",
+      mode: this.mode,
+      exercise: this.currentExerciseId,
+      model: this.opts.model ?? "movenet",
+      modelUrl: this.opts.modelUrl ?? null
+    };
+    if (!this.apiToken) {
+      void this.tracker.trackAnonymous({ event: "camera_start", params });
+      return;
+    }
+    this.meteredSessionState = "pending";
+    try {
+      await this.tracker.trackMetered({
+        event: "camera_start",
+        apiToken: this.apiToken,
+        params
+      });
+      this.meteredSessionState = "validated";
+      this.opts.onDiagnostic?.("[posetracker-web] camera_start tracked (metered)");
+    } catch (err) {
+      this.meteredSessionState = "refused";
+      if (err instanceof TrackError && err.code === "network") {
+        this.reportError({
+          type: "error",
+          code: "offline_metered",
+          message: "API-key features are not available offline: PoseTracker cannot count their usage. Keypoints-only keeps running."
+        });
+      } else if (err instanceof TrackError && err.code === "invalid_token") {
+        await this.handleRevocation("API key invalid or revoked \u2014 engine cache purged.");
+      } else if (err instanceof TrackError && err.code === "quota_exceeded") {
+        this.reportError({ type: "error", code: "quota_exceeded", message: err.message });
+      } else {
+        this.reportError({
+          type: "error",
+          code: "internal",
+          message: `Usage tracking failed: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  retryMeteredSessionIfRefused() {
+    if (this.meteredSessionState === "refused" && this.apiToken && this.lastCameraStartInfo) {
+      void this.handleCameraStart(this.lastCameraStartInfo);
+    }
+  }
+  async tryConfigure({
+    silentStatus,
+    forceEngineRetry = false
+  }) {
+    if (this.mode === "full-engine") return true;
+    if (!this.apiToken) {
+      this.validateRequestedFeatures();
+      this.setMode("keypoints-only");
+      this.applyWatermark();
+      return false;
+    }
+    const manifest = await this.resolveManifestOnce();
+    if (!manifest || manifest.revoked === true) {
+      this.setMode("keypoints-only");
+      this.applyWatermark();
+      return false;
+    }
+    this.manifest = manifest;
+    this.validateRequestedFeatures();
+    if (!silentStatus) this.setStatus("downloading");
+    const secret = deriveCacheSecret(this.apiToken);
+    if (forceEngineRetry && manifest.engine) {
+      await this.engineLoader.clearGuard(manifest.engine);
+    }
+    const result = await this.engineLoader.load(manifest.engine ?? null, secret, {
+      forceRetry: forceEngineRetry
+    });
+    if (!result) {
+      const detail = this.engineLoader.lastError;
+      this.reportError({
+        type: "error",
+        code: "engine_load_failed",
+        message: detail ? `Engine bundle unavailable \u2014 ${detail}` : "Engine bundle unavailable \u2014 running keypoints-only."
+      });
+      this.setMode("keypoints-only");
+      this.applyWatermark();
+      return false;
+    }
+    this.engine = result.engine;
+    this.engineSource = result.source;
+    if (manifest.engine?.version) {
+      await this.files?.write(ENGINE_VERSION_KEY, manifest.engine.version).catch(() => {
+      });
+    }
+    this.setMode("full-engine");
+    this.applyWatermark();
+    return true;
+  }
+  async resolveManifest(apiToken, localVersions) {
+    const secret = deriveCacheSecret(apiToken);
+    try {
+      const manifest = await configure(apiToken, { ...this.opts, localVersions });
+      await this.files?.write(MANIFEST_CACHE_KEY, sealString(JSON.stringify(manifest), secret)).catch(() => {
+      });
+      return manifest;
+    } catch (err) {
+      if (err instanceof ConfigureError && err.code === "invalid_token") {
+        await this.handleRevocation(err.message);
+        return null;
+      }
+      if (err instanceof ConfigureError && err.code === "quota_exceeded") {
+        this.reportError({ type: "error", code: "quota_exceeded", message: err.message });
+        return null;
+      }
+      const sealed = await this.files?.read(MANIFEST_CACHE_KEY);
+      if (sealed) {
+        const plain = openString(sealed, secret);
+        if (plain) {
+          try {
+            return JSON.parse(plain);
+          } catch {
+            await this.files?.remove(MANIFEST_CACHE_KEY).catch(() => {
+            });
+          }
+        }
+      }
+      this.reportError({
+        type: "error",
+        code: "network",
+        message: "Handshake unreachable and no cached session \u2014 running keypoints-only."
+      });
+      return null;
+    }
+  }
+  validateRequestedFeatures() {
+    if (this.unsupportedFeatureKeys.length > 0 && !this.featureGateReported.unsupported) {
+      this.featureGateReported.unsupported = true;
+      this.reportError({
+        type: "error",
+        code: "feature_not_supported",
+        message: featureNotSupportedMessage(this.unsupportedFeatureKeys[0])
+      });
+    }
+    const f = this.features;
+    const requestsDevFeatures = f.angles || f.recommendations || f.progression || f.keypoints;
+    if (!requestsDevFeatures) return;
+    if (!this.apiToken) {
+      if (!this.featureGateReported.missingToken) {
+        this.featureGateReported.missingToken = true;
+        this.reportError({ type: "error", code: "invalid_token", message: INVALID_TOKEN_MESSAGE });
+      }
+      return;
+    }
+    if (this.getPlanType() === "free") {
+      const blocked = freeBlockedFeatures(f, { withExercise: false });
+      if (blocked.length > 0 && !this.featureGateReported.freeBlock) {
+        this.featureGateReported.freeBlock = true;
+        this.reportError({
+          type: "error",
+          code: "free_plan_feature_blocked",
+          message: FREE_PLAN_FEATURES_MESSAGE
+        });
+      }
+    }
+  }
+  emitFromSession(event) {
+    if (event.type === "angles" && !this.features.angles) return;
+    if (event.type === "recommendations" && !this.features.recommendations) return;
+    if (event.type === "progression" && !this.features.progression) return;
+    if (event.type === "posture") {
+      const draw = this.opts.drawPlacementBox !== false;
+      this.shell?.setPlacementVisible(draw && !event.ready, this.opts.placementPaddingPercent ?? 10);
+    } else if (event.type === "exercise_summary") {
+      this.shell?.setPlacementVisible(false);
+    }
+    this.emit(event);
+  }
+  watermarkOn() {
+    if (typeof this.opts.showWatermark === "boolean") return this.opts.showWatermark;
+    if (this.coldStartMode === "basic" && !this.stream) return false;
+    return shouldShowWatermark(this.getPlanType());
+  }
+  applyWatermark() {
+    this.shell?.setWatermarkVisible(this.watermarkOn() && this.cameraRevealed);
+  }
+  revealCamera() {
+    if (!this.shell || this.cameraRevealed) return;
+    const v = this.shell.video;
+    if (!(v.videoWidth > 0 && v.videoHeight > 0)) return;
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        if (this.cameraRevealed || !this.shell) return;
+        if (!(this.shell.video.videoWidth > 0)) return;
+        this.cameraRevealed = true;
+        this.shell.setCameraVisible(true);
+        this.applyWatermark();
+      });
+    });
+  }
+  setStatus(status) {
+    this.status = status;
+    if (status === "configuring" || status === "downloading" || status === "warming") {
+      this.emit({
+        type: "initialization",
+        step: status,
+        message: status === "configuring" ? "checking you plan and access" : status === "downloading" ? "downloading engine" : "loading pose model",
+        ready: false
+      });
+    }
+    this.notifyState();
+  }
+  setMode(mode) {
+    if (this.mode !== mode) {
+      this.mode = mode;
+      this.notifyState();
+    }
+  }
+  reportError(error) {
+    this.lastError = error;
+    this.emit(error);
+    this.notifyState();
+  }
+  notifyState() {
+    this.stateListeners.forEach((l) => {
+      try {
+        l();
+      } catch {
+      }
+    });
+  }
+  emit(event) {
+    this.listeners.forEach((l) => {
+      try {
+        l(event);
+      } catch (err) {
+        this.opts.onDiagnostic?.(
+          `[posetracker-web] listener threw on '${event.type}': ` + (err instanceof Error ? err.message : String(err))
+        );
+      }
+    });
+    const typed = this.typedListeners.get(event.type);
+    typed?.forEach((l) => {
+      try {
+        l(event);
+      } catch {
+      }
+    });
+    const any = this.typedListeners.get("*");
+    any?.forEach((l) => {
+      try {
+        l(event);
+      } catch {
+      }
+    });
+    if (this.messageListeners.size === 0) return;
+    const classic = toClassicNativeMessage(event);
+    this.messageListeners.forEach((l) => {
+      try {
+        l(classic);
+      } catch {
+      }
+    });
+  }
+};
+function createPoseTracker(options = {}) {
+  return new PoseTrackerClient(options.apiToken, options);
+}
+function PoseCamera_mount(target, options = {}) {
+  const pt = createPoseTracker(options);
+  pt.mount(target);
+  return pt;
+}
+var PoseCamera = {
+  mount: PoseCamera_mount
+};
+
+exports.BRAND_COLORS = BRAND_COLORS;
+exports.BlazePoseAdapter = BlazePoseAdapter;
+exports.COCO_KEYPOINT_NAMES = COCO_KEYPOINT_NAMES;
+exports.COMBINED_REFERENCE_EXERCISE_MESSAGE = COMBINED_REFERENCE_EXERCISE_MESSAGE;
+exports.ConfigureError = ConfigureError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
+exports.DEFAULT_LOADING_TEXT = DEFAULT_LOADING_TEXT;
+exports.DEFAULT_MOVENET_LIGHTNING_URL = DEFAULT_MOVENET_LIGHTNING_URL;
+exports.DEFAULT_SKELETON = DEFAULT_SKELETON;
+exports.DEFAULT_SKELETON_DEFINITION = DEFAULT_SKELETON_DEFINITION;
+exports.EXERCISE_ALIASES = EXERCISE_ALIASES;
+exports.EngineLoader = EngineLoader;
+exports.FREE_PLAN_FEATURES_MESSAGE = FREE_PLAN_FEATURES_MESSAGE;
+exports.INVALID_TOKEN_MESSAGE = INVALID_TOKEN_MESSAGE;
+exports.MoveNetGraphAdapter = MoveNetGraphAdapter;
+exports.ONLINE_POSE_DETECTION_VERSION = ONLINE_POSE_DETECTION_VERSION;
+exports.ONLINE_TFJS_VERSION = ONLINE_TFJS_VERSION;
+exports.POSETRACKER_LOGO_URL = POSETRACKER_LOGO_URL;
+exports.PoseCamera = PoseCamera;
+exports.PoseCamera_mount = PoseCamera_mount;
+exports.PoseTrackerClient = PoseTrackerClient;
+exports.SDK_NAME = SDK_NAME;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SkeletonFetchError = SkeletonFetchError;
+exports.TrackError = TrackError;
+exports.UsageTracker = UsageTracker;
+exports.configure = configure;
+exports.createLocalFileStore = createLocalFileStore;
+exports.createLocalKeyValueStore = createLocalKeyValueStore;
+exports.createMemoryFileStore = createMemoryFileStore;
+exports.createPoseAdapter = createPoseAdapter;
+exports.createPoseTracker = createPoseTracker;
+exports.createWebFileStore = createWebFileStore;
+exports.defaultPoseDetectionCdnUrl = defaultPoseDetectionCdnUrl;
+exports.defaultTfjsCdnUrls = defaultTfjsCdnUrls;
+exports.drawSkeleton = drawSkeleton;
+exports.featureNotSupportedMessage = featureNotSupportedMessage;
+exports.fetchSkeletonDefinition = fetchSkeletonDefinition;
+exports.findExerciseByIdOrAlias = findExerciseByIdOrAlias;
+exports.freeBlockedFeatures = freeBlockedFeatures;
+exports.initWebGlBackend = initWebGlBackend;
+exports.isPaidPlan = isPaidPlan;
+exports.mapVideoKeypointsToDisplay = mapVideoKeypointsToDisplay;
+exports.mountDomShell = mountDomShell;
+exports.openCameraStream = openCameraStream;
+exports.resolveExerciseName = resolveExerciseName;
+exports.resolveFeatures = resolveFeatures;
+exports.resolvePoseDetection = resolvePoseDetection;
+exports.resolvePoseModel = resolvePoseModel;
+exports.resolveTf = resolveTf;
+exports.shouldShowWatermark = shouldShowWatermark;
+exports.stopMediaStream = stopMediaStream;
+exports.toClassicNativeMessage = toClassicNativeMessage;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map