@kaiord/fit 7.1.1 → 8.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { sportSchema, durationTypeSchema, createConsoleLogger, createFitParsingError, fileTypeSchema, workoutSchema, isRepetitionBlock, convertLengthToMeters, subSportSchema, lengthUnitSchema, equipmentSchema, targetTypeSchema, FIT_TO_SWIM_STROKE, targetUnitSchema, intensitySchema } from '@kaiord/core';
+import { fileTypeSchema, sportSchema, durationTypeSchema, createConsoleLogger, createFitParsingError, workoutSchema, isRepetitionBlock, convertLengthToMeters, subSportSchema, lengthUnitSchema, equipmentSchema, targetTypeSchema, FIT_TO_SWIM_STROKE, targetUnitSchema, intensitySchema } from '@kaiord/core';
 import { Stream, Decoder, Encoder, Profile } from '@garmin/fitsdk';
 import { z } from 'zod';
 
@@ -8,8 +8,7 @@ import { z } from 'zod';
 var FIT_MESSAGE_NUMBERS = {
   FILE_ID: 0,
   WORKOUT: 26,
-  WORKOUT_STEP: 27
-};
+  WORKOUT_STEP: 27};
 z.enum([
   "device",
   "settings",
@@ -195,8 +194,6 @@ var mapSubSportToFit = (krdSubSport) => {
   }
   return KRD_TO_FIT_SUB_SPORT_MAP[result.data] || fitSubSportSchema.enum.generic;
 };
-
-// src/adapters/krd-to-fit/krd-to-fit-metadata.mapper.ts
 var DEFAULT_MANUFACTURER = "garmin";
 var mapManufacturer = (manufacturer, logger) => {
   if (!manufacturer) {
@@ -215,25 +212,44 @@ var mapManufacturer = (manufacturer, logger) => {
   );
   return DEFAULT_MANUFACTURER;
 };
+var countValidSteps = (steps) => {
+  let count = 0;
+  for (const step of steps) {
+    if (isRepetitionBlock(step)) {
+      count += countValidSteps(step.steps) + 1;
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+};
+
+// src/adapters/krd-to-fit/krd-to-fit-metadata.converter.ts
+var resolveFitFileType = (krdType) => {
+  if (krdType === "structured_workout") return "workout";
+  if (krdType === "recorded_activity") return "activity";
+  if (krdType === "course") return "course";
+  return "workout";
+};
+var assignParsedNumber = (target, key, raw) => {
+  const parsed = parseInt(raw, 10);
+  if (!isNaN(parsed)) {
+    target[key] = parsed;
+  }
+};
 var convertMetadataToFileId = (krd, logger) => {
   logger.debug("Converting metadata to file_id message");
-  const fileType = krd.type === "structured_workout" ? "workout" : krd.type === "recorded_activity" ? "activity" : krd.type === "course" ? "course" : "workout";
+  const fileType = resolveFitFileType(krd.type);
   const fileId = {
-    type: FIT_FILE_TYPE_TO_NUMBER[fileType] ?? FIT_FILE_TYPE_TO_NUMBER.workout,
+    type: FIT_FILE_TYPE_TO_NUMBER[fileType],
     timeCreated: new Date(krd.metadata.created),
     manufacturer: mapManufacturer(krd.metadata.manufacturer, logger)
   };
   if (krd.metadata.product !== void 0) {
-    const productNumber = parseInt(krd.metadata.product, 10);
-    if (!isNaN(productNumber)) {
-      fileId.product = productNumber;
-    }
+    assignParsedNumber(fileId, "product", krd.metadata.product);
   }
   if (krd.metadata.serialNumber) {
-    const serialNumber = parseInt(krd.metadata.serialNumber, 10);
-    if (!isNaN(serialNumber)) {
-      fileId.serialNumber = serialNumber;
-    }
+    assignParsedNumber(fileId, "serialNumber", krd.metadata.serialNumber);
   }
   return fileId;
 };
@@ -254,17 +270,6 @@ var convertWorkoutMetadata = (workout, logger) => {
   }
   return workoutMesg;
 };
-var countValidSteps = (steps) => {
-  let count = 0;
-  for (const step of steps) {
-    if (isRepetitionBlock(step)) {
-      count += step.steps.length + 1;
-    } else {
-      count += 1;
-    }
-  }
-  return count;
-};
 var fitDurationTypeSchema = z.enum([
   "time",
   "distance",
@@ -490,7 +495,7 @@ var convertStrokeTarget = (step, message) => {
   message.targetValue = strokeValue.value;
 };
 
-// src/adapters/krd-to-fit/krd-to-fit-target.mapper.ts
+// src/adapters/krd-to-fit/krd-to-fit-target.converter.ts
 var convertTarget = (step, message) => {
   if (step.target.type === targetTypeSchema.enum.open) {
     message.targetType = fitTargetTypeSchema.enum.open;
@@ -671,9 +676,468 @@ var fitMessageKeySchema = z.enum([
   "sessionMesgs",
   "recordMesgs",
   "eventMesgs",
-  "lapMesgs"
+  "lapMesgs",
+  // Health domain (KRD v2.0)
+  "sleepLevelMesgs",
+  "monitoringMesgs",
+  "monitoringInfoMesgs",
+  "weightScaleMesgs",
+  "bodyCompositionMesgs",
+  "hrvStatusSummaryMesgs",
+  "hrvValueMesgs",
+  "stressLevelMesgs"
 ]);
 
+// src/adapters/health/shared/health-metadata.builder.ts
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number";
+var MS_PER_S = 1e3;
+var convertFitTimeCreatedToIso = (timeCreated) => {
+  if (timeCreated instanceof Date) return timeCreated.toISOString();
+  if (isNumber(timeCreated))
+    return new Date(timeCreated * MS_PER_S).toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+};
+var buildHealthMetadata = (fileId) => ({
+  created: convertFitTimeCreatedToIso(fileId?.timeCreated),
+  manufacturer: isString(fileId?.manufacturer) ? fileId.manufacturer : void 0,
+  product: isNumber(fileId?.product) ? String(fileId.product) : void 0
+});
+var fitBodyCompositionSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  percentFat: z.number().optional(),
+  percentHydration: z.number().optional(),
+  visceralFatRating: z.number().optional(),
+  boneMass: z.number().optional(),
+  muscleMass: z.number().optional(),
+  basalMet: z.number().optional(),
+  bmi: z.number().optional()
+});
+
+// src/adapters/health/body-composition/health-body-composition.converter.ts
+var HEALTH_VERSION = "2.0";
+var toIsoString = (value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number") return new Date(value * 1e3).toISOString();
+  return new Date(value).toISOString();
+};
+var FIT_KG_SCALE = 100;
+var fromScaledKg = (value) => value === void 0 ? void 0 : value / FIT_KG_SCALE;
+var collectMeasurements = (fit) => {
+  const out = {};
+  if (fit.percentFat !== void 0) out.bodyFatPercent = fit.percentFat;
+  if (fit.percentHydration !== void 0)
+    out.bodyWaterPercent = fit.percentHydration;
+  const leanMassKilograms = fromScaledKg(fit.muscleMass);
+  if (leanMassKilograms !== void 0)
+    out.leanMassKilograms = leanMassKilograms;
+  const boneMassKilograms = fromScaledKg(fit.boneMass);
+  if (boneMassKilograms !== void 0)
+    out.boneMassKilograms = boneMassKilograms;
+  if (fit.bmi !== void 0) out.bmi = fit.bmi;
+  return out;
+};
+var mapFitBodyCompositionToKrd = (fit) => {
+  const measurements = collectMeasurements(fit);
+  if (Object.keys(measurements).length === 0) return void 0;
+  return {
+    kind: "bodyComposition",
+    version: HEALTH_VERSION,
+    measuredAt: toIsoString(fit.timestamp),
+    ...measurements
+  };
+};
+
+// src/adapters/health/body-composition/fit-to-krd-health-body-composition.converter.ts
+var KRD_VERSION = "2.0";
+var parseFirstBodyComposition = (raw, logger) => {
+  for (const entry of raw) {
+    const result = fitBodyCompositionSchema.safeParse(entry);
+    if (result.success) return result.data;
+    logger.warn("Skipping malformed body_composition message", {
+      issues: result.error.issues
+    });
+  }
+  return void 0;
+};
+var convertFitToKrdHealthBodyComposition = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const rawBody = messages[fitMessageKeySchema.enum.bodyCompositionMesgs] ?? [];
+  const fitBody = parseFirstBodyComposition(rawBody, logger);
+  const body = fitBody ? mapFitBodyCompositionToKrd(fitBody) : void 0;
+  return {
+    version: KRD_VERSION,
+    type: fileTypeSchema.enum.body_composition,
+    metadata: buildHealthMetadata(fileId),
+    extensions: body ? { health: { bodyComposition: body } } : void 0
+  };
+};
+var fitMonitoringInfoSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  restingMetabolicRate: z.number().optional()
+});
+var fitMonitoringSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]).optional(),
+  steps: z.number().int().nonnegative().optional(),
+  activeCalories: z.number().int().nonnegative().optional(),
+  durationMin: z.number().int().nonnegative().optional(),
+  cycles: z.number().nonnegative().optional(),
+  distance: z.number().nonnegative().optional(),
+  activeTime: z.number().int().nonnegative().optional(),
+  activityType: z.string().optional()
+});
+
+// src/adapters/health/daily/health-daily.converter.ts
+var HEALTH_VERSION2 = "2.0";
+var toIsoDate = (value) => {
+  if (!value) return void 0;
+  const date = value instanceof Date ? value : typeof value === "number" ? new Date(value * 1e3) : new Date(value);
+  return date.toISOString().slice(0, 10);
+};
+var sumSteps = (samples) => samples.reduce((sum, s) => sum + (s.steps ?? 0), 0);
+var sumActiveCalories = (samples) => samples.reduce((sum, s) => sum + (s.activeCalories ?? 0), 0);
+var pickDate = (info, samples) => {
+  if (info) return toIsoDate(info.timestamp);
+  const firstWithTs = samples.find((s) => s.timestamp);
+  return firstWithTs ? toIsoDate(firstWithTs.timestamp) : void 0;
+};
+var mapFitMonitoringToKrdDaily = (info, monitoring) => {
+  const date = pickDate(info, monitoring);
+  if (!date) return void 0;
+  return {
+    kind: "daily",
+    version: HEALTH_VERSION2,
+    date,
+    steps: sumSteps(monitoring),
+    activeCalories: sumActiveCalories(monitoring),
+    restingCalories: info?.restingMetabolicRate ?? 0,
+    intensityMinutes: { moderate: 0, vigorous: 0 }
+  };
+};
+
+// src/adapters/health/daily/fit-to-krd-health-daily.converter.ts
+var KRD_VERSION2 = "2.0";
+var parseMonitoringInfo = (raw, logger) => {
+  for (const entry of raw) {
+    const result = fitMonitoringInfoSchema.safeParse(entry);
+    if (result.success) return result.data;
+    logger.warn("Skipping malformed monitoring_info message", {
+      issues: result.error.issues
+    });
+  }
+  return void 0;
+};
+var parseMonitoring = (raw, logger) => {
+  const parsed = [];
+  for (const entry of raw) {
+    const result = fitMonitoringSchema.safeParse(entry);
+    if (result.success) parsed.push(result.data);
+    else
+      logger.warn("Skipping malformed monitoring message", {
+        issues: result.error.issues
+      });
+  }
+  return parsed;
+};
+var convertFitToKrdHealthDaily = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const info = parseMonitoringInfo(
+    messages[fitMessageKeySchema.enum.monitoringInfoMesgs] ?? [],
+    logger
+  );
+  const monitoring = parseMonitoring(
+    messages[fitMessageKeySchema.enum.monitoringMesgs] ?? [],
+    logger
+  );
+  const daily = mapFitMonitoringToKrdDaily(info, monitoring);
+  return {
+    version: KRD_VERSION2,
+    type: fileTypeSchema.enum.daily_wellness,
+    metadata: buildHealthMetadata(fileId),
+    extensions: daily ? { health: { daily } } : void 0
+  };
+};
+var fitHrvStatusSummarySchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  weeklyAverage: z.number().optional(),
+  lastNightAverage: z.number().optional(),
+  lastNight5MinHigh: z.number().optional(),
+  baselineLowUpper: z.number().optional(),
+  baselineBalancedLower: z.number().optional(),
+  baselineBalancedUpper: z.number().optional(),
+  status: z.enum(["none", "poor", "low", "unbalanced", "balanced"]).optional()
+});
+var fitHrvValueSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  value: z.number()
+});
+
+// src/adapters/health/hrv/health-hrv.converter.ts
+var HEALTH_VERSION3 = "2.0";
+var toIsoString2 = (value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number") return new Date(value * 1e3).toISOString();
+  return new Date(value).toISOString();
+};
+var mapFitHrvToKrd = (summary, firstValue) => {
+  if (summary && summary.lastNightAverage !== void 0) {
+    return {
+      kind: "hrv",
+      version: HEALTH_VERSION3,
+      measuredAt: toIsoString2(summary.timestamp),
+      rMSSD: summary.lastNightAverage,
+      measurementWindow: "overnight"
+    };
+  }
+  if (firstValue) {
+    return {
+      kind: "hrv",
+      version: HEALTH_VERSION3,
+      measuredAt: toIsoString2(firstValue.timestamp),
+      rMSSD: firstValue.value,
+      measurementWindow: "spot"
+    };
+  }
+  return void 0;
+};
+
+// src/adapters/health/hrv/fit-to-krd-health-hrv.converter.ts
+var KRD_VERSION3 = "2.0";
+var parseFirstSummary = (raw, logger) => {
+  for (const entry of raw) {
+    const result = fitHrvStatusSummarySchema.safeParse(entry);
+    if (result.success) return result.data;
+    logger.warn("Skipping malformed hrv_status_summary message", {
+      issues: result.error.issues
+    });
+  }
+  return void 0;
+};
+var parseFirstValue = (raw, logger) => {
+  for (const entry of raw) {
+    const result = fitHrvValueSchema.safeParse(entry);
+    if (result.success) return result.data;
+    logger.warn("Skipping malformed hrv_value message", {
+      issues: result.error.issues
+    });
+  }
+  return void 0;
+};
+var convertFitToKrdHealthHrv = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const summary = parseFirstSummary(
+    messages[fitMessageKeySchema.enum.hrvStatusSummaryMesgs] ?? [],
+    logger
+  );
+  const firstValue = parseFirstValue(
+    messages[fitMessageKeySchema.enum.hrvValueMesgs] ?? [],
+    logger
+  );
+  const hrv = mapFitHrvToKrd(summary, firstValue);
+  return {
+    version: KRD_VERSION3,
+    type: fileTypeSchema.enum.hrv_summary,
+    metadata: buildHealthMetadata(fileId),
+    extensions: hrv ? { health: { hrv } } : void 0
+  };
+};
+var fitSleepLevelSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  sleepLevel: z.enum(["awake", "light", "deep", "rem", "unmeasurable"])
+});
+
+// src/adapters/health/sleep/health-sleep.converter.ts
+var HEALTH_VERSION4 = "2.0";
+var toIsoString3 = (value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number") return new Date(value * 1e3).toISOString();
+  return new Date(value).toISOString();
+};
+var isKnownSleepStage = (level) => level === "awake" || level === "light" || level === "deep" || level === "rem";
+var mapFitSleepLevelsToKrdSleep = (fitLevels) => {
+  if (fitLevels.length < 2) return void 0;
+  const sorted = [...fitLevels].sort(
+    (a, b) => new Date(toIsoString3(a.timestamp)).getTime() - new Date(toIsoString3(b.timestamp)).getTime()
+  );
+  const startTime = toIsoString3(sorted[0].timestamp);
+  const endTime = toIsoString3(sorted[sorted.length - 1].timestamp);
+  const stages = [];
+  for (let i = 0; i < sorted.length - 1; i += 1) {
+    const current = sorted[i];
+    if (!isKnownSleepStage(current.sleepLevel)) continue;
+    const startMs = new Date(toIsoString3(current.timestamp)).getTime();
+    const nextMs = new Date(toIsoString3(sorted[i + 1].timestamp)).getTime();
+    const durationSeconds = Math.max(0, Math.round((nextMs - startMs) / 1e3));
+    stages.push({
+      stage: current.sleepLevel,
+      startTime: toIsoString3(current.timestamp),
+      durationSeconds
+    });
+  }
+  const totalDurationSeconds = stages.reduce(
+    (sum, stage) => sum + stage.durationSeconds,
+    0
+  );
+  return {
+    kind: "sleep",
+    version: HEALTH_VERSION4,
+    startTime,
+    endTime,
+    totalDurationSeconds,
+    stages
+  };
+};
+
+// src/adapters/health/sleep/fit-to-krd-health-sleep.converter.ts
+var KRD_VERSION4 = "2.0";
+var parseSleepLevels = (raw, logger) => {
+  const parsed = [];
+  for (const entry of raw) {
+    const result = fitSleepLevelSchema.safeParse(entry);
+    if (result.success) {
+      parsed.push(result.data);
+    } else {
+      logger.warn("Skipping malformed sleep_level message", {
+        issues: result.error.issues
+      });
+    }
+  }
+  return parsed;
+};
+var convertFitToKrdHealthSleep = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const rawLevels = messages[fitMessageKeySchema.enum.sleepLevelMesgs] ?? [];
+  const fitLevels = parseSleepLevels(rawLevels, logger);
+  const sleep = mapFitSleepLevelsToKrdSleep(fitLevels);
+  return {
+    version: KRD_VERSION4,
+    type: fileTypeSchema.enum.sleep_record,
+    metadata: buildHealthMetadata(fileId),
+    extensions: sleep ? { health: { sleep } } : void 0
+  };
+};
+var fitStressLevelSchema = z.object({
+  stressLevelTime: z.union([z.date(), z.string(), z.number()]),
+  stressLevelValue: z.number().int()
+});
+
+// src/adapters/health/stress/health-stress.converter.ts
+var HEALTH_VERSION5 = "2.0";
+var MIN_VALID = 0;
+var MAX_VALID = 100;
+var MS_PER_S2 = 1e3;
+var toEpochMs = (value) => {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "number") return value * MS_PER_S2;
+  return new Date(value).getTime();
+};
+var isValid = (sample) => sample.stressLevelValue >= MIN_VALID && sample.stressLevelValue <= MAX_VALID;
+var mean = (values) => Math.round(values.reduce((s, v) => s + v, 0) / values.length);
+var mapFitStressToKrd = (samples) => {
+  const valid = samples.filter(isValid);
+  if (valid.length === 0) return void 0;
+  const epochs = valid.map((s) => toEpochMs(s.stressLevelTime));
+  const values = valid.map((s) => s.stressLevelValue);
+  return {
+    kind: "stress",
+    version: HEALTH_VERSION5,
+    startTime: new Date(Math.min(...epochs)).toISOString(),
+    endTime: new Date(Math.max(...epochs)).toISOString(),
+    averageLevel: mean(values),
+    peakLevel: Math.max(...values)
+  };
+};
+
+// src/adapters/health/stress/fit-to-krd-health-stress.converter.ts
+var KRD_VERSION5 = "2.0";
+var parseSamples = (raw, logger) => {
+  const out = [];
+  for (const entry of raw) {
+    const result = fitStressLevelSchema.safeParse(entry);
+    if (result.success) {
+      out.push(result.data);
+      continue;
+    }
+    logger.warn("Skipping malformed stress_level message", {
+      issues: result.error.issues
+    });
+  }
+  return out;
+};
+var convertFitToKrdHealthStress = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const samples = parseSamples(
+    messages[fitMessageKeySchema.enum.stressLevelMesgs] ?? [],
+    logger
+  );
+  const stress = mapFitStressToKrd(samples);
+  return {
+    version: KRD_VERSION5,
+    type: fileTypeSchema.enum.stress_episode,
+    metadata: buildHealthMetadata(fileId),
+    extensions: stress ? { health: { stress } } : void 0
+  };
+};
+var fitWeightScaleSchema = z.object({
+  timestamp: z.union([z.date(), z.string(), z.number()]),
+  weight: z.number(),
+  percentFat: z.number().optional(),
+  percentHydration: z.number().optional(),
+  visceralFatMass: z.number().optional(),
+  boneMass: z.number().optional(),
+  muscleMass: z.number().optional(),
+  bmi: z.number().optional(),
+  userProfileIndex: z.number().int().optional()
+});
+
+// src/adapters/health/weight/health-weight.converter.ts
+var HEALTH_VERSION6 = "2.0";
+var FIT_WEIGHT_SCALE = 100;
+var toIsoString4 = (value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number") return new Date(value * 1e3).toISOString();
+  return new Date(value).toISOString();
+};
+var mapFitWeightScaleToKrd = (fit) => {
+  if (fit.weight <= 0) return void 0;
+  return {
+    kind: "weight",
+    version: HEALTH_VERSION6,
+    measuredAt: toIsoString4(fit.timestamp),
+    weightKilograms: fit.weight / FIT_WEIGHT_SCALE
+  };
+};
+
+// src/adapters/health/weight/fit-to-krd-health-weight.converter.ts
+var KRD_VERSION6 = "2.0";
+var parseFirstWeight = (raw, logger) => {
+  for (const entry of raw) {
+    const result = fitWeightScaleSchema.safeParse(entry);
+    if (result.success) return result.data;
+    logger.warn("Skipping malformed weight_scale message", {
+      issues: result.error.issues
+    });
+  }
+  return void 0;
+};
+var convertFitToKrdHealthWeight = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const rawWeights = messages[fitMessageKeySchema.enum.weightScaleMesgs] ?? [];
+  if (rawWeights.length > 1) {
+    logger.warn("Multiple weight_scale messages \u2014 keeping the first only", {
+      count: rawWeights.length
+    });
+  }
+  const fitWeight = parseFirstWeight(rawWeights, logger);
+  const weight = fitWeight ? mapFitWeightScaleToKrd(fitWeight) : void 0;
+  return {
+    version: KRD_VERSION6,
+    type: fileTypeSchema.enum.weight_measurement,
+    metadata: buildHealthMetadata(fileId),
+    extensions: weight ? { health: { weight } } : void 0
+  };
+};
+
 // src/adapters/event/event-type-maps.ts
 var FIT_EVENT_TO_KRD_TYPE = {
   timer: "event_timer",
@@ -1152,7 +1616,7 @@ var convertFitToKrdSession = (data) => {
 };
 
 // src/adapters/messages/activity.mapper.ts
-var KRD_VERSION = "1.0";
+var KRD_VERSION7 = "1.0";
 var convertTimeCreated = (timeCreated) => {
   if (timeCreated instanceof Date) return timeCreated.toISOString();
   if (typeof timeCreated === "number")
@@ -1184,7 +1648,7 @@ var mapActivityFileToKRD = (messages, logger) => {
   const laps = convertFitToKrdLaps(lapMsgs);
   const fitExtensions = extractFitExtensions(messages, logger);
   return {
-    version: KRD_VERSION,
+    version: KRD_VERSION7,
     type: fileTypeSchema.enum.recorded_activity,
     metadata: buildKrdMetadata(
       fileId,
@@ -1197,6 +1661,30 @@ var mapActivityFileToKRD = (messages, logger) => {
     extensions: { fit: fitExtensions }
   };
 };
+var HEALTH_DETECTORS = [
+  ["sleepLevelMesgs", fileTypeSchema.enum.sleep_record],
+  ["bodyCompositionMesgs", fileTypeSchema.enum.body_composition],
+  ["weightScaleMesgs", fileTypeSchema.enum.weight_measurement],
+  ["hrvStatusSummaryMesgs", fileTypeSchema.enum.hrv_summary],
+  ["hrvValueMesgs", fileTypeSchema.enum.hrv_summary],
+  ["monitoringMesgs", fileTypeSchema.enum.daily_wellness],
+  ["stressLevelMesgs", fileTypeSchema.enum.stress_episode]
+];
+var detectFileType = (messages) => {
+  for (const [key, type] of HEALTH_DETECTORS) {
+    const mesgs = messages[key];
+    if (mesgs && mesgs.length > 0) return type;
+  }
+  const workoutMsgs = messages[fitMessageKeySchema.enum.workoutMesgs];
+  if (workoutMsgs && workoutMsgs.length > 0)
+    return fileTypeSchema.enum.structured_workout;
+  const sessionMsgs = messages[fitMessageKeySchema.enum.sessionMesgs];
+  const recordMsgs = messages[fitMessageKeySchema.enum.recordMesgs];
+  if (sessionMsgs && sessionMsgs.length > 0 || recordMsgs && recordMsgs.length > 0) {
+    return fileTypeSchema.enum.recorded_activity;
+  }
+  return fileTypeSchema.enum.structured_workout;
+};
 var DEFAULT_SPORT = sportSchema.enum.cycling;
 var mapSportType = (fitSport) => {
   if (!fitSport) {
@@ -1873,7 +2361,7 @@ var validateMessages = (...[fileId, workoutMsg, messages, logger, options = {}])
 };
 
 // src/adapters/messages/workout.mapper.ts
-var KRD_VERSION2 = "1.0";
+var KRD_VERSION8 = "1.0";
 var mapWorkoutFileToKRD = (messages, logger) => {
   const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
   const workoutMsg = messages[fitMessageKeySchema.enum.workoutMesgs]?.[0];
@@ -1883,7 +2371,7 @@ var mapWorkoutFileToKRD = (messages, logger) => {
   const workout = mapWorkout(workoutMsg, workoutSteps, logger);
   const fitExtensions = extractFitExtensions(messages, logger);
   return {
-    version: KRD_VERSION2,
+    version: KRD_VERSION8,
     type: fileTypeSchema.enum.structured_workout,
     metadata,
     extensions: { structured_workout: workout, fit: fitExtensions }
@@ -1891,17 +2379,6 @@ var mapWorkoutFileToKRD = (messages, logger) => {
 };
 
 // src/adapters/messages/messages.mapper.ts
-var detectFileType = (messages) => {
-  const workoutMsgs = messages[fitMessageKeySchema.enum.workoutMesgs];
-  if (workoutMsgs && workoutMsgs.length > 0)
-    return fileTypeSchema.enum.structured_workout;
-  const sessionMsgs = messages[fitMessageKeySchema.enum.sessionMesgs];
-  const recordMsgs = messages[fitMessageKeySchema.enum.recordMesgs];
-  if (sessionMsgs && sessionMsgs.length > 0 || recordMsgs && recordMsgs.length > 0) {
-    return fileTypeSchema.enum.recorded_activity;
-  }
-  return fileTypeSchema.enum.structured_workout;
-};
 var mapMessagesToKRD = (messages, logger) => {
   logger.debug("Mapping FIT messages to KRD", {
     messageCount: Object.keys(messages).length
@@ -1909,6 +2386,18 @@ var mapMessagesToKRD = (messages, logger) => {
   const fileType = detectFileType(messages);
   logger.debug("Detected file type", { fileType });
   switch (fileType) {
+    case fileTypeSchema.enum.sleep_record:
+      return convertFitToKrdHealthSleep(messages, logger);
+    case fileTypeSchema.enum.weight_measurement:
+      return convertFitToKrdHealthWeight(messages, logger);
+    case fileTypeSchema.enum.body_composition:
+      return convertFitToKrdHealthBodyComposition(messages, logger);
+    case fileTypeSchema.enum.hrv_summary:
+      return convertFitToKrdHealthHrv(messages, logger);
+    case fileTypeSchema.enum.daily_wellness:
+      return convertFitToKrdHealthDaily(messages, logger);
+    case fileTypeSchema.enum.stress_episode:
+      return convertFitToKrdHealthStress(messages, logger);
     case fileTypeSchema.enum.recorded_activity:
       return mapActivityFileToKRD(messages, logger);
     case fileTypeSchema.enum.structured_workout: