@kaiord/fit 4.0.0

package/dist/index.js

@@ -0,0 +1,1954 @@
+import { sportSchema, durationTypeSchema, createFitParsingError, createConsoleLogger, fileTypeSchema, workoutSchema, convertLengthToMeters, subSportSchema, lengthUnitSchema, FIT_TO_SWIM_STROKE, equipmentSchema, targetTypeSchema, targetUnitSchema, intensitySchema } from '@kaiord/core';
+import { Stream, Decoder, Encoder, Profile } from '@garmin/fitsdk';
+import { z } from 'zod';
+
+// src/providers.ts
+
+// src/adapters/shared/message-numbers.ts
+var FIT_MESSAGE_NUMBERS = {
+  FILE_ID: 0,
+  WORKOUT: 26,
+  WORKOUT_STEP: 27
+};
+z.enum([
+  "device",
+  "settings",
+  "sport",
+  "activity",
+  "workout",
+  "course",
+  "schedules",
+  "weight",
+  "totals",
+  "goals",
+  "bloodPressure",
+  "monitoringA",
+  "activitySummary",
+  "monitoringDaily",
+  "monitoringB",
+  "segment",
+  "segmentList",
+  "exdConfiguration"
+]);
+var FIT_FILE_TYPE_TO_NUMBER = {
+  device: 1,
+  settings: 2,
+  sport: 3,
+  activity: 4,
+  workout: 5,
+  course: 6,
+  schedules: 7,
+  weight: 9,
+  totals: 10,
+  goals: 11,
+  bloodPressure: 14,
+  monitoringA: 15,
+  activitySummary: 20,
+  monitoringDaily: 28,
+  monitoringB: 32,
+  segment: 34,
+  segmentList: 35,
+  exdConfiguration: 40
+};
+var isRepetitionBlock = (step) => {
+  return "repeatCount" in step;
+};
+var DEFAULT_SPORT = sportSchema.enum.cycling;
+var mapSportType = (fitSport) => {
+  if (!fitSport) {
+    return DEFAULT_SPORT;
+  }
+  return fitSport.toLowerCase();
+};
+var fitSubSportSchema = z.enum([
+  "generic",
+  "treadmill",
+  "street",
+  "trail",
+  "track",
+  "spin",
+  "indoorCycling",
+  "road",
+  "mountain",
+  "downhill",
+  "recumbent",
+  "cyclocross",
+  "handCycling",
+  "trackCycling",
+  "indoorRowing",
+  "elliptical",
+  "stairClimbing",
+  "lapSwimming",
+  "openWater",
+  "flexibilityTraining",
+  "strengthTraining",
+  "warmUp",
+  "match",
+  "exercise",
+  "challenge",
+  "indoorSkiing",
+  "cardioTraining",
+  "indoorWalking",
+  "eBikeFitness",
+  "bmx",
+  "casualWalking",
+  "speedWalking",
+  "bikeToRunTransition",
+  "runToBikeTransition",
+  "swimToBikeTransition",
+  "atv",
+  "motocross",
+  "backcountry",
+  "resort",
+  "rcDrone",
+  "wingsuit",
+  "whitewater",
+  "skateSkiing",
+  "yoga",
+  "pilates",
+  "indoorRunning",
+  "gravelCycling",
+  "eBikeMountain",
+  "commuting",
+  "mixedSurface",
+  "navigate",
+  "trackMe",
+  "map",
+  "singleGasDiving",
+  "multiGasDiving",
+  "gaugeDiving",
+  "apneaDiving",
+  "apneaHunting",
+  "virtualActivity",
+  "obstacle",
+  "all"
+]);
+
+// src/adapters/sub-sport/sub-sport.mapper.ts
+var FIT_TO_KRD_SUB_SPORT_MAP = {
+  generic: "generic",
+  treadmill: "treadmill",
+  street: "street",
+  trail: "trail",
+  track: "track",
+  spin: "spin",
+  indoorCycling: "indoor_cycling",
+  road: "road",
+  mountain: "mountain",
+  downhill: "downhill",
+  recumbent: "recumbent",
+  cyclocross: "cyclocross",
+  handCycling: "hand_cycling",
+  trackCycling: "track_cycling",
+  indoorRowing: "indoor_rowing",
+  elliptical: "elliptical",
+  stairClimbing: "stair_climbing",
+  lapSwimming: "lap_swimming",
+  openWater: "open_water",
+  flexibilityTraining: "flexibility_training",
+  strengthTraining: "strength_training",
+  warmUp: "warm_up",
+  match: "match",
+  exercise: "exercise",
+  challenge: "challenge",
+  indoorSkiing: "indoor_skiing",
+  cardioTraining: "cardio_training",
+  indoorWalking: "indoor_walking",
+  eBikeFitness: "e_bike_fitness",
+  bmx: "bmx",
+  casualWalking: "casual_walking",
+  speedWalking: "speed_walking",
+  bikeToRunTransition: "bike_to_run_transition",
+  runToBikeTransition: "run_to_bike_transition",
+  swimToBikeTransition: "swim_to_bike_transition",
+  atv: "atv",
+  motocross: "motocross",
+  backcountry: "backcountry",
+  resort: "resort",
+  rcDrone: "rc_drone",
+  wingsuit: "wingsuit",
+  whitewater: "whitewater",
+  skateSkiing: "skate_skiing",
+  yoga: "yoga",
+  pilates: "pilates",
+  indoorRunning: "indoor_running",
+  gravelCycling: "gravel_cycling",
+  eBikeMountain: "e_bike_mountain",
+  commuting: "commuting",
+  mixedSurface: "mixed_surface",
+  navigate: "navigate",
+  trackMe: "track_me",
+  map: "map",
+  singleGasDiving: "single_gas_diving",
+  multiGasDiving: "multi_gas_diving",
+  gaugeDiving: "gauge_diving",
+  apneaDiving: "apnea_diving",
+  apneaHunting: "apnea_hunting",
+  virtualActivity: "virtual_activity",
+  obstacle: "obstacle",
+  all: "all"
+};
+var KRD_TO_FIT_SUB_SPORT_MAP = Object.fromEntries(
+  Object.entries(FIT_TO_KRD_SUB_SPORT_MAP).map(([fit, krd]) => [krd, fit])
+);
+var mapSubSportToKrd = (fitSubSport) => {
+  const result = fitSubSportSchema.safeParse(fitSubSport);
+  if (!result.success) {
+    return subSportSchema.enum.generic;
+  }
+  return FIT_TO_KRD_SUB_SPORT_MAP[result.data] || subSportSchema.enum.generic;
+};
+var mapSubSportToFit = (krdSubSport) => {
+  const result = subSportSchema.safeParse(krdSubSport);
+  if (!result.success) {
+    return fitSubSportSchema.enum.generic;
+  }
+  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) {
+    return DEFAULT_MANUFACTURER;
+  }
+  const manufacturerEnum = Profile.types.manufacturer;
+  const manufacturerValues = Object.values(manufacturerEnum);
+  const normalized = manufacturer.toLowerCase();
+  const matched = manufacturerValues.find(
+    (value) => value.toLowerCase() === normalized || value.toLowerCase().startsWith(normalized) || normalized.startsWith(value.toLowerCase())
+  );
+  if (matched) return matched;
+  logger.warn(
+    `Unknown manufacturer "${manufacturer}", using fallback "${DEFAULT_MANUFACTURER}"`,
+    { original: manufacturer, fallback: DEFAULT_MANUFACTURER }
+  );
+  return DEFAULT_MANUFACTURER;
+};
+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 fileId = {
+    type: FIT_FILE_TYPE_TO_NUMBER[fileType] ?? FIT_FILE_TYPE_TO_NUMBER.workout,
+    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;
+    }
+  }
+  if (krd.metadata.serialNumber) {
+    const serialNumber = parseInt(krd.metadata.serialNumber, 10);
+    if (!isNaN(serialNumber)) {
+      fileId.serialNumber = serialNumber;
+    }
+  }
+  return fileId;
+};
+var convertWorkoutMetadata = (workout, logger) => {
+  logger.debug("Converting workout metadata");
+  const numValidSteps = countValidSteps(workout.steps);
+  const workoutMesg = {
+    wktName: workout.name,
+    sport: workout.sport,
+    numValidSteps
+  };
+  if (workout.subSport !== void 0) {
+    workoutMesg.subSport = mapSubSportToFit(workout.subSport);
+  }
+  if (workout.poolLength !== void 0) {
+    workoutMesg.poolLength = workout.poolLength;
+    workoutMesg.poolLengthUnit = 0;
+  }
+  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",
+  "repeatUntilStepsCmplt",
+  "repeatUntilHrGreaterThan",
+  "hrLessThan",
+  "hrGreaterThan",
+  "calories",
+  "powerLessThan",
+  "powerGreaterThan",
+  "repeatUntilTime",
+  "repeatUntilDistance",
+  "repeatUntilCalories",
+  "repeatUntilHrLessThan",
+  "repeatUntilPowerLessThan",
+  "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;
+    message.durationHr = duration.bpm;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.power_less_than) {
+    message.durationType = fitDurationTypeSchema.enum.powerLessThan;
+    message.durationPower = duration.watts;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.power_greater_than) {
+    message.durationType = fitDurationTypeSchema.enum.powerGreaterThan;
+    message.durationPower = duration.watts;
+    return true;
+  }
+  return false;
+};
+var convertRepeatDuration = (duration, message) => {
+  if (duration.type === durationTypeSchema.enum.repeat_until_time) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilTime;
+    message.durationTime = duration.seconds;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.repeat_until_distance) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilDistance;
+    message.durationDistance = duration.meters;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.repeat_until_calories) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilCalories;
+    message.durationCalories = duration.calories;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  return false;
+};
+var convertRepeatHrPowerDuration = (duration, message) => {
+  if (duration.type === durationTypeSchema.enum.repeat_until_heart_rate_greater_than) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilHrGreaterThan;
+    message.durationHr = duration.bpm;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.repeat_until_heart_rate_less_than) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilHrLessThan;
+    message.durationHr = duration.bpm;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.repeat_until_power_less_than) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilPowerLessThan;
+    message.durationPower = duration.watts;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.repeat_until_power_greater_than) {
+    message.durationType = fitDurationTypeSchema.enum.repeatUntilPowerGreaterThan;
+    message.durationPower = duration.watts;
+    message.durationStep = duration.repeatFrom;
+    return true;
+  }
+  return false;
+};
+var convertSimpleDuration = (duration, message) => {
+  if (duration.type === durationTypeSchema.enum.time) {
+    message.durationType = fitDurationTypeSchema.enum.time;
+    message.durationTime = duration.seconds;
+    message.durationValue = duration.seconds * 1e3;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.distance) {
+    message.durationType = fitDurationTypeSchema.enum.distance;
+    message.durationDistance = duration.meters;
+    return true;
+  }
+  if (duration.type === durationTypeSchema.enum.calories) {
+    message.durationType = fitDurationTypeSchema.enum.calories;
+    message.durationCalories = duration.calories;
+    return true;
+  }
+  return false;
+};
+
+// src/adapters/krd-to-fit/krd-to-fit-duration.mapper.ts
+var convertDuration = (step, message) => {
+  const { duration } = step;
+  if (convertSimpleDuration(duration, message)) return;
+  if (convertConditionalDuration(duration, message)) return;
+  if (convertRepeatDuration(duration, message)) return;
+  if (convertRepeatHrPowerDuration(duration, message)) return;
+  message.durationType = fitDurationTypeSchema.enum.open;
+};
+var convertCadenceTarget = (step, message) => {
+  message.targetType = fitTargetTypeSchema.enum.cadence;
+  if (step.target.type !== targetTypeSchema.enum.cadence) return;
+  const value = step.target.value;
+  if (value.unit === targetUnitSchema.enum.range) {
+    message.targetValue = 0;
+    message.customTargetCadenceLow = value.min;
+    message.customTargetCadenceHigh = value.max;
+  } else {
+    message.targetValue = 0;
+    message.customTargetCadenceLow = value.value;
+    message.customTargetCadenceHigh = value.value;
+  }
+};
+var convertHeartRateTarget = (step, message) => {
+  message.targetType = fitTargetTypeSchema.enum.heartRate;
+  if (step.target.type !== targetTypeSchema.enum.heart_rate) return;
+  const value = step.target.value;
+  if (value.unit === targetUnitSchema.enum.zone) {
+    message.targetHrZone = value.value;
+  } else if (value.unit === targetUnitSchema.enum.range) {
+    message.targetValue = 0;
+    message.customTargetHeartRateLow = value.min;
+    message.customTargetHeartRateHigh = value.max;
+  } else if (value.unit === targetUnitSchema.enum.bpm) {
+    message.targetValue = value.value + 100;
+  } else if (value.unit === targetUnitSchema.enum.percent_max) {
+    message.targetValue = value.value;
+  }
+};
+var convertPaceTarget = (step, message) => {
+  message.targetType = fitTargetTypeSchema.enum.speed;
+  if (step.target.type !== targetTypeSchema.enum.pace) return;
+  const value = step.target.value;
+  if (value.unit === targetUnitSchema.enum.zone) {
+    message.targetSpeedZone = value.value;
+  } else if (value.unit === targetUnitSchema.enum.range) {
+    message.targetValue = 0;
+    message.customTargetSpeedLow = value.min;
+    message.customTargetSpeedHigh = value.max;
+  } else {
+    message.targetValue = 0;
+    message.customTargetSpeedLow = value.value;
+    message.customTargetSpeedHigh = value.value;
+  }
+};
+var convertPowerTarget = (step, message) => {
+  message.targetType = fitTargetTypeSchema.enum.power;
+  if (step.target.type !== targetTypeSchema.enum.power) return;
+  const value = step.target.value;
+  if (value.unit === targetUnitSchema.enum.zone) {
+    message.targetPowerZone = value.value;
+  } else if (value.unit === targetUnitSchema.enum.range) {
+    message.targetValue = 0;
+    message.customTargetPowerLow = value.min;
+    message.customTargetPowerHigh = value.max;
+  } else if (value.unit === targetUnitSchema.enum.watts) {
+    message.targetValue = value.value + 1e3;
+  } else if (value.unit === targetUnitSchema.enum.percent_ftp) {
+    message.targetValue = value.value;
+  }
+};
+var convertStrokeTarget = (step, message) => {
+  message.targetType = fitTargetTypeSchema.enum.swimStroke;
+  if (step.target.type !== targetTypeSchema.enum.stroke_type) return;
+  const strokeValue = step.target.value;
+  message.targetValue = strokeValue.value;
+};
+
+// src/adapters/krd-to-fit/krd-to-fit-target.mapper.ts
+var convertTarget = (step, message) => {
+  if (step.target.type === targetTypeSchema.enum.open) {
+    message.targetType = fitTargetTypeSchema.enum.open;
+    return;
+  }
+  if (step.target.type === targetTypeSchema.enum.power) {
+    convertPowerTarget(step, message);
+  } else if (step.target.type === targetTypeSchema.enum.heart_rate) {
+    convertHeartRateTarget(step, message);
+  } else if (step.target.type === targetTypeSchema.enum.cadence) {
+    convertCadenceTarget(step, message);
+  } else if (step.target.type === targetTypeSchema.enum.pace) {
+    convertPaceTarget(step, message);
+  } else if (step.target.type === targetTypeSchema.enum.stroke_type) {
+    convertStrokeTarget(step, message);
+  }
+};
+
+// src/adapters/krd-to-fit/krd-to-fit-step.mapper.ts
+var FIT_NOTES_MAX_LENGTH = 256;
+var convertWorkoutStep = (step, messageIndex, logger, options = {}) => {
+  const { notesTruncation = "truncate" } = options;
+  logger.debug("Converting workout step", { stepIndex: step.stepIndex });
+  const workoutStepMesg = {
+    messageIndex
+  };
+  if (step.name) {
+    workoutStepMesg.wktStepName = step.name;
+  }
+  if (step.intensity) {
+    workoutStepMesg.intensity = step.intensity;
+  }
+  if (step.notes !== void 0) {
+    workoutStepMesg.notes = convertNotes(
+      step.notes,
+      step.stepIndex,
+      notesTruncation,
+      logger
+    );
+  }
+  if (step.equipment !== void 0) {
+    workoutStepMesg.equipment = mapEquipmentToFit(step.equipment);
+  }
+  convertDuration(step, workoutStepMesg);
+  convertTarget(step, workoutStepMesg);
+  return workoutStepMesg;
+};
+var convertNotes = (notes, stepIndex, behavior, logger) => {
+  if (notes.length <= FIT_NOTES_MAX_LENGTH) {
+    return notes;
+  }
+  if (behavior === "error") {
+    throw createFitParsingError(
+      `Notes exceed ${FIT_NOTES_MAX_LENGTH} characters at step ${stepIndex} (length: ${notes.length}). Use notesTruncation: "truncate" to auto-truncate.`
+    );
+  }
+  logger.warn(
+    `Notes truncated from ${notes.length} to ${FIT_NOTES_MAX_LENGTH} characters`,
+    { stepIndex, originalLength: notes.length }
+  );
+  return notes.substring(0, FIT_NOTES_MAX_LENGTH);
+};
+
+// 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 });
+  const messages = [];
+  let messageIndex = 0;
+  for (const step of workout.steps) {
+    if (isRepetitionBlock(step)) {
+      const repetitionMessages = convertRepetitionBlock(
+        step,
+        messageIndex,
+        logger,
+        options
+      );
+      messages.push(...repetitionMessages);
+      messageIndex += repetitionMessages.length;
+    } else {
+      const stepMessage = convertWorkoutStep(
+        step,
+        messageIndex,
+        logger,
+        options
+      );
+      messages.push(stepMessage);
+      messageIndex += 1;
+    }
+  }
+  return messages;
+};
+var convertRepetitionBlock = (block, startIndex, logger, options) => {
+  logger.debug("Converting repetition block", {
+    repeatCount: block.repeatCount,
+    stepCount: block.steps.length
+  });
+  const messages = [];
+  let messageIndex = startIndex;
+  for (const step of block.steps) {
+    const stepMessage = convertWorkoutStep(step, messageIndex, logger, options);
+    messages.push(stepMessage);
+    messageIndex += 1;
+  }
+  const repeatMessage = {
+    mesgNum: FIT_MESSAGE_NUMBERS.WORKOUT_STEP,
+    messageIndex,
+    durationType: fitDurationTypeSchema.enum.repeatUntilStepsCmplt,
+    durationStep: startIndex,
+    repeatSteps: block.repeatCount,
+    targetType: fitTargetTypeSchema.enum.open
+  };
+  messages.push(repeatMessage);
+  return messages;
+};
+
+// src/adapters/krd-to-fit/krd-to-fit.converter.ts
+var toRecord = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  return {};
+};
+var extractWorkout = (krd, logger) => {
+  const rawWorkout = krd.extensions?.structured_workout;
+  if (!rawWorkout) {
+    throw createFitParsingError("KRD missing workout data in extensions");
+  }
+  const result = workoutSchema.safeParse(rawWorkout);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    logger.error("Invalid workout data in KRD extensions", { issues });
+    throw createFitParsingError(`Invalid workout data: ${issues}`);
+  }
+  return result.data;
+};
+var convertKRDToMessages = (krd, logger) => {
+  logger.debug("Converting KRD to FIT messages");
+  const messages = [];
+  const fileIdMessage = convertMetadataToFileId(krd, logger);
+  messages.push({
+    mesgNum: FIT_MESSAGE_NUMBERS.FILE_ID,
+    ...fileIdMessage
+  });
+  const workout = extractWorkout(krd, logger);
+  const workoutMessage = convertWorkoutMetadata(workout, logger);
+  messages.push({
+    mesgNum: FIT_MESSAGE_NUMBERS.WORKOUT,
+    ...workoutMessage
+  });
+  const workoutStepMessages = convertWorkoutSteps(workout, logger);
+  for (const stepMessage of workoutStepMessages) {
+    messages.push({
+      mesgNum: FIT_MESSAGE_NUMBERS.WORKOUT_STEP,
+      ...toRecord(stepMessage)
+    });
+  }
+  logger.debug("Converted KRD to FIT messages", {
+    messageCount: messages.length
+  });
+  return messages;
+};
+
+// src/adapters/shared/coordinate.converter.ts
+var SEMICIRCLES_TO_DEGREES = 180 / Math.pow(2, 31);
+var semicirclesToDegrees = (semicircles) => semicircles * SEMICIRCLES_TO_DEGREES;
+var validateCoordinates = (latSemicircles, lonSemicircles) => {
+  if (!Number.isFinite(latSemicircles) || !Number.isFinite(lonSemicircles)) {
+    return false;
+  }
+  const degreesLat = semicirclesToDegrees(latSemicircles);
+  const degreesLon = semicirclesToDegrees(lonSemicircles);
+  return degreesLat >= -90 && degreesLat <= 90 && degreesLon >= -180 && degreesLon <= 180;
+};
+var fitMessageKeySchema = z.enum([
+  "fileIdMesgs",
+  "workoutMesgs",
+  "workoutStepMesgs",
+  "sessionMesgs",
+  "recordMesgs",
+  "eventMesgs",
+  "lapMesgs"
+]);
+var fitEventSchema = z.enum([
+  "timer",
+  "workout",
+  "workoutStep",
+  "powerDown",
+  "powerUp",
+  "offCourse",
+  "session",
+  "lap",
+  "coursePoint",
+  "battery",
+  "virtualPartnerPace",
+  "hrHighAlert",
+  "hrLowAlert",
+  "speedHighAlert",
+  "speedLowAlert",
+  "cadHighAlert",
+  "cadLowAlert",
+  "powerHighAlert",
+  "powerLowAlert",
+  "recoveryHr",
+  "batteryLow",
+  "timeDurationAlert",
+  "distanceDurationAlert",
+  "calorieDurationAlert",
+  "activity",
+  "fitnessEquipment",
+  "length",
+  "userMarker",
+  "sportPoint",
+  "calibration",
+  "frontGearChange",
+  "rearGearChange",
+  "riderPositionChange",
+  "elevHighAlert",
+  "elevLowAlert"
+]);
+var fitEventTypeSchema = z.enum([
+  "start",
+  "stop",
+  "consecutiveDepreciated",
+  "marker",
+  "stopAll",
+  "beginDepreciated",
+  "endDepreciated",
+  "endAllDepreciated",
+  "stopDisable",
+  "stopDisableAll"
+]);
+var fitEventMessageSchema = z.object({
+  timestamp: z.number(),
+  event: fitEventSchema,
+  eventType: fitEventTypeSchema,
+  eventGroup: z.number().optional(),
+  data: z.number().optional(),
+  data16: z.number().optional()
+});
+
+// src/adapters/event/event-type-maps.ts
+var FIT_EVENT_TO_KRD_TYPE = {
+  timer: "event_timer",
+  workout: "event_start",
+  workoutStep: "event_workout_step_change",
+  powerDown: "event_stop",
+  powerUp: "event_start",
+  offCourse: "event_marker",
+  session: "event_session_start",
+  lap: "event_lap",
+  coursePoint: "event_marker",
+  battery: "event_marker",
+  virtualPartnerPace: "event_marker",
+  hrHighAlert: "event_marker",
+  hrLowAlert: "event_marker",
+  speedHighAlert: "event_marker",
+  speedLowAlert: "event_marker",
+  cadHighAlert: "event_marker",
+  cadLowAlert: "event_marker",
+  powerHighAlert: "event_marker",
+  powerLowAlert: "event_marker",
+  recoveryHr: "event_marker",
+  batteryLow: "event_marker",
+  timeDurationAlert: "event_marker",
+  distanceDurationAlert: "event_marker",
+  calorieDurationAlert: "event_marker",
+  activity: "event_activity_start",
+  fitnessEquipment: "event_marker",
+  length: "event_lap",
+  userMarker: "event_marker",
+  sportPoint: "event_marker",
+  calibration: "event_marker",
+  frontGearChange: "event_marker",
+  rearGearChange: "event_marker",
+  riderPositionChange: "event_marker",
+  elevHighAlert: "event_marker",
+  elevLowAlert: "event_marker"
+};
+
+// src/adapters/event/event.mapper.ts
+var mapEventTypeToKrd = (fitEvent, fitEventType) => {
+  if (fitEvent === "timer") {
+    switch (fitEventType) {
+      case "start":
+        return "event_start";
+      case "stop":
+        return "event_stop";
+      case "stopDisable":
+      case "stopDisableAll":
+        return "event_pause";
+      default:
+        return "event_timer";
+    }
+  }
+  return FIT_EVENT_TO_KRD_TYPE[fitEvent] ?? "event_marker";
+};
+var mapFitEventToKrd = (fit) => ({
+  timestamp: new Date(fit.timestamp * 1e3).toISOString(),
+  eventType: mapEventTypeToKrd(fit.event, fit.eventType),
+  eventGroup: fit.eventGroup,
+  data: fit.data
+});
+
+// src/adapters/event/fit-to-krd-event.converter.ts
+var convertFitToKrdEvent = (data) => {
+  const fitEvent = fitEventMessageSchema.parse(data);
+  return mapFitEventToKrd(fitEvent);
+};
+var convertFitToKrdEvents = (events) => {
+  return events.map(convertFitToKrdEvent);
+};
+
+// src/adapters/extensions/extensions.extractor.ts
+var extractFitExtensions = (messages, logger) => {
+  logger.debug("Extracting FIT extensions");
+  const unknownMessages = extractUnknownMessages(messages, logger);
+  const developerFields = extractAllDeveloperFields(messages);
+  return buildExtensions(unknownMessages, developerFields, logger);
+};
+var extractUnknownMessages = (messages, logger) => {
+  const knownMessageKeys = /* @__PURE__ */ new Set([
+    fitMessageKeySchema.enum.fileIdMesgs,
+    fitMessageKeySchema.enum.workoutMesgs,
+    fitMessageKeySchema.enum.workoutStepMesgs
+  ]);
+  const unknownMessages = {};
+  for (const [key, value] of Object.entries(messages)) {
+    if (!knownMessageKeys.has(key) && value && Array.isArray(value)) {
+      logger.debug("Found unknown message type", { messageType: key });
+      unknownMessages[key] = value;
+    }
+  }
+  return unknownMessages;
+};
+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);
+          }
+        }
+      }
+    }
+  }
+  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) {
+    logger.info("Preserved developer fields", {
+      count: developerFields.length
+    });
+    extensions.developerFields = developerFields;
+  }
+  if (Object.keys(unknownMessages).length > 0) {
+    logger.info("Preserved unknown message types", {
+      types: Object.keys(unknownMessages)
+    });
+    extensions.unknownMessages = unknownMessages;
+  }
+  return extensions;
+};
+var fitLapTriggerSchema = z.enum([
+  "manual",
+  "time",
+  "distance",
+  "positionStart",
+  "positionLap",
+  "positionWaypoint",
+  "positionMarked",
+  "sessionEnd",
+  "fitnessEquipment"
+]);
+var fitSportSchema = z.enum([
+  "cycling",
+  "running",
+  "swimming",
+  "generic"
+]);
+
+// src/adapters/schemas/fit-lap.ts
+var fitLapSchema = z.object({
+  // Identifiers
+  messageIndex: z.number().optional(),
+  timestamp: z.number(),
+  // Timing
+  startTime: z.number(),
+  totalElapsedTime: z.number(),
+  totalTimerTime: z.number(),
+  // Distance
+  totalDistance: z.number().optional(),
+  // Speed (enhanced values preferred when available)
+  avgSpeed: z.number().optional(),
+  maxSpeed: z.number().optional(),
+  enhancedAvgSpeed: z.number().optional(),
+  enhancedMaxSpeed: z.number().optional(),
+  // Heart rate
+  avgHeartRate: z.number().optional(),
+  maxHeartRate: z.number().optional(),
+  // Cadence
+  avgCadence: z.number().optional(),
+  maxCadence: z.number().optional(),
+  // Power
+  avgPower: z.number().optional(),
+  maxPower: z.number().optional(),
+  normalizedPower: z.number().optional(),
+  // Elevation
+  totalAscent: z.number().optional(),
+  totalDescent: z.number().optional(),
+  // Calories
+  totalCalories: z.number().optional(),
+  // Classification
+  lapTrigger: fitLapTriggerSchema.optional(),
+  sport: fitSportSchema.optional(),
+  subSport: fitSubSportSchema.optional(),
+  // Swimming
+  numLengths: z.number().optional(),
+  swimStroke: z.number().optional(),
+  // Workout reference
+  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/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);
+  return mapFitLapToKrd(fitLap);
+};
+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()
+  };
+  if (fit.positionLat !== void 0 && fit.positionLong !== void 0) {
+    record.position = {
+      lat: semicirclesToDegrees(fit.positionLat),
+      lon: semicirclesToDegrees(fit.positionLong)
+    };
+  }
+  if (fit.enhancedAltitude !== void 0) {
+    record.altitude = fit.enhancedAltitude;
+  } else if (fit.altitude !== void 0) {
+    record.altitude = fit.altitude;
+  }
+  if (fit.enhancedSpeed !== void 0) {
+    record.speed = fit.enhancedSpeed;
+  } else if (fit.speed !== void 0) {
+    record.speed = fit.speed;
+  }
+  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;
+  if (fit.temperature !== void 0) record.temperature = fit.temperature;
+  if (fit.cadence !== void 0) {
+    record.cadence = fit.cadence + (fit.fractionalCadence ?? 0);
+  }
+  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;
+  return record;
+};
+
+// src/adapters/record/fit-to-krd-record.converter.ts
+var convertFitToKrdRecord = (data) => {
+  const fitRecord = fitRecordSchema.parse(data);
+  const hasLat = fitRecord.positionLat !== void 0;
+  const hasLon = fitRecord.positionLong !== void 0;
+  if (hasLat !== hasLon) {
+    throw new Error("Partial coordinates: both lat and lon must be present");
+  }
+  if (hasLat && hasLon) {
+    if (!validateCoordinates(fitRecord.positionLat, fitRecord.positionLong)) {
+      throw new Error("Invalid coordinates: out of range");
+    }
+  }
+  return mapFitRecordToKrd(fitRecord);
+};
+var convertFitToKrdRecords = (records) => {
+  return records.map(convertFitToKrdRecord);
+};
+var fitSessionSchema = z.object({
+  timestamp: z.number(),
+  startTime: z.number(),
+  totalElapsedTime: z.number(),
+  totalTimerTime: z.number(),
+  totalDistance: z.number().optional(),
+  totalCalories: z.number().optional(),
+  avgSpeed: z.number().optional(),
+  maxSpeed: z.number().optional(),
+  enhancedAvgSpeed: z.number().optional(),
+  enhancedMaxSpeed: z.number().optional(),
+  avgHeartRate: z.number().optional(),
+  maxHeartRate: z.number().optional(),
+  avgCadence: z.number().optional(),
+  maxCadence: z.number().optional(),
+  avgPower: z.number().optional(),
+  maxPower: z.number().optional(),
+  normalizedPower: z.number().optional(),
+  trainingStressScore: z.number().optional(),
+  intensityFactor: z.number().optional(),
+  totalAscent: z.number().optional(),
+  totalDescent: z.number().optional(),
+  sport: fitSportSchema,
+  subSport: fitSubSportSchema.optional(),
+  numLaps: z.number().optional(),
+  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);
+  return mapFitSessionToKrd(fitSession);
+};
+
+// src/adapters/messages/activity.mapper.ts
+var KRD_VERSION = "1.0";
+var convertTimeCreated = (timeCreated) => {
+  if (timeCreated instanceof Date) return timeCreated.toISOString();
+  if (typeof timeCreated === "number")
+    return new Date(timeCreated * 1e3).toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+};
+var mapActivityFileToKRD = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const sessionMsgs = messages[fitMessageKeySchema.enum.sessionMesgs] || [];
+  const recordMsgs = messages[fitMessageKeySchema.enum.recordMesgs] || [];
+  const eventMsgs = messages[fitMessageKeySchema.enum.eventMesgs] || [];
+  const lapMsgs = messages[fitMessageKeySchema.enum.lapMesgs] || [];
+  logger.debug("Mapping activity file", {
+    sessions: sessionMsgs.length,
+    records: recordMsgs.length,
+    events: eventMsgs.length,
+    laps: lapMsgs.length
+  });
+  const session = sessionMsgs.length > 0 ? convertFitToKrdSession(sessionMsgs[0]) : void 0;
+  const records = convertFitToKrdRecords(recordMsgs);
+  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
+    }
+  };
+};
+
+// src/adapters/metadata/metadata.mapper.ts
+var mapMetadata = (fileId, workoutMsg, logger) => {
+  logger.debug("Mapping metadata from FIT messages");
+  const sport = mapSportType(workoutMsg?.sport);
+  const created = mapCreatedTimestamp(fileId);
+  return {
+    created,
+    manufacturer: fileId?.manufacturer,
+    product: fileId?.garminProduct || fileId?.product?.toString(),
+    serialNumber: fileId?.serialNumber?.toString(),
+    sport
+  };
+};
+var mapCreatedTimestamp = (fileId) => {
+  if (!fileId?.timeCreated) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (typeof fileId.timeCreated === "string") {
+    return fileId.timeCreated;
+  }
+  if (fileId.timeCreated instanceof Date) {
+    return fileId.timeCreated.toISOString();
+  }
+  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 {
+      type: durationTypeSchema.enum.time,
+      seconds: data.durationTime
+    };
+  }
+  return null;
+};
+var convertDistanceDuration = (data) => {
+  if (data.durationDistance !== void 0) {
+    return {
+      type: durationTypeSchema.enum.distance,
+      meters: data.durationDistance
+    };
+  }
+  return null;
+};
+var convertHeartRateLessThan = (data) => {
+  if (data.durationHr !== void 0) {
+    return {
+      type: durationTypeSchema.enum.heart_rate_less_than,
+      bpm: data.durationHr
+    };
+  }
+  return null;
+};
+var convertHeartRateGreaterThan = (data) => {
+  if (data.repeatHr !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_heart_rate_greater_than,
+      bpm: data.repeatHr,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertCaloriesDuration = (data) => {
+  if (data.durationCalories !== void 0) {
+    return {
+      type: durationTypeSchema.enum.calories,
+      calories: data.durationCalories
+    };
+  }
+  return null;
+};
+var convertPowerLessThan = (data) => {
+  if (data.durationPower !== void 0) {
+    return {
+      type: durationTypeSchema.enum.power_less_than,
+      watts: data.durationPower
+    };
+  }
+  return null;
+};
+var convertPowerGreaterThan = (data) => {
+  if (data.durationPower !== void 0) {
+    return {
+      type: durationTypeSchema.enum.power_greater_than,
+      watts: data.durationPower
+    };
+  }
+  return null;
+};
+var convertRepeatUntilTime = (data) => {
+  if (data.durationTime !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_time,
+      seconds: data.durationTime,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertRepeatUntilDistance = (data) => {
+  if (data.durationDistance !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_distance,
+      meters: data.durationDistance,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertRepeatUntilCalories = (data) => {
+  if (data.durationCalories !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_calories,
+      calories: data.durationCalories,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertRepeatUntilHrLessThan = (data) => {
+  if (data.durationHr !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_heart_rate_less_than,
+      bpm: data.durationHr,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertRepeatUntilPowerLessThan = (data) => {
+  if (data.durationPower !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_power_less_than,
+      watts: data.durationPower,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+var convertRepeatUntilPowerGreaterThan = (data) => {
+  if (data.durationPower !== void 0 && data.durationStep !== void 0) {
+    return {
+      type: durationTypeSchema.enum.repeat_until_power_greater_than,
+      watts: data.durationPower,
+      repeatFrom: data.durationStep
+    };
+  }
+  return null;
+};
+
+// src/adapters/duration/duration.converter.ts
+var DURATION_CONVERTERS = {
+  [fitDurationTypeSchema.enum.time]: convertTimeDuration,
+  [fitDurationTypeSchema.enum.distance]: convertDistanceDuration,
+  [fitDurationTypeSchema.enum.hrLessThan]: convertHeartRateLessThan,
+  [fitDurationTypeSchema.enum.repeatUntilHrGreaterThan]: convertHeartRateGreaterThan,
+  [fitDurationTypeSchema.enum.calories]: convertCaloriesDuration,
+  [fitDurationTypeSchema.enum.powerLessThan]: convertPowerLessThan,
+  [fitDurationTypeSchema.enum.powerGreaterThan]: convertPowerGreaterThan,
+  [fitDurationTypeSchema.enum.repeatUntilTime]: convertRepeatUntilTime,
+  [fitDurationTypeSchema.enum.repeatUntilDistance]: convertRepeatUntilDistance,
+  [fitDurationTypeSchema.enum.repeatUntilCalories]: convertRepeatUntilCalories,
+  [fitDurationTypeSchema.enum.repeatUntilHrLessThan]: convertRepeatUntilHrLessThan,
+  [fitDurationTypeSchema.enum.repeatUntilPowerLessThan]: convertRepeatUntilPowerLessThan,
+  [fitDurationTypeSchema.enum.repeatUntilPowerGreaterThan]: convertRepeatUntilPowerGreaterThan
+};
+var convertFitDuration = (data) => {
+  const result = fitDurationTypeSchema.safeParse(data.durationType);
+  if (!result.success) {
+    return { type: durationTypeSchema.enum.open };
+  }
+  const converter = DURATION_CONVERTERS[result.data];
+  if (converter) {
+    return converter(data) || { type: durationTypeSchema.enum.open };
+  }
+  return { type: durationTypeSchema.enum.open };
+};
+
+// src/adapters/duration/duration.mapper.ts
+var mapDuration = (step) => {
+  return convertFitDuration(step);
+};
+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;
+};
+var convertCadenceTarget2 = (data) => {
+  const rangeTarget = buildCadenceRangeTarget(data);
+  if (rangeTarget) return rangeTarget;
+  const zoneTarget = buildCadenceZoneTarget(data);
+  if (zoneTarget) return zoneTarget;
+  const valueTarget = buildCadenceValueTarget(data);
+  if (valueTarget) return valueTarget;
+  return { type: targetTypeSchema.enum.open };
+};
+var buildCadenceRangeTarget = (data) => {
+  if (data.customTargetCadenceLow !== void 0 && data.customTargetCadenceHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.cadence,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetCadenceLow,
+        max: data.customTargetCadenceHigh
+      }
+    };
+  }
+  if (data.customTargetValueLow !== void 0 && data.customTargetValueHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.cadence,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetValueLow,
+        max: data.customTargetValueHigh
+      }
+    };
+  }
+  return null;
+};
+var buildCadenceZoneTarget = (data) => {
+  if (data.targetCadenceZone !== void 0) {
+    return {
+      type: targetTypeSchema.enum.cadence,
+      value: {
+        unit: targetUnitSchema.enum.rpm,
+        value: data.targetCadenceZone
+      }
+    };
+  }
+  return null;
+};
+var buildCadenceValueTarget = (data) => {
+  if (data.targetValue !== void 0) {
+    return {
+      type: targetTypeSchema.enum.cadence,
+      value: {
+        unit: targetUnitSchema.enum.rpm,
+        value: data.targetValue
+      }
+    };
+  }
+  return null;
+};
+var convertHeartRateTarget2 = (data) => {
+  const rangeTarget = buildHeartRateRangeTarget(data);
+  if (rangeTarget) return rangeTarget;
+  const zoneTarget = buildHeartRateZoneTarget(data);
+  if (zoneTarget) return zoneTarget;
+  if (data.targetValue !== void 0) {
+    return convertHeartRateValue(data.targetValue);
+  }
+  return { type: targetTypeSchema.enum.open };
+};
+var buildHeartRateRangeTarget = (data) => {
+  if (data.customTargetHeartRateLow !== void 0 && data.customTargetHeartRateHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetHeartRateLow,
+        max: data.customTargetHeartRateHigh
+      }
+    };
+  }
+  if (data.customTargetValueLow !== void 0 && data.customTargetValueHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetValueLow,
+        max: data.customTargetValueHigh
+      }
+    };
+  }
+  return null;
+};
+var buildHeartRateZoneTarget = (data) => {
+  if (data.targetHrZone !== void 0) {
+    if (data.targetHrZone >= 1 && data.targetHrZone <= 5) {
+      return {
+        type: targetTypeSchema.enum.heart_rate,
+        value: {
+          unit: targetUnitSchema.enum.zone,
+          value: data.targetHrZone
+        }
+      };
+    }
+    return convertHeartRateValue(data.targetHrZone);
+  }
+  return null;
+};
+var convertHeartRateValue = (value) => {
+  if (value > 100) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: targetUnitSchema.enum.bpm,
+        value: value - 100
+      }
+    };
+  }
+  if (value > 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: targetUnitSchema.enum.percent_max,
+        value
+      }
+    };
+  }
+  return { type: targetTypeSchema.enum.open };
+};
+var convertPaceTarget2 = (data) => {
+  const rangeTarget = buildPaceRangeTarget(data);
+  if (rangeTarget) return rangeTarget;
+  const zoneTarget = buildPaceZoneTarget(data);
+  if (zoneTarget) return zoneTarget;
+  const valueTarget = buildPaceValueTarget(data);
+  if (valueTarget) return valueTarget;
+  return { type: targetTypeSchema.enum.open };
+};
+var buildPaceRangeTarget = (data) => {
+  if (data.customTargetSpeedLow !== void 0 && data.customTargetSpeedHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.pace,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetSpeedLow,
+        max: data.customTargetSpeedHigh
+      }
+    };
+  }
+  if (data.customTargetValueLow !== void 0 && data.customTargetValueHigh !== void 0) {
+    return {
+      type: targetTypeSchema.enum.pace,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: data.customTargetValueLow,
+        max: data.customTargetValueHigh
+      }
+    };
+  }
+  return null;
+};
+var buildPaceZoneTarget = (data) => {
+  if (data.targetSpeedZone !== void 0) {
+    return {
+      type: targetTypeSchema.enum.pace,
+      value: {
+        unit: targetUnitSchema.enum.zone,
+        value: data.targetSpeedZone
+      }
+    };
+  }
+  return null;
+};
+var buildPaceValueTarget = (data) => {
+  if (data.targetValue !== void 0) {
+    return {
+      type: targetTypeSchema.enum.pace,
+      value: {
+        unit: targetUnitSchema.enum.mps,
+        value: data.targetValue
+      }
+    };
+  }
+  return null;
+};
+
+// src/adapters/target/power-helpers.ts
+var interpretWorkoutPower = (value) => {
+  if (value >= 1e3) {
+    return {
+      type: "watts",
+      value: value - 1e3
+    };
+  }
+  return {
+    type: "percentage",
+    value
+  };
+};
+var convertPowerValue = (value) => {
+  if (value > 1e3) {
+    return {
+      unit: "watts",
+      value: value - 1e3
+    };
+  }
+  if (value > 0) {
+    return {
+      unit: "percent_ftp",
+      value
+    };
+  }
+  return null;
+};
+
+// src/adapters/target/target-power.converter.ts
+var convertPowerTarget2 = (data) => {
+  const rangeTarget = buildPowerRangeTarget(data);
+  if (rangeTarget) return rangeTarget;
+  const zoneTarget = buildPowerZoneTarget(data);
+  if (zoneTarget) return zoneTarget;
+  if (data.targetValue !== void 0) {
+    const powerValue = convertPowerValue(data.targetValue);
+    if (powerValue) {
+      return {
+        type: targetTypeSchema.enum.power,
+        value: powerValue
+      };
+    }
+  }
+  return { type: targetTypeSchema.enum.open };
+};
+var buildPowerRangeTarget = (data) => {
+  if (data.customTargetPowerLow !== void 0 && data.customTargetPowerHigh !== void 0) {
+    const minValue = interpretWorkoutPower(data.customTargetPowerLow);
+    const maxValue = interpretWorkoutPower(data.customTargetPowerHigh);
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: minValue.value,
+        max: maxValue.value
+      }
+    };
+  }
+  if (data.customTargetValueLow !== void 0 && data.customTargetValueHigh !== void 0) {
+    const minValue = interpretWorkoutPower(data.customTargetValueLow);
+    const maxValue = interpretWorkoutPower(data.customTargetValueHigh);
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: targetUnitSchema.enum.range,
+        min: minValue.value,
+        max: maxValue.value
+      }
+    };
+  }
+  return null;
+};
+var buildPowerZoneTarget = (data) => {
+  if (data.targetPowerZone !== void 0) {
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: targetUnitSchema.enum.zone,
+        value: data.targetPowerZone
+      }
+    };
+  }
+  return null;
+};
+var convertStrokeTypeTarget = (data) => {
+  if (data.targetSwimStroke !== void 0) {
+    return {
+      type: targetTypeSchema.enum.stroke_type,
+      value: {
+        unit: targetUnitSchema.enum.swim_stroke,
+        value: data.targetSwimStroke
+      }
+    };
+  }
+  return { type: targetTypeSchema.enum.open };
+};
+
+// src/adapters/target/target.converter.ts
+var convertFitTarget = (data) => {
+  if (data.targetType === fitTargetTypeSchema.enum.power) {
+    return convertPowerTarget2(data);
+  }
+  if (data.targetType === fitTargetTypeSchema.enum.heartRate) {
+    return convertHeartRateTarget2(data);
+  }
+  if (data.targetType === fitTargetTypeSchema.enum.cadence) {
+    return convertCadenceTarget2(data);
+  }
+  if (data.targetType === fitTargetTypeSchema.enum.speed) {
+    return convertPaceTarget2(data);
+  }
+  if (data.targetType === fitTargetTypeSchema.enum.swimStroke) {
+    return convertStrokeTypeTarget(data);
+  }
+  return { type: targetTypeSchema.enum.open };
+};
+
+// src/adapters/target/target.mapper.ts
+var mapTarget = (step) => {
+  return convertFitTarget(step);
+};
+var mapTargetType = (fitTargetType) => {
+  if (fitTargetType === fitTargetTypeSchema.enum.power)
+    return targetTypeSchema.enum.power;
+  if (fitTargetType === fitTargetTypeSchema.enum.heartRate)
+    return targetTypeSchema.enum.heart_rate;
+  if (fitTargetType === fitTargetTypeSchema.enum.cadence)
+    return targetTypeSchema.enum.cadence;
+  if (fitTargetType === fitTargetTypeSchema.enum.speed)
+    return targetTypeSchema.enum.pace;
+  if (fitTargetType === fitTargetTypeSchema.enum.swimStroke)
+    return targetTypeSchema.enum.stroke_type;
+  return targetTypeSchema.enum.open;
+};
+
+// src/adapters/workout/step.mapper.ts
+var mapStep = (step, index) => {
+  const duration = mapDuration(step);
+  const target = mapTarget(step);
+  const workoutStep = {
+    stepIndex: step.messageIndex ?? index,
+    name: step.wktStepName,
+    durationType: mapDurationType(step.durationType),
+    duration,
+    targetType: mapTargetType(step.targetType),
+    target,
+    intensity: mapIntensity(step.intensity)
+  };
+  if (step.notes !== void 0) {
+    workoutStep.notes = step.notes;
+  }
+  if (step.equipment !== void 0) {
+    workoutStep.equipment = mapEquipmentToKrd(step.equipment);
+  }
+  return workoutStep;
+};
+var mapIntensity = (intensity) => {
+  if (!intensity) return void 0;
+  const normalized = intensity.toLowerCase();
+  const validIntensities = intensitySchema.options;
+  if (validIntensities.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+};
+
+// src/adapters/workout/repetition.builder.ts
+var findRepetitionStepIndices = (workoutSteps) => {
+  const indices = /* @__PURE__ */ new Set();
+  for (let i = 0; i < workoutSteps.length; i++) {
+    const step = workoutSteps[i];
+    if (step.durationType === fitDurationTypeSchema.enum.repeatUntilStepsCmplt) {
+      const startIndex = step.durationStep || 0;
+      for (let j = startIndex; j < i; j++) {
+        indices.add(j);
+      }
+    }
+  }
+  return indices;
+};
+var buildWorkoutSteps = (workoutSteps, repetitionStepIndices) => {
+  const steps = [];
+  for (let i = 0; i < workoutSteps.length; i++) {
+    const step = workoutSteps[i];
+    if (step.durationType === fitDurationTypeSchema.enum.repeatUntilStepsCmplt && step.repeatSteps) {
+      const repetitionBlock = buildRepetitionBlock(step, workoutSteps, i);
+      steps.push(repetitionBlock);
+    } else if (!repetitionStepIndices.has(i)) {
+      steps.push(mapStep(step, i));
+    }
+  }
+  return steps;
+};
+var buildRepetitionBlock = (step, workoutSteps, currentIndex) => {
+  const repeatCount = step.repeatSteps;
+  const startIndex = step.durationStep || 0;
+  const repeatedSteps = [];
+  for (let j = startIndex; j < currentIndex; j++) {
+    repeatedSteps.push(mapStep(workoutSteps[j], j));
+  }
+  return {
+    repeatCount,
+    steps: repeatedSteps
+  };
+};
+
+// src/adapters/workout/workout.mapper.ts
+var mapWorkout = (workoutMsg, workoutSteps, logger) => {
+  logger.debug("Mapping workout steps", {
+    stepCount: workoutSteps.length
+  });
+  const repetitionStepIndices = findRepetitionStepIndices(workoutSteps);
+  const steps = buildWorkoutSteps(workoutSteps, repetitionStepIndices);
+  const workout = {
+    name: workoutMsg?.wktName,
+    sport: mapSportType(workoutMsg?.sport),
+    steps
+  };
+  if (workoutMsg?.subSport !== void 0) {
+    workout.subSport = mapSubSportToKrd(workoutMsg.subSport);
+  }
+  if (workoutMsg?.poolLength !== void 0) {
+    const unit = mapLengthUnitToKrd(workoutMsg.poolLengthUnit);
+    workout.poolLength = convertLengthToMeters(workoutMsg.poolLength, unit);
+    workout.poolLengthUnit = "meters";
+  }
+  return workout;
+};
+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
+    });
+  }
+};
+
+// src/adapters/messages/workout.mapper.ts
+var KRD_VERSION2 = "1.0";
+var mapWorkoutFileToKRD = (messages, logger) => {
+  const fileId = messages[fitMessageKeySchema.enum.fileIdMesgs]?.[0];
+  const workoutMsg = messages[fitMessageKeySchema.enum.workoutMesgs]?.[0];
+  const workoutSteps = messages[fitMessageKeySchema.enum.workoutStepMesgs] || [];
+  validateMessages(fileId, workoutMsg, messages, logger);
+  const metadata = mapMetadata(fileId, workoutMsg, logger);
+  const workout = mapWorkout(workoutMsg, workoutSteps, logger);
+  const fitExtensions = extractFitExtensions(messages, logger);
+  return {
+    version: KRD_VERSION2,
+    type: fileTypeSchema.enum.structured_workout,
+    metadata,
+    extensions: { structured_workout: workout, fit: fitExtensions }
+  };
+};
+
+// 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
+  });
+  const fileType = detectFileType(messages);
+  logger.debug("Detected file type", { fileType });
+  switch (fileType) {
+    case fileTypeSchema.enum.recorded_activity:
+      return mapActivityFileToKRD(messages, logger);
+    case fileTypeSchema.enum.structured_workout:
+    default:
+      return mapWorkoutFileToKRD(messages, logger);
+  }
+};
+
+// src/adapters/garmin-fitsdk.ts
+var createGarminFitSdkReader = (logger) => async (buffer) => {
+  try {
+    logger.debug("Parsing FIT file", { bufferSize: buffer.length });
+    if (buffer.length === 0) {
+      logger.error("Empty FIT buffer");
+      throw createFitParsingError("Cannot parse empty FIT buffer");
+    }
+    const stream = Stream.fromByteArray(Array.from(buffer));
+    const decoder = new Decoder(stream);
+    const { messages, errors } = decoder.read();
+    if (errors.length > 0) {
+      logger.error("FIT parsing errors detected", { errors });
+      throw createFitParsingError(`FIT parsing errors: ${errors.join(", ")}`);
+    }
+    logger.info("FIT file parsed successfully");
+    return mapMessagesToKRD(messages, logger);
+  } catch (error) {
+    if (error instanceof Error && error.name === "FitParsingError") {
+      throw error;
+    }
+    logger.error("Failed to parse FIT file", { error });
+    throw createFitParsingError("Failed to parse FIT file", error);
+  }
+};
+var createGarminFitSdkWriter = (logger) => async (krd) => {
+  try {
+    logger.debug("Encoding KRD to FIT");
+    const encoder = new Encoder();
+    const messages = convertKRDToMessages(krd, logger);
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      try {
+        logger.debug(`Writing message ${i + 1}/${messages.length}`, {
+          mesgNum: message.mesgNum
+        });
+        encoder.writeMesg(message);
+      } catch (error) {
+        logger.error(`Failed to write message ${i + 1}`, {
+          message: JSON.stringify(message, null, 2),
+          error
+        });
+        throw error;
+      }
+    }
+    const buffer = encoder.close();
+    logger.info("KRD encoded to FIT successfully");
+    return new Uint8Array(buffer);
+  } catch (error) {
+    if (error instanceof Error && error.name === "FitParsingError") {
+      throw error;
+    }
+    logger.error("Failed to write FIT file", { error });
+    throw createFitParsingError("Failed to write FIT file", error);
+  }
+};
+
+// src/providers.ts
+var createFitProviders = (logger) => {
+  const log = logger || createConsoleLogger();
+  return {
+    fitReader: createGarminFitSdkReader(log),
+    fitWriter: createGarminFitSdkWriter(log)
+  };
+};
+
+export { createFitProviders, createGarminFitSdkReader, createGarminFitSdkWriter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map