technogym-js 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1016 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APP_ID: () => APP_ID,
+  APP_NAME: () => APP_NAME,
+  CORE_URL: () => CORE_URL,
+  CUMULATIVE_CHANNELS: () => CUMULATIVE_CHANNELS,
+  FileSessionStore: () => FileSessionStore,
+  MemorySessionStore: () => MemorySessionStore,
+  SERVICES_URL: () => SERVICES_URL,
+  SETPOINT_CHANNELS: () => SETPOINT_CHANNELS,
+  Technogym: () => Technogym,
+  TechnogymApiError: () => TechnogymApiError,
+  TechnogymAuthError: () => TechnogymAuthError,
+  TechnogymClient: () => TechnogymClient,
+  TechnogymConnectionError: () => TechnogymConnectionError,
+  TechnogymError: () => TechnogymError,
+  TechnogymHttpError: () => TechnogymHttpError,
+  TechnogymNotFoundError: () => TechnogymNotFoundError,
+  TechnogymRateLimitError: () => TechnogymRateLimitError,
+  channelStats: () => channelStats,
+  downsample: () => downsample,
+  isAuthErrorEntry: () => isAuthErrorEntry,
+  parseExercise: () => parseExercise,
+  parseExerciseAnalytics: () => parseExerciseAnalytics,
+  parseHrSession: () => parseHrSession,
+  parseProperties: () => parseProperties,
+  parseSessionSummary: () => parseSessionSummary,
+  parseUser: () => parseUser,
+  parseWorkoutSession: () => parseWorkoutSession,
+  segmentAnalytics: () => segmentAnalytics,
+  windowSamples: () => windowSamples
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var TechnogymError = class extends Error {
+  /** `options.cause` is the underlying error, if any. */
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    Error.captureStackTrace?.(this, new.target);
+  }
+};
+var TechnogymAuthError = class extends TechnogymError {
+};
+var TechnogymConnectionError = class extends TechnogymError {
+};
+var TechnogymRateLimitError = class extends TechnogymError {
+  /** Thrown by the transport on a 429. */
+  constructor(message, retryAfter, options) {
+    super(message, options);
+    this.retryAfter = retryAfter;
+  }
+  retryAfter;
+};
+var TechnogymHttpError = class extends TechnogymError {
+  /** Thrown by the transport for a non-2xx response that no other error class covers. */
+  constructor(message, status, url, body, options) {
+    super(message, options);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+  status;
+  url;
+  body;
+};
+var TechnogymApiError = class extends TechnogymError {
+  /** Thrown when a 200 response's envelope carries errors. */
+  constructor(message, action, errors, options) {
+    super(message, options);
+    this.action = action;
+    this.errors = errors;
+  }
+  action;
+  errors;
+};
+var TechnogymNotFoundError = class extends TechnogymError {
+};
+
+// src/auth/constants.ts
+var CORE_URL = "https://core.mywellness.com";
+var SERVICES_URL = "https://services.mywellness.com";
+var APP_ID = "EC1D38D7-D359-48D0-A60C-D8C0B8FB9DF9";
+var APP_NAME = "enduserweb";
+var APP_VERSION = "1.0";
+var LOGIN_PATH = "/v2/enduser/authentication/login";
+var USER_AGENT = "technogym-js (+https://github.com/DynamicsNinja/technogym-js)";
+function appHeaders() {
+  return {
+    accept: "application/json",
+    "user-agent": USER_AGENT,
+    "x-mwapps-appid": APP_ID,
+    "x-mwapps-client": APP_NAME,
+    "x-mwapps-clientversion": `${APP_VERSION},${APP_NAME}`
+  };
+}
+
+// src/auth/session-store.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var MemorySessionStore = class {
+  #session = null;
+  async load() {
+    return this.#session;
+  }
+  async save(session) {
+    this.#session = session;
+  }
+  async clear() {
+    this.#session = null;
+  }
+};
+var SESSION_FILE = "session.json";
+var FileSessionStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  async load() {
+    try {
+      return parseSession(JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(this.dir, SESSION_FILE), "utf8")));
+    } catch {
+      return null;
+    }
+  }
+  async save(session) {
+    await (0, import_promises.mkdir)(this.dir, { recursive: true });
+    const tmp = (0, import_node_path.join)(this.dir, `${SESSION_FILE}.${process.pid}-${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+      await (0, import_promises.writeFile)(tmp, JSON.stringify(session, null, 2), { mode: 384 });
+      await (0, import_promises.rename)(tmp, (0, import_node_path.join)(this.dir, SESSION_FILE));
+    } catch (err) {
+      await (0, import_promises.rm)(tmp, { force: true });
+      throw err;
+    }
+  }
+  async clear() {
+    await (0, import_promises.rm)((0, import_node_path.join)(this.dir, SESSION_FILE), { force: true });
+  }
+};
+function parseSession(value) {
+  if (!isRecord(value) || typeof value["token"] !== "string" || !value["token"]) return null;
+  const user = value["user"];
+  if (!isRecord(user) || typeof user["userId"] !== "string" || !user["userId"]) return null;
+  if (!Array.isArray(user["facilities"])) return null;
+  const facilities = [];
+  for (const f of user["facilities"]) {
+    if (!isRecord(f) || typeof f["url"] !== "string") return null;
+    const str = (v) => typeof v === "string" ? v : "";
+    facilities.push({ id: str(f["id"]), url: f["url"], name: str(f["name"]) });
+  }
+  const text2 = (key) => typeof user[key] === "string" ? user[key] : "";
+  return {
+    token: value["token"],
+    user: {
+      userId: user["userId"],
+      firstName: text2("firstName"),
+      lastName: text2("lastName"),
+      nickName: text2("nickName"),
+      measurementSystem: text2("measurementSystem"),
+      culture: text2("culture"),
+      facilities
+    },
+    savedAt: typeof value["savedAt"] === "number" ? value["savedAt"] : 0
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/http/fetcher.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([408, 500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var Fetcher = class {
+  #timeoutMs;
+  #retries;
+  #backoffMs;
+  #fetch;
+  constructor(options = {}) {
+    this.#timeoutMs = options.timeoutMs ?? 3e4;
+    this.#retries = options.retries ?? 3;
+    this.#backoffMs = options.backoffMs ?? 500;
+    this.#fetch = options.fetchImpl ?? globalThis.fetch;
+  }
+  async request(url, options = {}) {
+    const safeUrl = redactUrl(url);
+    const headers = new Headers(options.headers ?? {});
+    let body;
+    if (options.json !== void 0) {
+      body = JSON.stringify(options.json);
+      if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    }
+    const method = options.method ?? "GET";
+    const canRetry = IDEMPOTENT_METHODS.has(method.toUpperCase()) || options.retry === true;
+    const timeoutMs = options.timeoutMs ?? this.#timeoutMs;
+    let lastError;
+    for (let attempt = 0; attempt <= this.#retries; attempt++) {
+      if (attempt > 0) await sleep(this.#backoffMs * 2 ** (attempt - 1));
+      let res;
+      try {
+        res = await this.#fetch(url, {
+          method,
+          headers,
+          body,
+          redirect: "follow",
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (cause) {
+        lastError = cause;
+        if (canRetry && attempt < this.#retries) continue;
+        throw new TechnogymConnectionError(
+          `Request to ${safeUrl} failed after ${attempt + 1} attempt${attempt === 0 ? "" : "s"}`,
+          { cause: lastError }
+        );
+      }
+      if (res.ok) return res;
+      if (RETRY_STATUSES.has(res.status) && canRetry && attempt < this.#retries) continue;
+      throw await toError(res, safeUrl);
+    }
+    throw new TechnogymConnectionError(`Request to ${safeUrl} failed after ${this.#retries + 1} attempts`, {
+      cause: lastError
+    });
+  }
+};
+async function toError(res, safeUrl) {
+  const body = await res.text().catch(() => "");
+  if (res.status === 429) {
+    const raw = res.headers.get("retry-after");
+    const retryAfter = raw && !Number.isNaN(Number(raw)) ? Number(raw) : void 0;
+    return new TechnogymRateLimitError(`Rate limited by mywellness at ${safeUrl}`, retryAfter);
+  }
+  if (res.status === 401 || res.status === 403) {
+    return new TechnogymAuthError(`Not authorized for ${safeUrl} (${res.status})`);
+  }
+  return new TechnogymHttpError(`Request to ${safeUrl} failed with ${res.status}`, res.status, safeUrl, body);
+}
+function redactUrl(url) {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return url;
+  }
+}
+
+// src/util/dates.ts
+var ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function toIsoDate(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new TechnogymError("Invalid Date");
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+  }
+  const m = ISO_DATE.exec(value);
+  if (!m) throw new TechnogymError(`Invalid date "${value}"; expected YYYY-MM-DD`);
+  const d = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
+  if (d.toISOString().slice(0, 10) !== value) throw new TechnogymError(`Invalid date "${value}"`);
+  return value;
+}
+function toPartitionKey(value) {
+  return toIsoDate(value).replaceAll("-", "");
+}
+function fromPartitionKey(value) {
+  const s = typeof value === "string" || typeof value === "number" ? String(value) : "";
+  return /^\d{8}$/.test(s) ? `${s.slice(0, 4)}-${s.slice(4, 6)}-${s.slice(6, 8)}` : s;
+}
+function addDays(date, days) {
+  const [y, m, d] = date.split("-").map(Number);
+  const t = new Date(Date.UTC(y, m - 1, d + days));
+  return t.toISOString().slice(0, 10);
+}
+
+// src/parse.ts
+function rec(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function list(value) {
+  return Array.isArray(value) ? value.map(rec) : [];
+}
+function text(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return typeof value === "object" && value !== null ? JSON.stringify(value) : "";
+}
+function firstText(...values) {
+  for (const v of values) if (v != null && v !== "") return text(v);
+  return "";
+}
+function intOrNull(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.trunc(n) : null;
+}
+function numOrNull(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function parseUser(data) {
+  const d = rec(data);
+  const uc = rec(d["userContext"]);
+  if (!uc["id"]) return null;
+  const facilities = list(d["facilities"]).map((f) => ({
+    id: text(f["id"]),
+    url: text(f["url"]),
+    name: text(f["name"])
+  }));
+  return {
+    userId: text(uc["id"]),
+    firstName: text(uc["firstName"]),
+    lastName: text(uc["lastName"]),
+    nickName: text(uc["nickName"]),
+    measurementSystem: text(uc["measurementSystem"]),
+    culture: text(uc["defaultCulture"]),
+    facilities
+  };
+}
+function parseSessionSummary(item) {
+  const i = rec(item);
+  const pad = (v) => String(intOrNull(v) ?? 0).padStart(2, "0");
+  return {
+    sessionId: text(i["idCr"]),
+    date: fromPartitionKey(i["partitionDate"]),
+    time: `${pad(i["hour"])}:${pad(i["minute"])}`,
+    name: text(i["name"]),
+    type: text(i["type"]),
+    durationMin: intOrNull(i["totalDurationInMinutes"] ?? i["duration"]),
+    moves: intOrNull(i["moves"]),
+    calories: intOrNull(i["calories"]),
+    exercisesDone: intOrNull(i["numberOfExerciseDoneWithGroups"]),
+    exercisesPlanned: intOrNull(i["numberOfExerciseToDoWithGroups"]),
+    userWorkoutSessionId: text(i["userWorkoutSessionId"]),
+    facilityId: text(i["facilityId"]),
+    workoutEffectiveness: intOrNull(i["workoutEffectiveness"]),
+    workoutCompliance: intOrNull(i["workoutCompliance"])
+  };
+}
+function parseProperties(rows) {
+  const out = {};
+  for (const p of list(rows)) {
+    const key = text(p["physicalProperty"] ?? p["property"]);
+    if (!key) continue;
+    if ("rawValue" in p) {
+      out[key] = { value: p["rawValue"], displayValue: p["rawValue"], unit: text(p["uM"]), formatted: p["value"] };
+    } else {
+      out[key] = {
+        value: p["value"],
+        displayValue: "displayValue" in p ? p["displayValue"] : p["value"],
+        unit: text(p["unitOfMeasureShortString"]),
+        formatted: p["formattedValue"]
+      };
+    }
+  }
+  return out;
+}
+function stepToSet(setNumber, properties) {
+  const num = (key) => numOrNull(properties[key]?.value);
+  return {
+    setNumber,
+    reps: num("IsoReps") ?? num("Reps"),
+    weightKg: num("IsoWeight") ?? num("Weight"),
+    restSec: num("RestTime"),
+    durationSec: num("Duration"),
+    properties
+  };
+}
+function parseExercise(activity) {
+  const act = rec(activity);
+  const pa = rec(act["performedPhysicalActivity"]);
+  const pdata = rec(pa["data"]);
+  const prescribed = rec(act["displayPrescibedPhysicalActivity"]);
+  const workloadRanges = {};
+  for (const c of list(pdata["constraints"])) {
+    const prop = text(c["physicalProperty"]);
+    if (!prop) continue;
+    const range = rec(c["discreteRange"]);
+    workloadRanges[prop] = {
+      min: range["min"],
+      max: range["max"],
+      step: range["step"],
+      readOnly: Boolean(c["isReadOnly"]),
+      visibility: c["visibility"]
+    };
+  }
+  const extData = {};
+  for (const [k, v] of Object.entries(rec(pa["extData"]))) {
+    if (v != null && v !== "") extData[k.startsWith("mwc_") ? k.slice(4) : k] = v;
+  }
+  return {
+    activityId: text(pa["id"]),
+    analyticsId: firstText(act["analyticsId"], pa["analiticsId"]),
+    // sic
+    name: text(act["physicalActivityName"]),
+    machine: text(act["equipmentName"]),
+    equipmentType: text(act["equipmentType"]),
+    type: text(act["physicalActivityType"]),
+    isCardio: Boolean(act["isCardio"]),
+    status: text(act["status"]),
+    doneOn: text(pa["doneOn"]),
+    position: intOrNull(act["position"]),
+    duration: firstText(act["displayDurationDoneShort"], act["displayDurationShort"]),
+    calories: text(act["displayCaloriesDoneShort"]),
+    moves: text(act["displayMoveDoneShort"]),
+    muscles: list(act["muscles"]).map((m) => firstText(m["muscleName"], m["muscleType"])),
+    summary: parseProperties(pdata["data"]),
+    sets: list(pdata["steps"]).map((step, i) => stepToSet(i + 1, parseProperties(step["data"]))),
+    prescribedSets: list(prescribed["steps"]).map((step, i) => stepToSet(i + 1, parseProperties(step["properties"]))),
+    shortName: firstText(act["physicalActivityShortName"], pa["shortName"]),
+    activityCode: intOrNull(act["physicalActivityCode"]),
+    activityTypeId: text(act["physicalActivityId"]),
+    equipmentCode: intOrNull(act["equipmentCode"]),
+    targetType: text(act["targetType"]),
+    doneAs: text(pa["doneAs"]),
+    manuallyDone: Boolean(pa["manuallyDone"]),
+    hasAdjustments: Boolean(act["hasAdjustments"]),
+    donePartially: Boolean(act["hasBeenDonePartially"]),
+    progress: intOrNull(pa["progress"] ?? act["progress"]),
+    estimated: {
+      duration: act["estimatedDuration"],
+      calories: act["estimatedCalories"],
+      moves: act["estimatedMove"]
+    },
+    workloadRanges,
+    extData
+  };
+}
+function parseWorkoutSession(data, sessionId) {
+  const d = rec(data);
+  const startedOn = text(d["startedOn"]);
+  const done = parseProperties(d["doneSummary"]);
+  const muscleScores = {};
+  for (const m of list(d["muscleScores"])) {
+    muscleScores[firstText(m["muscleName"], m["muscleType"])] = intOrNull(m["score"]) ?? 0;
+  }
+  return {
+    sessionId,
+    date: startedOn.slice(0, 10),
+    startedOn,
+    closedOn: text(d["closedOn"]),
+    name: firstText(d["displayName"], d["name"]),
+    type: text(d["sessionType"]),
+    status: text(d["workoutSessionStatus"]),
+    duration: text(d["displayDurationDoneShort"]),
+    durationPlanned: text(d["displayDurationShort"]),
+    calories: firstText(done["Calories"]?.formatted, d["displayCaloriesDoneShort"]),
+    moves: firstText(done["Move"]?.formatted, d["displayMoveDoneShort"]),
+    efficacy: intOrNull(d["workoutEfficacy"]),
+    efficacyQuality: text(d["workoutEfficacyQuality"]),
+    efficacyDescription: text(d["workoutEfficacyDescription"]),
+    muscleScores,
+    exercises: list(d["physicalActivities"]).filter((a) => rec(a["performedPhysicalActivity"])["id"]).map(parseExercise),
+    fromTgCoach: Boolean(d["isFromTgCoach"]),
+    facilityId: text(d["startedInFacilityId"]),
+    userWorkoutSessionId: text(d["userWorkoutSessionId"]),
+    clientApplication: text(rec(d["extData"])["mwc_client_application"]),
+    doneSummary: done
+  };
+}
+function parseZones(rows) {
+  return list(rows).map((z) => ({
+    name: text(z["name"]),
+    lowerBound: numOrNull(z["lowerBound"]),
+    upperBound: numOrNull(z["upperBound"]),
+    secondsInZone: numOrNull(z["secondsInZone"]) ?? 0
+  }));
+}
+function parseExerciseAnalytics(data, analyticsId) {
+  const d = rec(data);
+  const an = rec(d["analitics"] ?? d["analytics"]);
+  const channelByIndex = /* @__PURE__ */ new Map();
+  for (const ch of list(an["descriptor"])) {
+    const index = intOrNull(ch["i"]);
+    if (index === null) continue;
+    channelByIndex.set(index, text(rec(ch["pr"])["name"]));
+  }
+  const channels = [...channelByIndex.entries()].sort(([a], [b]) => a - b).map(([, name]) => name);
+  const samples = [];
+  for (const raw of list(an["samples"])) {
+    const vs = Array.isArray(raw["vs"]) ? raw["vs"] : [];
+    if (vs.length === 0) continue;
+    const row = { t: intOrNull(raw["t"]) ?? 0 };
+    for (const [index, name] of channelByIndex) row[name] = numOrNull(vs[index]);
+    samples.push(row);
+  }
+  const hr = list(an["hr"]).filter((h) => "hr" in h).map((h) => ({ t: intOrNull(h["t"]) ?? 0, hr: intOrNull(h["hr"]) ?? 0 }));
+  const laps = list(an["laps"]).map((lap) => ({
+    n: intOrNull(lap["n"]),
+    lapDistanceM: numOrNull(lap["lapDistance"]),
+    lapTimeSec: numOrNull(lap["lapTime"]),
+    totalDistanceM: numOrNull(lap["totalDistance"]),
+    totalTimeSec: numOrNull(lap["totalTime"])
+  }));
+  return {
+    analyticsId,
+    name: text(d["name"]),
+    equipmentType: text(d["equipmentType"]),
+    channels,
+    samples,
+    hr,
+    hrZones: parseZones(an["hrZones"]),
+    summary: parseProperties(d["data"]),
+    date: text(d["date"]),
+    target: text(d["target"]),
+    activityTypeId: text(d["physicalActivityId"]),
+    activityName: text(d["physicalActivityName"]),
+    laps
+  };
+}
+function parseHrSession(data, sessionId, date) {
+  const d = rec(data);
+  return {
+    sessionId,
+    date,
+    summary: parseProperties(d["properties"]),
+    hrSamples: list(d["hrSamples"]).map((h) => ({ timestamp: text(h["timestamp"]), hr: intOrNull(h["hr"]) ?? 0 })),
+    hrZones: parseZones(d["hrZones"])
+  };
+}
+
+// src/client.ts
+var AUTH_ERROR_DETAILS = /* @__PURE__ */ new Set([
+  "TokenNotValid",
+  "InvalidToken",
+  "TokenExpired",
+  "NotAuthenticated",
+  "Unauthorized",
+  "UserNotLogged"
+]);
+function isAuthErrorEntry(errors) {
+  return errors.some((e) => {
+    const details = String(e.details ?? e.message ?? "");
+    return AUTH_ERROR_DETAILS.has(details) || details.toLowerCase().includes("token");
+  });
+}
+function errorsText(errors) {
+  return errors.map((e) => String(e.errorMessage ?? e.message ?? e.details ?? JSON.stringify(e))).join("; ");
+}
+var TechnogymClient = class {
+  /** Where this client loads and saves its session. */
+  sessionStore;
+  #fetcher;
+  #facility;
+  #credentials;
+  #session = null;
+  #signingIn = null;
+  /** Creates a client that is not signed in yet. */
+  constructor(options = {}) {
+    this.sessionStore = options.sessionStore ?? new MemorySessionStore();
+    this.#credentials = options.credentials;
+    this.#facility = options.facility;
+    this.#fetcher = new Fetcher({
+      timeoutMs: options.timeoutMs,
+      retries: options.retries,
+      backoffMs: options.backoffMs,
+      fetchImpl: options.fetchImpl
+    });
+  }
+  /**
+   * Signs in with email and password and saves the session to the store. The credentials are
+   * kept in memory so a rejected token can be renewed without asking again. Throws
+   * `TechnogymAuthError` when mywellness refuses them.
+   */
+  async login(email, password) {
+    this.#credentials = { email, password };
+    return this.#signIn();
+  }
+  /** Loads the saved session. Returns false when the store holds none. */
+  async loadSession() {
+    const session = await this.sessionStore.load();
+    if (!session) return false;
+    this.#session = session;
+    return true;
+  }
+  /** Uses this session from now on. Does not save it to the store. */
+  setSession(session) {
+    this.#session = session;
+  }
+  /** The session currently held in memory, or `null` before a login or `loadSession()`. */
+  getSession() {
+    return this.#session;
+  }
+  /** Forgets the session and the in-memory credentials, and clears the store. */
+  async logout() {
+    this.#session = null;
+    this.#credentials = void 0;
+    await this.sessionStore.clear();
+  }
+  /**
+   * The signed-in account. Signs in first when the client was given credentials and holds no
+   * session yet; otherwise throws `TechnogymAuthError`.
+   */
+  async user() {
+    return (await this.#requireSession()).user;
+  }
+  /**
+   * The facility training paths are sent to (see `TechnogymClientOptions.facility`), or `null` for
+   * an account with no facility. Live on 2026-10-31, an account whose login listed no facilities
+   * got the same answers with no facility prefix as with any prefix, so paths go out unprefixed.
+   */
+  facilityOf(user) {
+    if (!this.#facility) return user.facilities[0] ?? null;
+    const facility = user.facilities.find((f) => f.id === this.#facility || f.url === this.#facility);
+    if (!facility) throw new TechnogymError(`The account has no facility "${this.#facility}"`);
+    return facility;
+  }
+  async #requireSession() {
+    if (this.#session) return this.#session;
+    if (this.#credentials) return this.#signIn();
+    throw new TechnogymAuthError("Not signed in: call login() or loadSession() first");
+  }
+  /** Concurrent sign-ins collapse into one login request. */
+  #signIn() {
+    const credentials = this.#credentials;
+    if (!credentials) return Promise.reject(new TechnogymAuthError("No credentials to sign in with"));
+    this.#signingIn ??= (async () => {
+      try {
+        const session = await this.#loginRequest(credentials);
+        this.#session = session;
+        await this.sessionStore.save(session);
+        return session;
+      } finally {
+        this.#signingIn = null;
+      }
+    })();
+    return this.#signingIn;
+  }
+  async #loginRequest({ email, password }) {
+    let body;
+    try {
+      const res = await this.#fetcher.request(`${CORE_URL}${LOGIN_PATH}`, {
+        method: "POST",
+        json: { username: email, password, keepMeLoggedIn: true },
+        headers: appHeaders()
+      });
+      body = await parseEnvelope(res);
+    } catch (cause) {
+      if (cause instanceof TechnogymAuthError) {
+        throw new TechnogymAuthError(`Login failed: ${cause.message}`, { cause });
+      }
+      throw cause;
+    }
+    if (body.errors?.length) throw new TechnogymAuthError(`Login failed: ${errorsText(body.errors)}`);
+    const data = body.data ?? body;
+    const token = data["token"];
+    const user = parseUser(data);
+    if (typeof token !== "string" || !token || !user) {
+      throw new TechnogymAuthError(`Login failed: unexpected response (result=${JSON.stringify(data["result"])})`);
+    }
+    return { token, user, savedAt: Date.now() };
+  }
+  /**
+   * POSTs `body` to a training endpoint and returns the envelope's `data` (or the whole body when
+   * it has none). `path` is relative to the facility, e.g. `/Training/User/{userId}/MyMovergy`;
+   * `{userId}` is replaced with the signed-in user's id. For endpoints `Technogym` has no method for.
+   *
+   * A rejected session is renewed once, when the client has credentials, and the call repeated.
+   */
+  async services(path, body = {}, options = {}) {
+    const session = await this.#requireSession();
+    try {
+      return await this.#servicesOnce(session, path, body, options);
+    } catch (error) {
+      if (!(error instanceof TechnogymAuthError) || !this.#credentials) throw error;
+      const renewed = this.#session && this.#session.token !== session.token ? this.#session : await this.#signIn();
+      return this.#servicesOnce(renewed, path, body, options);
+    }
+  }
+  async #servicesOnce(session, path, body, options) {
+    const facility = this.facilityOf(session.user);
+    const resolved = path.replaceAll("{userId}", encodeURIComponent(session.user.userId));
+    const headers = new Headers(appHeaders());
+    headers.set("authorization", `Bearer ${session.token}`);
+    const prefix = facility?.url ? `/${encodeURIComponent(facility.url)}` : "";
+    const res = await this.#fetcher.request(`${SERVICES_URL}${prefix}${resolved}`, {
+      method: "POST",
+      json: body,
+      headers,
+      timeoutMs: options.timeoutMs,
+      retry: options.retry ?? true
+    });
+    const envelope = await parseEnvelope(res);
+    const action = resolved.split("/").pop() ?? resolved;
+    if (envelope.errors?.length) {
+      if (isAuthErrorEntry(envelope.errors)) {
+        throw new TechnogymAuthError(`${action}: mywellness rejected the session (${errorsText(envelope.errors)})`);
+      }
+      throw new TechnogymApiError(`${action}: ${errorsText(envelope.errors)}`, action, envelope.errors);
+    }
+    await this.#adoptRotatedToken(session, envelope.token);
+    return "data" in envelope ? envelope.data : envelope;
+  }
+  /** Some responses carry a fresh `token`; keep it so the session outlives the old one. */
+  async #adoptRotatedToken(session, token) {
+    if (typeof token !== "string" || !token || token === session.token) return;
+    if (this.#session !== session) return;
+    this.#session = { ...session, token, savedAt: Date.now() };
+    await this.sessionStore.save(this.#session);
+  }
+};
+async function parseEnvelope(res) {
+  const text2 = await res.text();
+  if (text2.length === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (cause) {
+    throw new TechnogymError("mywellness returned a non-JSON response", { cause });
+  }
+  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : { data: parsed };
+}
+
+// src/analysis.ts
+var CUMULATIVE_CHANNELS = /* @__PURE__ */ new Set(["HDistance", "Distance", "VDistance", "Calories", "Move"]);
+var SETPOINT_CHANNELS = ["Speed", "Grade", "Level", "Resistance", "Incline", "Rpm_Target"];
+var MIN_INTERVAL_SEC = 10;
+var round = (n, digits) => Math.round(n * 10 ** digits) / 10 ** digits;
+function numbers(samples, channel) {
+  const out = [];
+  for (const row of samples) {
+    const v = row[channel];
+    if (typeof v === "number") out.push(v);
+  }
+  return out;
+}
+function channelStats(samples, channels) {
+  const stats = {};
+  for (const ch of channels) {
+    const values = numbers(samples, ch);
+    if (values.length === 0) continue;
+    const entry = { max: Math.max(...values), samples: values.length };
+    if (CUMULATIVE_CHANNELS.has(ch)) {
+      entry.final = values[values.length - 1];
+    } else {
+      const nonzero = values.filter((v) => v > 0);
+      entry.avg = nonzero.length ? round(nonzero.reduce((a, b) => a + b, 0) / nonzero.length, 1) : 0;
+      entry.minNonzero = nonzero.length ? Math.min(...nonzero) : 0;
+    }
+    stats[ch] = entry;
+  }
+  return stats;
+}
+function workloadBounds(samples, channels) {
+  const keys = SETPOINT_CHANNELS.filter((c) => channels.includes(c));
+  if (keys.length === 0) return [];
+  const sig = (row) => keys.map((k) => round(row[k] ?? 0, 1));
+  const same = (a, b) => a.every((v, i) => v === b[i]);
+  const blocks = [];
+  for (const row of samples) {
+    const s = sig(row);
+    const last = blocks[blocks.length - 1];
+    if (last && same(last.sig, s)) last.end = row.t;
+    else blocks.push({ sig: s, start: row.t, end: row.t });
+  }
+  const merged = [];
+  let carryStart = null;
+  for (const b of blocks) {
+    if (b.end - b.start + 1 < MIN_INTERVAL_SEC) {
+      carryStart ??= b.start;
+      continue;
+    }
+    merged.push({ sig: b.sig, start: carryStart ?? b.start, end: b.end });
+    carryStart = null;
+  }
+  if (carryStart !== null) {
+    const lastMerged = merged[merged.length - 1];
+    const lastBlock = blocks[blocks.length - 1];
+    if (lastMerged) lastMerged.end = lastBlock.end;
+    else merged.push({ sig: blocks[0].sig, start: blocks[0].start, end: lastBlock.end });
+  }
+  if (merged.length < 2) return [];
+  return merged.map((m, i) => [
+    m.start - 1,
+    m.end,
+    { interval: i + 1, setpoint: Object.fromEntries(keys.map((k, j) => [k, m.sig[j]])) }
+  ]);
+}
+function segmentAnalytics(samples, channels, laps, options = {}) {
+  const segmentBy = options.segmentBy ?? "auto";
+  if (samples.length === 0) return { mode: segmentBy === "auto" ? "fixed" : segmentBy, segments: [] };
+  let mode = "fixed";
+  let bounds = [];
+  if (segmentBy === "auto" || segmentBy === "workload") {
+    bounds = workloadBounds(samples, channels);
+    if (bounds.length) mode = "workload";
+  }
+  if (bounds.length === 0 && (segmentBy === "auto" || segmentBy === "laps") && laps.length) {
+    let prev = 0;
+    for (const lap of laps) {
+      if (lap.totalTimeSec == null) continue;
+      bounds.push([prev, lap.totalTimeSec, { lap: lap.n, lapDistanceM: lap.lapDistanceM }]);
+      prev = lap.totalTimeSec;
+    }
+    if (bounds.length) mode = "laps";
+  }
+  if (bounds.length === 0) {
+    mode = "fixed";
+    const step = Math.max(10, Math.trunc(options.segmentSeconds ?? 300) || 300);
+    const lastT = Math.max(...samples.map((r) => r.t));
+    for (let s = 0; s < lastT; s += step) bounds.push([s, Math.min(s + step, lastT), {}]);
+  }
+  const segments = [];
+  for (const [start, end, meta] of bounds) {
+    const rows = samples.filter((r) => start < r.t && r.t <= end);
+    if (rows.length === 0) continue;
+    const stats = channelStats(rows, channels);
+    for (const ch of Object.keys(stats)) {
+      if (!CUMULATIVE_CHANNELS.has(ch)) continue;
+      const vals = numbers(rows, ch);
+      stats[ch] = { delta: round(vals[vals.length - 1] - vals[0], 2), end: vals[vals.length - 1] };
+    }
+    const segment = { startSec: start, endSec: end, durationSec: end - start, ...meta, channels: stats };
+    const speed = stats["Speed"]?.avg;
+    if (speed) segment.paceMinPerKm = round(60 / speed, 2);
+    segments.push(segment);
+  }
+  return { mode, segments };
+}
+function windowSamples(rows, fromSec = 0, toSec = 0) {
+  const lo = Math.max(0, fromSec);
+  return rows.filter((r) => r.t >= lo && (toSec <= 0 || r.t <= toSec));
+}
+function downsample(rows, step) {
+  const n = Math.max(1, Math.trunc(step) || 1);
+  return rows.filter((_, i) => i % n === 0);
+}
+
+// src/technogym.ts
+var HISTORY_PATH = "/Training/User/{userId}/ActivityHistory";
+var SESSION_PATH = "/Training/User/{userId}/GetPerformedWorkoutSessionByIdCr";
+var HR_SESSION_PATH = "/Training/User/{userId}/GetHrSession";
+var MOVERGY_PATH = "/Training/User/{userId}/MyMovergy";
+var analyticsPath = (analyticsId) => `/Training/CardioLog/${encodeURIComponent(analyticsId)}/Details`;
+var Technogym = class {
+  /** Wraps a client. It signs in on first use when it was given credentials. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** The signed-in account: user id, name, culture and facilities. No HTTP call once signed in. */
+  getUser() {
+    return this.client.user();
+  }
+  /** The account's current Movergy score, or `null` when mywellness has none. */
+  async getMovergy() {
+    const data = await this.client.services(MOVERGY_PATH);
+    return typeof data?.movergy === "number" ? data.movergy : null;
+  }
+  /** The untouched `ActivityHistory` payload for a date range (bounds in either order). */
+  getActivityHistoryRaw(from, to, options = {}) {
+    let start = toIsoDate(from);
+    let end = toIsoDate(to);
+    if (start > end) [start, end] = [end, start];
+    const body = { startDay: toPartitionKey(start), endDay: toPartitionKey(end) };
+    if (options.onlyWorkouts ?? true) body["justThisType"] = "WorkoutSession";
+    return this.client.services(HISTORY_PATH, body);
+  }
+  /** Sessions between two dates (inclusive, either order), newest first. An overview only. */
+  async listSessions(from, to, options = {}) {
+    const data = await this.getActivityHistoryRaw(from, to, options);
+    const items = Array.isArray(data?.["items"]) ? data["items"] : [];
+    return items.map(parseSessionSummary).sort((a, b) => (b.date + b.time).localeCompare(a.date + a.time));
+  }
+  /**
+   * The date of a session, found by scanning the last `lookbackDays` (default 365) of history
+   * across every activity type. Throws `TechnogymNotFoundError` when it is not there.
+   */
+  async findSessionDate(sessionId, lookbackDays = 365) {
+    const today = toIsoDate(/* @__PURE__ */ new Date());
+    const sessions = await this.listSessions(addDays(today, -lookbackDays), today, { onlyWorkouts: false });
+    const match = sessions.find((s) => s.sessionId === String(sessionId));
+    if (!match) throw new TechnogymNotFoundError(`Session ${sessionId} not found in the last ${lookbackDays} days`);
+    return match.date;
+  }
+  /** The untouched `GetPerformedWorkoutSessionByIdCr` payload. Pass `date`; see `getWorkoutSession`. */
+  async getWorkoutSessionRaw(sessionId, date) {
+    const day = await this.#resolveDate(sessionId, date);
+    const data = await this.client.services(SESSION_PATH, {
+      idCr: idCr(sessionId),
+      partitionDate: toPartitionKey(day)
+    });
+    if (!data?.["id"]) throw new TechnogymNotFoundError(`Session ${sessionId} on ${day} not found`);
+    return data;
+  }
+  /**
+   * Every exercise of a session with machine, sets (performed and prescribed), the machine's full
+   * summary and workload ranges, plus efficacy, muscle scores and totals. Summaries are averages
+   * and maxima only: for splits and time series, call `getExerciseAnalytics` with an exercise's
+   * `analyticsId`. `date` is strongly recommended; without it the last year is scanned for it.
+   */
+  async getWorkoutSession(sessionId, date) {
+    return parseWorkoutSession(await this.getWorkoutSessionRaw(sessionId, date), String(sessionId));
+  }
+  /**
+   * Every workout session of the last `days` days (1-365, default 14), fully loaded, newest first.
+   * One request for the list plus one per session.
+   */
+  async getRecentWorkouts(days = 14) {
+    const n = Math.max(1, Math.min(Math.trunc(days) || 14, 365));
+    const today = toIsoDate(/* @__PURE__ */ new Date());
+    const items = await this.listSessions(addDays(today, -n), today);
+    const sessions = [];
+    for (const item of items) sessions.push(await this.getWorkoutSession(item.sessionId, item.date));
+    return sessions;
+  }
+  /** The untouched `CardioLog/{analyticsId}/Details` payload. */
+  async getExerciseAnalyticsRaw(analyticsId) {
+    if (!analyticsId) throw new TechnogymError("analyticsId is required");
+    const data = await this.client.services(analyticsPath(analyticsId));
+    if (!data || Object.keys(data).length === 0) throw new TechnogymNotFoundError(`No analytics for ${analyticsId}`);
+    return data;
+  }
+  /**
+   * Per-second analytics of one exercise: the machine's channels (Skillrun: Speed, Grade,
+   * HDistance, RunningCadence, RunningPower; bikes: Power, Rpm...), heart rate, HR zones, laps and
+   * summary. Strength machines have no time series; use the sets of `getWorkoutSession`.
+   */
+  async getExerciseAnalytics(analyticsId) {
+    return parseExerciseAnalytics(await this.getExerciseAnalyticsRaw(analyticsId), analyticsId);
+  }
+  /**
+   * `getExerciseAnalytics` plus per-channel stats and segments: by default one per interval
+   * detected from setpoint changes (speed / grade / level), else per console lap, else fixed
+   * windows. See `segmentAnalytics` to run the same analysis on samples you already have.
+   */
+  async analyzeExercise(analyticsId, options = {}) {
+    const analytics = await this.getExerciseAnalytics(analyticsId);
+    const { mode, segments } = segmentAnalytics(analytics.samples, analytics.channels, analytics.laps, options);
+    return {
+      ...analytics,
+      channelStats: channelStats(analytics.samples, analytics.channels),
+      segmentMode: mode,
+      segments
+    };
+  }
+  /** The untouched `GetHrSession` payload. */
+  async getSessionHeartRateRaw(sessionId, date) {
+    const day = await this.#resolveDate(sessionId, date);
+    const data = await this.client.services(HR_SESSION_PATH, {
+      idCr: idCr(sessionId),
+      // A NUMBER here, unlike the string partitionDate of GetPerformedWorkoutSessionByIdCr.
+      partitionDate: Number(toPartitionKey(day))
+    });
+    if (!data || Object.keys(data).length === 0) {
+      throw new TechnogymNotFoundError(`No heart-rate data for session ${sessionId}`);
+    }
+    return data;
+  }
+  /** The whole-session heart-rate trace: timestamped samples, HR zones and avg/min/max HR. */
+  async getSessionHeartRate(sessionId, date) {
+    const day = await this.#resolveDate(sessionId, date);
+    return parseHrSession(await this.getSessionHeartRateRaw(sessionId, day), String(sessionId), day);
+  }
+  async #resolveDate(sessionId, date) {
+    return date === void 0 ? this.findSessionDate(sessionId) : toIsoDate(date);
+  }
+};
+function idCr(sessionId) {
+  const n = Number(sessionId);
+  if (!Number.isSafeInteger(n)) throw new TechnogymError(`sessionId must be an integer, got "${sessionId}"`);
+  return n;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APP_ID,
+  APP_NAME,
+  CORE_URL,
+  CUMULATIVE_CHANNELS,
+  FileSessionStore,
+  MemorySessionStore,
+  SERVICES_URL,
+  SETPOINT_CHANNELS,
+  Technogym,
+  TechnogymApiError,
+  TechnogymAuthError,
+  TechnogymClient,
+  TechnogymConnectionError,
+  TechnogymError,
+  TechnogymHttpError,
+  TechnogymNotFoundError,
+  TechnogymRateLimitError,
+  channelStats,
+  downsample,
+  isAuthErrorEntry,
+  parseExercise,
+  parseExerciseAnalytics,
+  parseHrSession,
+  parseProperties,
+  parseSessionSummary,
+  parseUser,
+  parseWorkoutSession,
+  segmentAnalytics,
+  windowSamples
+});
+//# sourceMappingURL=index.cjs.map