@kaiord/fit 4.8.1 → 7.0.0

package/dist/index.js

@@ -3,6 +3,13 @@ import { Stream, Decoder, Encoder, Profile } from '@garmin/fitsdk';
 import { z } from 'zod';
 
 // src/index.ts
+
+// src/adapters/shared/message-numbers.ts
+var FIT_MESSAGE_NUMBERS = {
+  FILE_ID: 0,
+  WORKOUT: 26,
+  WORKOUT_STEP: 27
+};
 z.enum([
   "device",
   "settings",
@@ -276,6 +283,49 @@ var fitDurationTypeSchema = z.enum([
   "repeatUntilPowerGreaterThan",
   "open"
 ]);
+var fitTargetTypeSchema = z.enum([
+  "power",
+  "heartRate",
+  "cadence",
+  "speed",
+  "swimStroke",
+  "open"
+]);
+var fitEquipmentSchema = z.enum([
+  "none",
+  "swimFins",
+  "swimKickboard",
+  "swimPaddles",
+  "swimPullBuoy",
+  "swimSnorkel"
+]);
+
+// src/adapters/equipment/equipment.mapper.ts
+var FIT_TO_KRD_EQUIPMENT_MAP = {
+  none: "none",
+  swimFins: "swim_fins",
+  swimKickboard: "swim_kickboard",
+  swimPaddles: "swim_paddles",
+  swimPullBuoy: "swim_pull_buoy",
+  swimSnorkel: "swim_snorkel"
+};
+var KRD_TO_FIT_EQUIPMENT_MAP = Object.fromEntries(
+  Object.entries(FIT_TO_KRD_EQUIPMENT_MAP).map(([fit, krd]) => [krd, fit])
+);
+var mapEquipmentToKrd = (fitEquipment) => {
+  const result = fitEquipmentSchema.safeParse(fitEquipment);
+  if (!result.success) {
+    return equipmentSchema.enum.none;
+  }
+  return FIT_TO_KRD_EQUIPMENT_MAP[result.data] || equipmentSchema.enum.none;
+};
+var mapEquipmentToFit = (krdEquipment) => {
+  const result = equipmentSchema.safeParse(krdEquipment);
+  if (!result.success) {
+    return fitEquipmentSchema.enum.none;
+  }
+  return KRD_TO_FIT_EQUIPMENT_MAP[result.data] || fitEquipmentSchema.enum.none;
+};
 var convertConditionalDuration = (duration, message) => {
   if (duration.type === durationTypeSchema.enum.heart_rate_less_than) {
     message.durationType = fitDurationTypeSchema.enum.hrLessThan;
@@ -371,16 +421,6 @@ var convertDuration = (step, message) => {
   if (convertRepeatHrPowerDuration(duration, message)) return;
   message.durationType = fitDurationTypeSchema.enum.open;
 };
-var fitTargetTypeSchema = z.enum([
-  "power",
-  "heartRate",
-  "cadence",
-  "speed",
-  "swimStroke",
-  "open"
-]);
-
-// src/adapters/krd-to-fit/krd-to-fit-target-cadence.mapper.ts
 var convertCadenceTarget = (step, message) => {
   message.targetType = fitTargetTypeSchema.enum.cadence;
   if (step.target.type !== targetTypeSchema.enum.cadence) return;
@@ -468,41 +508,6 @@ var convertTarget = (step, message) => {
     convertStrokeTarget(step, message);
   }
 };
-var fitEquipmentSchema = z.enum([
-  "none",
-  "swimFins",
-  "swimKickboard",
-  "swimPaddles",
-  "swimPullBuoy",
-  "swimSnorkel"
-]);
-
-// src/adapters/equipment/equipment.mapper.ts
-var FIT_TO_KRD_EQUIPMENT_MAP = {
-  none: "none",
-  swimFins: "swim_fins",
-  swimKickboard: "swim_kickboard",
-  swimPaddles: "swim_paddles",
-  swimPullBuoy: "swim_pull_buoy",
-  swimSnorkel: "swim_snorkel"
-};
-var KRD_TO_FIT_EQUIPMENT_MAP = Object.fromEntries(
-  Object.entries(FIT_TO_KRD_EQUIPMENT_MAP).map(([fit, krd]) => [krd, fit])
-);
-var mapEquipmentToKrd = (fitEquipment) => {
-  const result = fitEquipmentSchema.safeParse(fitEquipment);
-  if (!result.success) {
-    return equipmentSchema.enum.none;
-  }
-  return FIT_TO_KRD_EQUIPMENT_MAP[result.data] || equipmentSchema.enum.none;
-};
-var mapEquipmentToFit = (krdEquipment) => {
-  const result = equipmentSchema.safeParse(krdEquipment);
-  if (!result.success) {
-    return fitEquipmentSchema.enum.none;
-  }
-  return KRD_TO_FIT_EQUIPMENT_MAP[result.data] || fitEquipmentSchema.enum.none;
-};
 
 // src/adapters/krd-to-fit/krd-to-fit-step.mapper.ts
 var FIT_NOTES_MAX_LENGTH = 256;
@@ -549,13 +554,6 @@ var convertNotes = (notes, stepIndex, behavior, logger) => {
   return notes.substring(0, FIT_NOTES_MAX_LENGTH);
 };
 
-// src/adapters/shared/message-numbers.ts
-var FIT_MESSAGE_NUMBERS = {
-  FILE_ID: 0,
-  WORKOUT: 26,
-  WORKOUT_STEP: 27
-};
-
 // src/adapters/krd-to-fit/krd-to-fit-workout.mapper.ts
 var convertWorkoutSteps = (workout, logger, options = {}) => {
   logger.debug("Converting workout steps", { stepCount: workout.steps.length });
@@ -666,6 +664,15 @@ var validateCoordinates = (latSemicircles, lonSemicircles) => {
   const degreesLon = semicirclesToDegrees(lonSemicircles);
   return degreesLat >= -90 && degreesLat <= 90 && degreesLon >= -180 && degreesLon <= 180;
 };
+var fitMessageKeySchema = z.enum([
+  "fileIdMesgs",
+  "workoutMesgs",
+  "workoutStepMesgs",
+  "sessionMesgs",
+  "recordMesgs",
+  "eventMesgs",
+  "lapMesgs"
+]);
 
 // src/adapters/event/event-type-maps.ts
 var FIT_EVENT_TO_KRD_TYPE = {
@@ -795,15 +802,34 @@ var convertFitToKrdEvent = (data) => {
 var convertFitToKrdEvents = (events) => {
   return events.map(convertFitToKrdEvent);
 };
-var fitMessageKeySchema = z.enum([
-  "fileIdMesgs",
-  "workoutMesgs",
-  "workoutStepMesgs",
-  "sessionMesgs",
-  "recordMesgs",
-  "eventMesgs",
-  "lapMesgs"
-]);
+
+// src/adapters/extensions/developer-fields.extractor.ts
+var extractDeveloperFields = (message) => {
+  const devFields = [];
+  for (const [key, value] of Object.entries(message)) {
+    if (key.startsWith("developer_") || key.includes("DeveloperField")) {
+      devFields.push({
+        fieldName: key,
+        value
+      });
+    }
+  }
+  return devFields;
+};
+var extractFieldsFromMessageArray = (messages) => {
+  const developerFields = [];
+  for (const message of messages) {
+    if (message && typeof message === "object") {
+      const devFields = extractDeveloperFields(
+        message
+      );
+      if (devFields.length > 0) {
+        developerFields.push(...devFields);
+      }
+    }
+  }
+  return developerFields;
+};
 
 // src/adapters/extensions/extensions.extractor.ts
 var extractFitExtensions = (messages, logger) => {
@@ -831,30 +857,11 @@ var extractAllDeveloperFields = (messages) => {
   const developerFields = [];
   for (const value of Object.values(messages)) {
     if (value && Array.isArray(value)) {
-      for (const message of value) {
-        if (message && typeof message === "object") {
-          const devFields = extractDeveloperFields(message);
-          if (devFields.length > 0) {
-            developerFields.push(...devFields);
-          }
-        }
-      }
+      developerFields.push(...extractFieldsFromMessageArray(value));
     }
   }
   return developerFields;
 };
-var extractDeveloperFields = (message) => {
-  const devFields = [];
-  for (const [key, value] of Object.entries(message)) {
-    if (key.startsWith("developer_") || key.includes("DeveloperField")) {
-      devFields.push({
-        fieldName: key,
-        value
-      });
-    }
-  }
-  return devFields;
-};
 var buildExtensions = (unknownMessages, developerFields, logger) => {
   const extensions = {};
   if (developerFields.length > 0) {
@@ -871,64 +878,6 @@ var buildExtensions = (unknownMessages, developerFields, logger) => {
   }
   return extensions;
 };
-
-// src/adapters/lap/lap-trigger.mapper.ts
-var mapFitLapTriggerToKrd = (fit) => {
-  switch (fit) {
-    case "manual":
-      return "manual";
-    case "time":
-      return "time";
-    case "distance":
-      return "distance";
-    case "positionStart":
-    case "positionLap":
-    case "positionWaypoint":
-    case "positionMarked":
-      return "position";
-    case "sessionEnd":
-      return "session_end";
-    case "fitnessEquipment":
-      return "fitness_equipment";
-  }
-};
-
-// src/adapters/lap/lap.mapper.ts
-var mapFitLapToKrd = (fit) => ({
-  // Timing - convert ms to seconds
-  startTime: new Date(fit.startTime * 1e3).toISOString(),
-  totalElapsedTime: fit.totalElapsedTime / 1e3,
-  totalTimerTime: fit.totalTimerTime / 1e3,
-  // Distance
-  totalDistance: fit.totalDistance,
-  // Heart rate
-  avgHeartRate: fit.avgHeartRate,
-  maxHeartRate: fit.maxHeartRate,
-  // Cadence
-  avgCadence: fit.avgCadence,
-  maxCadence: fit.maxCadence,
-  // Power
-  avgPower: fit.avgPower,
-  maxPower: fit.maxPower,
-  normalizedPower: fit.normalizedPower,
-  // Speed - prefer enhanced values
-  avgSpeed: fit.enhancedAvgSpeed ?? fit.avgSpeed,
-  maxSpeed: fit.enhancedMaxSpeed ?? fit.maxSpeed,
-  // Elevation
-  totalAscent: fit.totalAscent,
-  totalDescent: fit.totalDescent,
-  // Calories
-  totalCalories: fit.totalCalories,
-  // Classification
-  trigger: fit.lapTrigger ? mapFitLapTriggerToKrd(fit.lapTrigger) : void 0,
-  sport: fit.sport,
-  subSport: fit.subSport ? mapSubSportToKrd(fit.subSport) : void 0,
-  // Workout reference
-  workoutStepIndex: fit.wktStepIndex,
-  // Swimming
-  numLengths: fit.numLengths,
-  swimStroke: fit.swimStroke !== void 0 ? FIT_TO_SWIM_STROKE[fit.swimStroke] : void 0
-});
 var fitLapTriggerSchema = z.enum([
   "manual",
   "time",
@@ -989,6 +938,64 @@ var fitLapSchema = z.object({
   wktStepIndex: z.number().optional()
 });
 
+// src/adapters/lap/lap-trigger.mapper.ts
+var mapFitLapTriggerToKrd = (fit) => {
+  switch (fit) {
+    case "manual":
+      return "manual";
+    case "time":
+      return "time";
+    case "distance":
+      return "distance";
+    case "positionStart":
+    case "positionLap":
+    case "positionWaypoint":
+    case "positionMarked":
+      return "position";
+    case "sessionEnd":
+      return "session_end";
+    case "fitnessEquipment":
+      return "fitness_equipment";
+  }
+};
+
+// src/adapters/lap/fit-to-krd-lap.mapper.ts
+var mapFitLapToKrd = (fit) => ({
+  // Timing - convert ms to seconds
+  startTime: new Date(fit.startTime * 1e3).toISOString(),
+  totalElapsedTime: fit.totalElapsedTime / 1e3,
+  totalTimerTime: fit.totalTimerTime / 1e3,
+  // Distance
+  totalDistance: fit.totalDistance,
+  // Heart rate
+  avgHeartRate: fit.avgHeartRate,
+  maxHeartRate: fit.maxHeartRate,
+  // Cadence
+  avgCadence: fit.avgCadence,
+  maxCadence: fit.maxCadence,
+  // Power
+  avgPower: fit.avgPower,
+  maxPower: fit.maxPower,
+  normalizedPower: fit.normalizedPower,
+  // Speed - prefer enhanced values
+  avgSpeed: fit.enhancedAvgSpeed ?? fit.avgSpeed,
+  maxSpeed: fit.enhancedMaxSpeed ?? fit.maxSpeed,
+  // Elevation
+  totalAscent: fit.totalAscent,
+  totalDescent: fit.totalDescent,
+  // Calories
+  totalCalories: fit.totalCalories,
+  // Classification
+  trigger: fit.lapTrigger ? mapFitLapTriggerToKrd(fit.lapTrigger) : void 0,
+  sport: fit.sport,
+  subSport: fit.subSport ? mapSubSportToKrd(fit.subSport) : void 0,
+  // Workout reference
+  workoutStepIndex: fit.wktStepIndex,
+  // Swimming
+  numLengths: fit.numLengths,
+  swimStroke: fit.swimStroke !== void 0 ? FIT_TO_SWIM_STROKE[fit.swimStroke] : void 0
+});
+
 // src/adapters/lap/fit-to-krd-lap.converter.ts
 var convertFitToKrdLap = (data) => {
   const fitLap = fitLapSchema.parse(data);
@@ -997,18 +1004,38 @@ var convertFitToKrdLap = (data) => {
 var convertFitToKrdLaps = (laps) => {
   return laps.map(convertFitToKrdLap);
 };
+var fitRecordSchema = z.object({
+  timestamp: z.number(),
+  positionLat: z.number().optional(),
+  positionLong: z.number().optional(),
+  altitude: z.number().optional(),
+  enhancedAltitude: z.number().optional(),
+  speed: z.number().optional(),
+  enhancedSpeed: z.number().optional(),
+  distance: z.number().optional(),
+  heartRate: z.number().optional(),
+  cadence: z.number().optional(),
+  fractionalCadence: z.number().optional(),
+  power: z.number().optional(),
+  temperature: z.number().optional(),
+  verticalOscillation: z.number().optional(),
+  stanceTime: z.number().optional(),
+  stanceTimePercent: z.number().optional(),
+  stepLength: z.number().optional(),
+  compressedTimestamp: z.number().optional()
+});
 
-// src/adapters/record/record.mapper.ts
-var mapFitRecordToKrd = (fit) => {
-  const record = {
-    timestamp: new Date(fit.timestamp * 1e3).toISOString()
-  };
+// src/adapters/record/record-from-fit.mapper.ts
+var mapFitPosition = (fit) => {
   if (fit.positionLat !== void 0 && fit.positionLong !== void 0) {
-    record.position = {
+    return {
       lat: semicirclesToDegrees(fit.positionLat),
       lon: semicirclesToDegrees(fit.positionLong)
     };
   }
+  return void 0;
+};
+var mapFitAltitudeAndSpeed = (fit, record) => {
   if (fit.enhancedAltitude !== void 0) {
     record.altitude = fit.enhancedAltitude;
   } else if (fit.altitude !== void 0) {
@@ -1019,6 +1046,8 @@ var mapFitRecordToKrd = (fit) => {
   } else if (fit.speed !== void 0) {
     record.speed = fit.speed;
   }
+};
+var mapFitCoreFields = (fit, record) => {
   if (fit.distance !== void 0) record.distance = fit.distance;
   if (fit.heartRate !== void 0) record.heartRate = fit.heartRate;
   if (fit.power !== void 0) record.power = fit.power;
@@ -1026,33 +1055,25 @@ var mapFitRecordToKrd = (fit) => {
   if (fit.cadence !== void 0) {
     record.cadence = fit.cadence + (fit.fractionalCadence ?? 0);
   }
+};
+var mapFitRunningDynamics = (fit, record) => {
   if (fit.verticalOscillation !== void 0) {
     record.verticalOscillation = fit.verticalOscillation;
   }
   if (fit.stanceTime !== void 0) record.stanceTime = fit.stanceTime;
   if (fit.stepLength !== void 0) record.stepLength = fit.stepLength;
+};
+var mapFitRecordToKrd = (fit) => {
+  const record = {
+    timestamp: new Date(fit.timestamp * 1e3).toISOString()
+  };
+  const position = mapFitPosition(fit);
+  if (position) record.position = position;
+  mapFitAltitudeAndSpeed(fit, record);
+  mapFitCoreFields(fit, record);
+  mapFitRunningDynamics(fit, record);
   return record;
 };
-var fitRecordSchema = z.object({
-  timestamp: z.number(),
-  positionLat: z.number().optional(),
-  positionLong: z.number().optional(),
-  altitude: z.number().optional(),
-  enhancedAltitude: z.number().optional(),
-  speed: z.number().optional(),
-  enhancedSpeed: z.number().optional(),
-  distance: z.number().optional(),
-  heartRate: z.number().optional(),
-  cadence: z.number().optional(),
-  fractionalCadence: z.number().optional(),
-  power: z.number().optional(),
-  temperature: z.number().optional(),
-  verticalOscillation: z.number().optional(),
-  stanceTime: z.number().optional(),
-  stanceTimePercent: z.number().optional(),
-  stepLength: z.number().optional(),
-  compressedTimestamp: z.number().optional()
-});
 
 // src/adapters/record/fit-to-krd-record.converter.ts
 var convertFitToKrdRecord = (data) => {
@@ -1072,30 +1093,6 @@ var convertFitToKrdRecord = (data) => {
 var convertFitToKrdRecords = (records) => {
   return records.map(convertFitToKrdRecord);
 };
-
-// src/adapters/session/session.mapper.ts
-var mapFitSessionToKrd = (fit) => ({
-  startTime: new Date(fit.startTime * 1e3).toISOString(),
-  totalElapsedTime: fit.totalElapsedTime / 1e3,
-  totalTimerTime: fit.totalTimerTime !== void 0 ? fit.totalTimerTime / 1e3 : void 0,
-  totalDistance: fit.totalDistance,
-  sport: String(fit.sport),
-  subSport: fit.subSport ? mapSubSportToKrd(fit.subSport) : void 0,
-  avgHeartRate: fit.avgHeartRate,
-  maxHeartRate: fit.maxHeartRate,
-  avgCadence: fit.avgCadence,
-  maxCadence: fit.maxCadence,
-  avgPower: fit.avgPower,
-  maxPower: fit.maxPower,
-  normalizedPower: fit.normalizedPower,
-  trainingStressScore: fit.trainingStressScore,
-  intensityFactor: fit.intensityFactor,
-  totalCalories: fit.totalCalories,
-  totalAscent: fit.totalAscent,
-  totalDescent: fit.totalDescent,
-  avgSpeed: fit.enhancedAvgSpeed ?? fit.avgSpeed,
-  maxSpeed: fit.enhancedMaxSpeed ?? fit.maxSpeed
-});
 var fitSessionSchema = z.object({
   timestamp: z.number(),
   startTime: z.number(),
@@ -1124,6 +1121,30 @@ var fitSessionSchema = z.object({
   firstLapIndex: z.number().optional()
 });
 
+// src/adapters/session/session.mapper.ts
+var mapFitSessionToKrd = (fit) => ({
+  startTime: new Date(fit.startTime * 1e3).toISOString(),
+  totalElapsedTime: fit.totalElapsedTime / 1e3,
+  totalTimerTime: fit.totalTimerTime !== void 0 ? fit.totalTimerTime / 1e3 : void 0,
+  totalDistance: fit.totalDistance,
+  sport: String(fit.sport),
+  subSport: fit.subSport ? mapSubSportToKrd(fit.subSport) : void 0,
+  avgHeartRate: fit.avgHeartRate,
+  maxHeartRate: fit.maxHeartRate,
+  avgCadence: fit.avgCadence,
+  maxCadence: fit.maxCadence,
+  avgPower: fit.avgPower,
+  maxPower: fit.maxPower,
+  normalizedPower: fit.normalizedPower,
+  trainingStressScore: fit.trainingStressScore,
+  intensityFactor: fit.intensityFactor,
+  totalCalories: fit.totalCalories,
+  totalAscent: fit.totalAscent,
+  totalDescent: fit.totalDescent,
+  avgSpeed: fit.enhancedAvgSpeed ?? fit.avgSpeed,
+  maxSpeed: fit.enhancedMaxSpeed ?? fit.maxSpeed
+});
+
 // src/adapters/session/fit-to-krd-session.converter.ts
 var convertFitToKrdSession = (data) => {
   const fitSession = fitSessionSchema.parse(data);
@@ -1138,6 +1159,13 @@ var convertTimeCreated = (timeCreated) => {
     return new Date(timeCreated * 1e3).toISOString();
   return (/* @__PURE__ */ new Date()).toISOString();
 };
+var buildKrdMetadata = (fileId, session) => ({
+  created: convertTimeCreated(fileId ? fileId.timeCreated : void 0),
+  sport: (session ? session.sport : void 0) ?? "other",
+  subSport: session ? session.subSport : void 0
+});
+var toOptionalArray = (items) => items.length > 0 ? items : void 0;
+var toOptionalSingle = (item) => item !== void 0 ? [item] : void 0;
 var mapActivityFileToKRD = (messages, logger) => {
   const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
   const sessionMsgs = messages[fitMessageKeySchema.enum.sessionMesgs] || [];
@@ -1155,47 +1183,20 @@ var mapActivityFileToKRD = (messages, logger) => {
   const events = convertFitToKrdEvents(eventMsgs);
   const laps = convertFitToKrdLaps(lapMsgs);
   const fitExtensions = extractFitExtensions(messages, logger);
-  const created = convertTimeCreated(fileId?.timeCreated);
   return {
     version: KRD_VERSION,
     type: fileTypeSchema.enum.recorded_activity,
-    metadata: {
-      created,
-      sport: session?.sport ?? "other",
-      subSport: session?.subSport
-    },
-    sessions: session ? [session] : void 0,
-    laps: laps.length > 0 ? laps : void 0,
-    records: records.length > 0 ? records : void 0,
-    events: events.length > 0 ? events : void 0,
-    extensions: {
-      fit: fitExtensions
-    }
+    metadata: buildKrdMetadata(
+      fileId,
+      session
+    ),
+    sessions: toOptionalSingle(session),
+    laps: toOptionalArray(laps),
+    records: toOptionalArray(records),
+    events: toOptionalArray(events),
+    extensions: { fit: fitExtensions }
   };
 };
-var validateMessages = (fileId, workoutMsg, messages, logger, options = {}) => {
-  const { strict = true } = options;
-  if (!fileId) {
-    const message = "Missing required fileId message in FIT file";
-    if (strict) {
-      throw createFitParsingError(message);
-    }
-    logger.warn(message);
-  }
-  if (!workoutMsg) {
-    const message = "Missing required workout message in FIT file";
-    if (strict) {
-      throw createFitParsingError(message);
-    }
-    logger.warn(message);
-  }
-  const workoutMessages = messages[fitMessageKeySchema.enum.workoutMesgs];
-  if (workoutMessages && workoutMessages.length > 1) {
-    logger.warn("Multiple workout messages found, using first one", {
-      count: workoutMessages.length
-    });
-  }
-};
 var DEFAULT_SPORT = sportSchema.enum.cycling;
 var mapSportType = (fitSport) => {
   if (!fitSport) {
@@ -1231,6 +1232,16 @@ var mapCreatedTimestamp = (fileId) => {
   }
   return (/* @__PURE__ */ new Date()).toISOString();
 };
+var FIT_LENGTH_UNIT_MAP = {
+  0: "meters",
+  1: "yards"
+};
+var mapLengthUnitToKrd = (fitUnit) => {
+  if (fitUnit === void 0) {
+    return lengthUnitSchema.enum.meters;
+  }
+  return FIT_LENGTH_UNIT_MAP[fitUnit] || lengthUnitSchema.enum.meters;
+};
 var convertTimeDuration = (data) => {
   if (data.durationTime !== void 0) {
     return {
@@ -1388,34 +1399,24 @@ var convertFitDuration = (data) => {
 var mapDuration = (step) => {
   return convertFitDuration(step);
 };
+var FIT_TO_KRD_DURATION_TYPE = {
+  [fitDurationTypeSchema.enum.time]: durationTypeSchema.enum.time,
+  [fitDurationTypeSchema.enum.distance]: durationTypeSchema.enum.distance,
+  [fitDurationTypeSchema.enum.hrLessThan]: durationTypeSchema.enum.heart_rate_less_than,
+  [fitDurationTypeSchema.enum.repeatUntilHrGreaterThan]: durationTypeSchema.enum.repeat_until_heart_rate_greater_than,
+  [fitDurationTypeSchema.enum.calories]: durationTypeSchema.enum.calories,
+  [fitDurationTypeSchema.enum.powerLessThan]: durationTypeSchema.enum.power_less_than,
+  [fitDurationTypeSchema.enum.powerGreaterThan]: durationTypeSchema.enum.power_greater_than,
+  [fitDurationTypeSchema.enum.repeatUntilTime]: durationTypeSchema.enum.repeat_until_time,
+  [fitDurationTypeSchema.enum.repeatUntilDistance]: durationTypeSchema.enum.repeat_until_distance,
+  [fitDurationTypeSchema.enum.repeatUntilCalories]: durationTypeSchema.enum.repeat_until_calories,
+  [fitDurationTypeSchema.enum.repeatUntilHrLessThan]: durationTypeSchema.enum.repeat_until_heart_rate_less_than,
+  [fitDurationTypeSchema.enum.repeatUntilPowerLessThan]: durationTypeSchema.enum.repeat_until_power_less_than,
+  [fitDurationTypeSchema.enum.repeatUntilPowerGreaterThan]: durationTypeSchema.enum.repeat_until_power_greater_than
+};
 var mapDurationType = (fitDurationType) => {
-  if (fitDurationType === fitDurationTypeSchema.enum.time)
-    return durationTypeSchema.enum.time;
-  if (fitDurationType === fitDurationTypeSchema.enum.distance)
-    return durationTypeSchema.enum.distance;
-  if (fitDurationType === fitDurationTypeSchema.enum.hrLessThan)
-    return durationTypeSchema.enum.heart_rate_less_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilHrGreaterThan)
-    return durationTypeSchema.enum.repeat_until_heart_rate_greater_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.calories)
-    return durationTypeSchema.enum.calories;
-  if (fitDurationType === fitDurationTypeSchema.enum.powerLessThan)
-    return durationTypeSchema.enum.power_less_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.powerGreaterThan)
-    return durationTypeSchema.enum.power_greater_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilTime)
-    return durationTypeSchema.enum.repeat_until_time;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilDistance)
-    return durationTypeSchema.enum.repeat_until_distance;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilCalories)
-    return durationTypeSchema.enum.repeat_until_calories;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilHrLessThan)
-    return durationTypeSchema.enum.repeat_until_heart_rate_less_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilPowerLessThan)
-    return durationTypeSchema.enum.repeat_until_power_less_than;
-  if (fitDurationType === fitDurationTypeSchema.enum.repeatUntilPowerGreaterThan)
-    return durationTypeSchema.enum.repeat_until_power_greater_than;
-  return durationTypeSchema.enum.open;
+  if (!fitDurationType) return durationTypeSchema.enum.open;
+  return FIT_TO_KRD_DURATION_TYPE[fitDurationType] ?? durationTypeSchema.enum.open;
 };
 var convertCadenceTarget2 = (data) => {
   const rangeTarget = buildCadenceRangeTarget(data);
@@ -1822,16 +1823,6 @@ var buildRepetitionBlock = (step, workoutSteps, currentIndex) => {
     steps: repeatedSteps
   };
 };
-var FIT_LENGTH_UNIT_MAP = {
-  0: "meters",
-  1: "yards"
-};
-var mapLengthUnitToKrd = (fitUnit) => {
-  if (fitUnit === void 0) {
-    return lengthUnitSchema.enum.meters;
-  }
-  return FIT_LENGTH_UNIT_MAP[fitUnit] || lengthUnitSchema.enum.meters;
-};
 
 // src/adapters/workout/workout.mapper.ts
 var mapWorkout = (workoutMsg, workoutSteps, logger) => {
@@ -1855,6 +1846,31 @@ var mapWorkout = (workoutMsg, workoutSteps, logger) => {
   }
   return workout;
 };
+var checkFileId = (fileId, logger, strict) => {
+  if (!fileId) {
+    const message = "Missing required fileId message in FIT file";
+    if (strict) throw createFitParsingError(message);
+    logger.warn(message);
+  }
+};
+var checkWorkoutMsg = (workoutMsg, logger, strict) => {
+  if (!workoutMsg) {
+    const message = "Missing required workout message in FIT file";
+    if (strict) throw createFitParsingError(message);
+    logger.warn(message);
+  }
+};
+var validateMessages = (...[fileId, workoutMsg, messages, logger, options = {}]) => {
+  const { strict = true } = options;
+  checkFileId(fileId, logger, strict);
+  checkWorkoutMsg(workoutMsg, logger, strict);
+  const workoutMessages = messages[fitMessageKeySchema.enum.workoutMesgs];
+  if (workoutMessages && workoutMessages.length > 1) {
+    logger.warn("Multiple workout messages found, using first one", {
+      count: workoutMessages.length
+    });
+  }
+};
 
 // src/adapters/messages/workout.mapper.ts
 var KRD_VERSION2 = "1.0";