@kaiord/zwo 4.0.0

package/dist/index.js

@@ -0,0 +1,1202 @@
+import { createZwiftParsingError, createConsoleLogger, createZwiftValidationError, intensitySchema, targetTypeSchema, targetUnitSchema, durationTypeSchema } from '@kaiord/core';
+import { XMLParser, XMLValidator, XMLBuilder } from 'fast-xml-parser';
+
+// src/providers.ts
+var detectIntervalType = (step) => {
+  if (step.target.type === targetTypeSchema.enum.open) {
+    return "FreeRide";
+  }
+  if (step.target.type === targetTypeSchema.enum.power) {
+    const powerValue = step.target.value;
+    if (powerValue.unit === targetUnitSchema.enum.range) {
+      if (step.intensity === intensitySchema.enum.warmup) {
+        return "Warmup";
+      }
+      if (step.intensity === intensitySchema.enum.cooldown) {
+        return "Cooldown";
+      }
+      return "Ramp";
+    }
+    if (powerValue.unit === targetUnitSchema.enum.percent_ftp || powerValue.unit === targetUnitSchema.enum.watts) {
+      return "SteadyState";
+    }
+  }
+  return "SteadyState";
+};
+
+// src/adapters/krd-to-zwift/text-events-encoder.ts
+var encodeTextEvents = (step) => {
+  const stepExtensions = step.extensions?.zwift;
+  const textEvents = stepExtensions?.textEvents;
+  if (!textEvents || textEvents.length === 0) {
+    return void 0;
+  }
+  if (textEvents.length === 1) {
+    const event = textEvents[0];
+    const encoded = {
+      "@_message": event.message
+    };
+    if (event.timeoffset !== void 0) {
+      encoded["@_timeoffset"] = event.timeoffset;
+    }
+    if (event.distoffset !== void 0) {
+      encoded["@_distoffset"] = event.distoffset;
+    }
+    return encoded;
+  }
+  return textEvents.map((event) => {
+    const encoded = {
+      "@_message": event.message
+    };
+    if (event.timeoffset !== void 0) {
+      encoded["@_timeoffset"] = event.timeoffset;
+    }
+    if (event.distoffset !== void 0) {
+      encoded["@_distoffset"] = event.distoffset;
+    }
+    return encoded;
+  });
+};
+
+// src/adapters/krd-to-zwift/intervals-t-encoder.ts
+var encodeDurations = (onStep, offStep, intervalsT) => {
+  if (onStep.duration.type === "time") {
+    intervalsT["@_OnDuration"] = onStep.duration.seconds;
+  } else if (onStep.duration.type === "distance") {
+    intervalsT["@_OnDuration"] = onStep.duration.meters;
+  }
+  if (offStep.duration.type === "time") {
+    intervalsT["@_OffDuration"] = offStep.duration.seconds;
+  } else if (offStep.duration.type === "distance") {
+    intervalsT["@_OffDuration"] = offStep.duration.meters;
+  }
+};
+var encodePowerTargets = (onStep, offStep, intervalsT) => {
+  if (onStep.target.type === "power" && onStep.target.value.unit === "percent_ftp") {
+    intervalsT["@_OnPower"] = onStep.target.value.value / 100;
+  }
+  if (offStep.target.type === "power" && offStep.target.value.unit === "percent_ftp") {
+    intervalsT["@_OffPower"] = offStep.target.value.value / 100;
+  }
+};
+var encodeCadenceTargets = (onStep, offStep, intervalsT) => {
+  if (onStep.target.type === "cadence" && onStep.target.value.unit === "rpm") {
+    intervalsT["@_Cadence"] = onStep.target.value.value;
+  } else {
+    const onStepExtensions = onStep.extensions?.zwift;
+    const cadence = onStepExtensions?.cadence;
+    if (cadence !== void 0) {
+      intervalsT["@_Cadence"] = cadence;
+    }
+  }
+  if (offStep.target.type === "cadence" && offStep.target.value.unit === "rpm") {
+    intervalsT["@_CadenceResting"] = offStep.target.value.value;
+  } else {
+    const offStepExtensions = offStep.extensions?.zwift;
+    const cadenceResting = offStepExtensions?.cadence;
+    if (cadenceResting !== void 0) {
+      intervalsT["@_CadenceResting"] = cadenceResting;
+    }
+  }
+};
+var encodeIntervalsT = (repetitionBlock) => {
+  const onStep = repetitionBlock.steps[0];
+  const offStep = repetitionBlock.steps[1];
+  const intervalsT = {
+    "@_Repeat": repetitionBlock.repeatCount
+  };
+  encodeDurations(onStep, offStep, intervalsT);
+  encodePowerTargets(onStep, offStep, intervalsT);
+  encodeCadenceTargets(onStep, offStep, intervalsT);
+  const textEvents = encodeTextEvents(onStep);
+  if (textEvents) {
+    intervalsT.textevent = textEvents;
+  }
+  return intervalsT;
+};
+
+// src/adapters/krd-to-zwift/duration-encoder.ts
+var encodeDuration = (step, interval, logger) => {
+  if (step.duration.type === "time") {
+    interval["@_Duration"] = step.duration.seconds;
+  } else if (step.duration.type === "distance") {
+    interval["@_Duration"] = step.duration.meters;
+    interval["@_kaiord:originalDurationType"] = "distance";
+    interval["@_kaiord:originalDurationMeters"] = step.duration.meters;
+    logger?.warn("Lossy conversion: distance duration converted to time", {
+      originalMeters: step.duration.meters,
+      convertedSeconds: step.duration.meters,
+      stepIndex: step.stepIndex
+    });
+  } else if (step.duration.type === "open") {
+    interval["@_Duration"] = 0;
+  } else {
+    interval["@_Duration"] = 300;
+    interval["@_kaiord:originalDurationType"] = step.duration.type;
+    if ("bpm" in step.duration) {
+      interval["@_kaiord:originalDurationBpm"] = step.duration.bpm;
+    } else if ("watts" in step.duration) {
+      interval["@_kaiord:originalDurationWatts"] = step.duration.watts;
+    }
+    logger?.warn("Lossy conversion: unsupported duration type", {
+      originalType: step.duration.type,
+      fallbackSeconds: 300,
+      stepIndex: step.stepIndex
+    });
+  }
+};
+
+// src/adapters/krd-to-zwift/metadata-encoder.ts
+var encodeHrRange = (step, interval, logger) => {
+  if (step.target.type === "heart_rate" && step.target.value.unit === "range") {
+    interval["@_kaiord:hrTargetLow"] = step.target.value.min;
+    interval["@_kaiord:hrTargetHigh"] = step.target.value.max;
+    logger?.warn("Lossy conversion: heart rate target not supported by Zwift", {
+      hrRange: { low: step.target.value.min, high: step.target.value.max },
+      stepIndex: step.stepIndex
+    });
+  }
+};
+var encodeHrBpm = (step, interval, logger) => {
+  if (step.target.type === "heart_rate" && step.target.value.unit === "bpm") {
+    interval["@_kaiord:hrTargetBpm"] = step.target.value.value;
+    logger?.warn("Lossy conversion: heart rate target not supported by Zwift", {
+      hrBpm: step.target.value.value,
+      stepIndex: step.stepIndex
+    });
+  }
+};
+var encodeHrZone = (step, interval, logger) => {
+  if (step.target.type === "heart_rate" && step.target.value.unit === "zone") {
+    interval["@_kaiord:hrTargetZone"] = step.target.value.value;
+    logger?.warn("Lossy conversion: heart rate target not supported by Zwift", {
+      hrZone: step.target.value.value,
+      stepIndex: step.stepIndex
+    });
+  }
+};
+var encodeHrPercentMax = (step, interval, logger) => {
+  if (step.target.type === "heart_rate" && step.target.value.unit === "percent_max") {
+    interval["@_kaiord:hrTargetPercentMax"] = step.target.value.value;
+    logger?.warn("Lossy conversion: heart rate target not supported by Zwift", {
+      hrPercentMax: step.target.value.value,
+      stepIndex: step.stepIndex
+    });
+  }
+};
+var encodeHeartRateTarget = (step, interval, logger) => {
+  encodeHrRange(step, interval, logger);
+  encodeHrBpm(step, interval, logger);
+  encodeHrZone(step, interval, logger);
+  encodeHrPercentMax(step, interval, logger);
+};
+var encodeMetadata = (step, interval) => {
+  if (step.name) {
+    interval["@_kaiord:name"] = step.name;
+  }
+  if (step.intensity) {
+    interval["@_kaiord:intensity"] = step.intensity;
+  }
+  if (step.equipment) {
+    interval["@_kaiord:equipment"] = step.equipment;
+  }
+};
+var convertZwiftPowerTarget = (ftpPercentage) => {
+  return {
+    type: targetTypeSchema.enum.power,
+    value: {
+      unit: "percent_ftp",
+      value: ftpPercentage * 100
+    }
+  };
+};
+var convertZwiftPowerRange = (powerLow, powerHigh) => {
+  return {
+    type: targetTypeSchema.enum.power,
+    value: {
+      unit: "range",
+      min: powerLow * 100,
+      max: powerHigh * 100
+    }
+  };
+};
+var convertPowerZoneToPercentFtp = (zone) => {
+  const zoneMap = {
+    1: 55,
+    2: 75,
+    3: 90,
+    4: 105,
+    5: 120,
+    6: 150,
+    7: 200
+  };
+  return zoneMap[zone] || 100;
+};
+var convertZwiftCadenceTarget = (cadence, isRunning = false) => {
+  const rpm = isRunning ? cadence / 2 : cadence;
+  return {
+    type: targetTypeSchema.enum.cadence,
+    value: {
+      unit: "rpm",
+      value: rpm
+    }
+  };
+};
+
+// src/adapters/krd-to-zwift/power-encoder.ts
+var encodeSteadyStatePowerTarget = (step, interval) => {
+  if (step.target.type !== "power") return;
+  if (step.target.value.unit === "percent_ftp") {
+    interval["@_kaiord:powerUnit"] = "percent_ftp";
+    interval["@_Power"] = step.target.value.value / 100;
+  } else if (step.target.value.unit === "zone") {
+    interval["@_kaiord:powerUnit"] = "zone";
+    interval["@_kaiord:powerZone"] = step.target.value.value;
+    const percentFtp = convertPowerZoneToPercentFtp(step.target.value.value);
+    interval["@_Power"] = percentFtp / 100;
+  } else if (step.target.value.unit === "watts") {
+    interval["@_kaiord:powerUnit"] = "watts";
+    interval["@_kaiord:originalWatts"] = step.target.value.value;
+    const assumedFtp = 250;
+    interval["@_kaiord:assumedFtp"] = assumedFtp;
+    const percentFtp = step.target.value.value / assumedFtp * 100;
+    interval["@_Power"] = percentFtp / 100;
+  }
+};
+var encodeRampPowerTarget = (step, interval, logger) => {
+  if (step.target.type !== "power") return;
+  if (step.target.value.unit === "range") {
+    let powerLow = step.target.value.min;
+    let powerHigh = step.target.value.max;
+    interval["@_kaiord:powerUnit"] = "watts";
+    const assumedFtp = 250;
+    const originalLow = powerLow;
+    const originalHigh = powerHigh;
+    powerLow = powerLow / assumedFtp * 100;
+    powerHigh = powerHigh / assumedFtp * 100;
+    interval["@_kaiord:originalWattsLow"] = originalLow;
+    interval["@_kaiord:originalWattsHigh"] = originalHigh;
+    interval["@_kaiord:assumedFtp"] = assumedFtp;
+    logger?.warn("Lossy conversion: watts converted to percent FTP", {
+      originalWatts: { low: originalLow, high: originalHigh },
+      assumedFtp,
+      convertedPercentFtp: { low: powerLow, high: powerHigh },
+      stepIndex: step.stepIndex
+    });
+    interval["@_PowerLow"] = powerLow / 100;
+    interval["@_PowerHigh"] = powerHigh / 100;
+  } else if (step.target.value.unit === "zone") {
+    interval["@_kaiord:powerUnit"] = "zone";
+    interval["@_kaiord:powerZone"] = step.target.value.value;
+    const percentFtp = convertPowerZoneToPercentFtp(step.target.value.value);
+    interval["@_PowerLow"] = percentFtp / 100;
+    interval["@_PowerHigh"] = percentFtp / 100;
+  } else if (step.target.value.unit === "percent_ftp") {
+    interval["@_kaiord:powerUnit"] = "percent_ftp";
+    interval["@_PowerLow"] = step.target.value.value / 100;
+    interval["@_PowerHigh"] = step.target.value.value / 100;
+  }
+};
+
+// src/adapters/krd-to-zwift/target-encoder.ts
+var encodeSteadyStateTargets = (step, interval) => {
+  encodeSteadyStatePowerTarget(step, interval);
+  if (step.target.type === "pace" && step.target.value.unit === "mps") {
+    interval["@_pace"] = 1e3 / step.target.value.value;
+  }
+};
+var encodeRampTargets = (step, interval, logger) => {
+  encodeRampPowerTarget(step, interval, logger);
+  if (step.target.type === "pace" && step.target.value.unit === "range") {
+    interval["@_paceLow"] = 1e3 / step.target.value.max;
+    interval["@_paceHigh"] = 1e3 / step.target.value.min;
+  }
+};
+var encodeFreeRideTargets = (step, interval) => {
+  const stepExtensions = step.extensions?.zwift;
+  const flatRoad = stepExtensions?.flatRoad || stepExtensions?.FlatRoad;
+  if (flatRoad !== void 0) {
+    interval["@_FlatRoad"] = flatRoad;
+  }
+};
+var encodeTargets = (step, intervalType, interval, logger) => {
+  if (intervalType === "SteadyState") {
+    encodeSteadyStateTargets(step, interval);
+  } else if (intervalType === "Warmup" || intervalType === "Ramp" || intervalType === "Cooldown") {
+    encodeRampTargets(step, interval, logger);
+  } else if (intervalType === "FreeRide") {
+    encodeFreeRideTargets(step, interval);
+  }
+};
+var encodeCadence = (step, interval) => {
+  if (step.target.type === "cadence" && step.target.value.unit === "rpm") {
+    interval["@_Cadence"] = step.target.value.value;
+  }
+};
+
+// src/adapters/krd-to-zwift/step-encoder.ts
+var convertStepToInterval = (step, intervalType, logger) => {
+  const interval = {};
+  encodeDuration(step, interval, logger);
+  encodeTargets(step, intervalType, interval, logger);
+  encodeCadence(step, interval);
+  encodeHeartRateTarget(step, interval, logger);
+  encodeMetadata(step, interval);
+  const textEvents = encodeTextEvents(step);
+  if (textEvents) {
+    interval.textevent = textEvents;
+  }
+  return interval;
+};
+
+// src/adapters/krd-to-zwift/intervals-encoder.ts
+var convertStepsToZwiftIntervals = (steps, logger) => {
+  const intervals = {};
+  for (const step of steps) {
+    if ("repeatCount" in step) {
+      const repetitionBlock = step;
+      if (repetitionBlock.steps.length === 2) {
+        const intervalsT = encodeIntervalsT(repetitionBlock);
+        if (!intervals.IntervalsT) {
+          intervals.IntervalsT = [];
+        }
+        intervals.IntervalsT.push(intervalsT);
+      }
+    } else {
+      const workoutStep = step;
+      const intervalType = detectIntervalType(workoutStep);
+      const interval = convertStepToInterval(workoutStep, intervalType, logger);
+      if (!intervals[intervalType]) {
+        intervals[intervalType] = [];
+      }
+      intervals[intervalType].push(interval);
+    }
+  }
+  return intervals;
+};
+
+// src/adapters/krd-to-zwift/metadata-builder.ts
+var addKrdMetadata = (workoutFile, metadata, fitExtensions) => {
+  if (metadata.created) {
+    workoutFile["@_kaiord:timeCreated"] = metadata.created;
+  }
+  if (metadata.manufacturer) {
+    workoutFile["@_kaiord:manufacturer"] = metadata.manufacturer;
+  }
+  if (metadata.product) {
+    workoutFile["@_kaiord:product"] = metadata.product;
+  }
+  if (metadata.serialNumber) {
+    workoutFile["@_kaiord:serialNumber"] = metadata.serialNumber;
+  }
+  if (fitExtensions) {
+    if (fitExtensions.type) {
+      workoutFile["@_kaiord:fitType"] = fitExtensions.type;
+    }
+    if (fitExtensions.hrm_fit_single_byte_product_id) {
+      workoutFile["@_kaiord:hrmFitProductId"] = fitExtensions.hrm_fit_single_byte_product_id;
+    }
+  }
+};
+
+// src/adapters/krd-to-zwift/workout-properties.ts
+var addWorkoutProperties = (workoutFile, workoutName, zwiftExtensions) => {
+  if (zwiftExtensions.author) {
+    workoutFile.author = zwiftExtensions.author;
+  }
+  if (workoutName) {
+    workoutFile.name = workoutName;
+  }
+  if (zwiftExtensions.description) {
+    workoutFile.description = zwiftExtensions.description;
+  }
+  if (zwiftExtensions.thresholdSecPerKm !== void 0) {
+    workoutFile.thresholdSecPerKm = zwiftExtensions.thresholdSecPerKm;
+  }
+  const tags = zwiftExtensions.tags;
+  if (tags && tags.length > 0) {
+    workoutFile.tags = {
+      tag: tags.map((name) => ({ "@_name": name })).filter((t) => t["@_name"])
+    };
+  }
+};
+var mapSportType = (sport) => {
+  return sport === "cycling" ? "bike" : sport === "running" ? "run" : "bike";
+};
+
+// src/adapters/krd-to-zwift/workout-file-builder.ts
+var buildWorkoutFile = (workoutData, zwiftExtensions, metadata, fitExtensions, logger) => {
+  const workoutFile = {};
+  addWorkoutProperties(workoutFile, workoutData.name, zwiftExtensions);
+  workoutFile.sportType = mapSportType(workoutData.sport);
+  const intervals = convertStepsToZwiftIntervals(
+    workoutData.steps || [],
+    logger
+  );
+  workoutFile.workout = intervals;
+  addKrdMetadata(workoutFile, metadata, fitExtensions);
+  return workoutFile;
+};
+
+// src/adapters/krd-to-zwift.converter.ts
+var extractWorkoutData = (krd) => {
+  const workout = krd.extensions?.structured_workout;
+  if (!workout || typeof workout !== "object") {
+    throw createZwiftParsingError("KRD missing workout in extensions");
+  }
+  return workout;
+};
+var buildXmlString = (workoutFile) => {
+  const builder = new XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    indentBy: "  "
+  });
+  const workoutFileWithNamespace = {
+    "@_xmlns:kaiord": "http://kaiord.dev/zwift-extensions/1.0",
+    ...workoutFile
+  };
+  const xmlObj = {
+    "?xml": {
+      "@_version": "1.0",
+      "@_encoding": "UTF-8"
+    },
+    workout_file: workoutFileWithNamespace
+  };
+  return builder.build(xmlObj);
+};
+var convertKRDToZwift = (krd, logger) => {
+  logger.debug("Building Zwift workout structure from KRD");
+  const workoutData = extractWorkoutData(krd);
+  const zwiftExtensions = krd.extensions?.zwift || {};
+  const workoutFile = buildWorkoutFile(
+    workoutData,
+    zwiftExtensions,
+    krd.metadata,
+    krd.extensions?.fit,
+    logger
+  );
+  const xmlString = buildXmlString(workoutFile);
+  logger.debug("Zwift XML structure built successfully");
+  return xmlString;
+};
+var validateInputZwiftXml = async (xmlString, validator, logger) => {
+  logger.debug("Validating Zwift file against XSD", {
+    xmlLength: xmlString.length
+  });
+  const validationResult = await validator(xmlString);
+  if (!validationResult.valid) {
+    logger.error("Zwift file does not conform to XSD schema", {
+      errors: validationResult.errors
+    });
+    throw createZwiftValidationError(
+      "Zwift file does not conform to XSD schema",
+      validationResult.errors
+    );
+  }
+};
+var validateGeneratedZwiftXml = async (xmlString, validator, logger) => {
+  logger.debug("Validating generated Zwift XML against XSD", {
+    xmlLength: xmlString.length
+  });
+  const validationResult = await validator(xmlString);
+  if (!validationResult.valid) {
+    logger.error("Generated Zwift XML does not conform to XSD schema", {
+      errors: validationResult.errors
+    });
+    throw createZwiftValidationError(
+      "Generated Zwift XML does not conform to XSD schema",
+      validationResult.errors
+    );
+  }
+};
+var validateZwiftStructure = (zwiftData, logger) => {
+  if (!zwiftData || typeof zwiftData !== "object" || !("workout_file" in zwiftData)) {
+    const error = createZwiftParsingError(
+      "Invalid Zwift format: missing workout_file element"
+    );
+    logger.error("Invalid Zwift structure", { error });
+    throw error;
+  }
+};
+
+// src/adapters/zwift-to-krd/intervals-extractor.ts
+var extractIntervals = (workout) => {
+  if (!workout) return [];
+  const intervals = [];
+  const intervalTypes = [
+    "SteadyState",
+    "Warmup",
+    "Ramp",
+    "Cooldown",
+    "IntervalsT",
+    "FreeRide"
+  ];
+  for (const type of intervalTypes) {
+    const data = workout[type];
+    if (data) {
+      if (Array.isArray(data)) {
+        for (const item of data) {
+          intervals.push({ type, data: item });
+        }
+      } else {
+        intervals.push({ type, data });
+      }
+    }
+  }
+  return intervals;
+};
+var extractTags = (tags) => {
+  if (!tags || !tags.tag) return [];
+  const tagArray = Array.isArray(tags.tag) ? tags.tag : [tags.tag];
+  return tagArray.map((t) => t["@_name"]);
+};
+var mapZwiftDuration = (data) => {
+  if (data["kaiord:originalDurationType"] === "distance") {
+    return {
+      type: durationTypeSchema.enum.distance,
+      meters: data["kaiord:originalDurationMeters"] || data.Duration || 0
+    };
+  }
+  if (data["kaiord:originalDurationType"] === "heart_rate_less_than") {
+    return {
+      type: durationTypeSchema.enum.heart_rate_less_than,
+      bpm: data["kaiord:originalDurationBpm"] || 0
+    };
+  }
+  if (data["kaiord:originalDurationType"] === "power_less_than") {
+    return {
+      type: durationTypeSchema.enum.power_less_than,
+      watts: data["kaiord:originalDurationWatts"] || 0
+    };
+  }
+  if (data.Duration === void 0 || data.Duration <= 0) {
+    return { type: durationTypeSchema.enum.open };
+  }
+  if (data.durationType === "distance") {
+    return {
+      type: durationTypeSchema.enum.distance,
+      meters: data.Duration
+    };
+  }
+  return {
+    type: durationTypeSchema.enum.time,
+    seconds: data.Duration
+  };
+};
+var createOnStep = (data) => {
+  const onDurationData = {
+    Duration: data.OnDuration,
+    durationType: data.durationType
+  };
+  const onDuration = mapZwiftDuration(onDurationData);
+  let onTarget;
+  if (data.OnPower !== void 0) {
+    onTarget = convertZwiftPowerTarget(data.OnPower);
+  } else if (data.Cadence !== void 0) {
+    onTarget = convertZwiftCadenceTarget(data.Cadence);
+  } else {
+    onTarget = { type: targetTypeSchema.enum.open };
+  }
+  const textEventData = extractTextEvents(data.textevent);
+  const onStep = {
+    stepIndex: data.stepIndex,
+    durationType: onDuration.type,
+    duration: onDuration,
+    targetType: onTarget.type,
+    target: onTarget,
+    intensity: intensitySchema.enum.active,
+    ...textEventData
+  };
+  if (data.OnPower !== void 0 && data.Cadence !== void 0) {
+    onStep.extensions = {
+      zwift: {
+        cadence: data.Cadence
+      }
+    };
+  }
+  return onStep;
+};
+var createOffStep = (data) => {
+  const offDurationData = {
+    Duration: data.OffDuration,
+    durationType: data.durationType
+  };
+  const offDuration = mapZwiftDuration(offDurationData);
+  let offTarget;
+  if (data.OffPower !== void 0) {
+    offTarget = convertZwiftPowerTarget(data.OffPower);
+  } else if (data.CadenceResting !== void 0) {
+    offTarget = convertZwiftCadenceTarget(data.CadenceResting);
+  } else {
+    offTarget = { type: targetTypeSchema.enum.open };
+  }
+  const offStep = {
+    stepIndex: data.stepIndex + 1,
+    durationType: offDuration.type,
+    duration: offDuration,
+    targetType: offTarget.type,
+    target: offTarget,
+    intensity: intensitySchema.enum.recovery
+  };
+  if (data.OffPower !== void 0 && data.CadenceResting !== void 0) {
+    offStep.extensions = {
+      zwift: {
+        cadence: data.CadenceResting
+      }
+    };
+  }
+  return offStep;
+};
+
+// src/adapters/interval/intervals-t.mapper.ts
+var mapIntervalsTToKrd = (data) => {
+  return {
+    repeatCount: data.Repeat,
+    steps: [createOnStep(data), createOffStep(data)]
+  };
+};
+var restoreHrRange = (data) => {
+  if (data["kaiord:hrTargetLow"] !== void 0 && data["kaiord:hrTargetHigh"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: "range",
+        min: data["kaiord:hrTargetLow"],
+        max: data["kaiord:hrTargetHigh"]
+      }
+    };
+  }
+  return null;
+};
+var restoreHrBpm = (data) => {
+  if (data["kaiord:hrTargetBpm"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: "bpm",
+        value: data["kaiord:hrTargetBpm"]
+      }
+    };
+  }
+  return null;
+};
+var restoreHrZone = (data) => {
+  if (data["kaiord:hrTargetZone"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: "zone",
+        value: data["kaiord:hrTargetZone"]
+      }
+    };
+  }
+  return null;
+};
+var restoreHrPercentMax = (data) => {
+  if (data["kaiord:hrTargetPercentMax"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.heart_rate,
+      value: {
+        unit: "percent_max",
+        value: data["kaiord:hrTargetPercentMax"]
+      }
+    };
+  }
+  return null;
+};
+var restoreHeartRateTarget = (data) => {
+  return restoreHrRange(data) || restoreHrBpm(data) || restoreHrZone(data) || restoreHrPercentMax(data) || null;
+};
+
+// src/adapters/interval/target-restoration.ts
+var restoreWattsTarget = (data) => {
+  if (data["kaiord:powerUnit"] === "watts" && data["kaiord:originalWattsLow"] !== void 0 && data["kaiord:originalWattsHigh"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: "range",
+        min: data["kaiord:originalWattsLow"],
+        max: data["kaiord:originalWattsHigh"]
+      }
+    };
+  }
+  return null;
+};
+var restoreZoneTarget = (data) => {
+  if (data["kaiord:powerUnit"] === "zone" && data["kaiord:powerZone"] !== void 0) {
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: "zone",
+        value: data["kaiord:powerZone"]
+      }
+    };
+  }
+  return null;
+};
+var restorePowerTarget = (data, powerLow, powerHigh, convertZwiftPowerRange2) => {
+  const wattsTarget = restoreWattsTarget(data);
+  if (wattsTarget) return wattsTarget;
+  const zoneTarget = restoreZoneTarget(data);
+  if (zoneTarget) return zoneTarget;
+  if (powerLow !== void 0 && powerHigh !== void 0 && convertZwiftPowerRange2) {
+    return convertZwiftPowerRange2(powerLow, powerHigh);
+  }
+  return null;
+};
+
+// src/adapters/interval/ramp-helpers.ts
+var buildRampDurationData = (data) => ({
+  Duration: data.Duration,
+  durationType: data.durationType,
+  "kaiord:originalDurationType": data["kaiord:originalDurationType"],
+  "kaiord:originalDurationMeters": data["kaiord:originalDurationMeters"],
+  "kaiord:originalDurationBpm": data["kaiord:originalDurationBpm"],
+  "kaiord:originalDurationWatts": data["kaiord:originalDurationWatts"]
+});
+var resolveRampTarget = (data) => {
+  const powerTarget = restorePowerTarget(
+    data,
+    data.PowerLow,
+    data.PowerHigh,
+    convertZwiftPowerRange
+  );
+  const hrTarget = restoreHeartRateTarget(data);
+  return powerTarget || hrTarget || { type: targetTypeSchema.enum.open };
+};
+var resolveIntensity = (data, defaultIntensity) => {
+  return data["kaiord:intensity"] || defaultIntensity;
+};
+var addRampMetadata = (step, data) => {
+  if (data["kaiord:name"]) step.name = data["kaiord:name"];
+  if (data["kaiord:equipment"]) {
+    step.equipment = data["kaiord:equipment"];
+  }
+};
+
+// src/adapters/interval/ramp.mapper.ts
+var mapWarmupToKrd = (data) => {
+  return mapRampToKrd(data, intensitySchema.enum.warmup);
+};
+var mapRampToKrd = (data, intensity = intensitySchema.enum.active) => {
+  const duration = mapZwiftDuration(buildRampDurationData(data));
+  const target = resolveRampTarget(data);
+  const textEventData = extractTextEvents(
+    data.textevent
+  );
+  const step = {
+    stepIndex: data.stepIndex,
+    durationType: duration.type,
+    duration,
+    targetType: target.type,
+    target,
+    intensity: resolveIntensity(data, intensity),
+    ...textEventData
+  };
+  addRampMetadata(step, data);
+  return step;
+};
+var mapCooldownToKrd = (data) => {
+  return mapRampToKrd(data, intensitySchema.enum.cooldown);
+};
+var restoreSteadyStateTarget = (data) => {
+  if (data["kaiord:powerUnit"] === "watts" && data["kaiord:originalWatts"]) {
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: "watts",
+        value: data["kaiord:originalWatts"]
+      }
+    };
+  }
+  if (data["kaiord:powerUnit"] === "zone" && data["kaiord:powerZone"]) {
+    return {
+      type: targetTypeSchema.enum.power,
+      value: {
+        unit: "zone",
+        value: data["kaiord:powerZone"]
+      }
+    };
+  }
+  if (data.Power !== void 0) {
+    return convertZwiftPowerTarget(data.Power);
+  }
+  const hrTarget = restoreHeartRateTarget(data);
+  return hrTarget || { type: targetTypeSchema.enum.open };
+};
+var mapSteadyStateToKrd = (data) => {
+  const durationData = {
+    Duration: data.Duration,
+    durationType: data.durationType,
+    "kaiord:originalDurationType": data["kaiord:originalDurationType"],
+    "kaiord:originalDurationMeters": data["kaiord:originalDurationMeters"],
+    "kaiord:originalDurationBpm": data["kaiord:originalDurationBpm"],
+    "kaiord:originalDurationWatts": data["kaiord:originalDurationWatts"]
+  };
+  const duration = mapZwiftDuration(durationData);
+  const target = restoreSteadyStateTarget(data);
+  const textEventData = extractTextEvents(data.textevent);
+  const step = {
+    stepIndex: data.stepIndex,
+    durationType: duration.type,
+    duration,
+    targetType: target.type,
+    target,
+    intensity: data["kaiord:intensity"] || intensitySchema.enum.active,
+    ...textEventData
+  };
+  if (data["kaiord:name"]) {
+    step.name = data["kaiord:name"];
+  }
+  if (data["kaiord:equipment"]) {
+    step.equipment = data["kaiord:equipment"];
+  }
+  return step;
+};
+
+// src/adapters/interval/index.ts
+var extractTextEvents = (textevent) => {
+  if (!textevent) {
+    return {};
+  }
+  const events = Array.isArray(textevent) ? textevent : [textevent];
+  if (events.length === 0) {
+    return {};
+  }
+  const primaryMessage = events[0].message;
+  const result = {};
+  if (primaryMessage) {
+    result.notes = primaryMessage;
+  }
+  if (events.length > 0) {
+    result.extensions = {
+      zwift: {
+        textEvents: events
+      }
+    };
+  }
+  return result;
+};
+
+// src/adapters/interval/free-ride.mapper.ts
+var mapFreeRideToKrd = (data) => {
+  const durationData = {
+    Duration: data.Duration,
+    durationType: data.durationType
+  };
+  const duration = mapZwiftDuration(durationData);
+  const textEventData = extractTextEvents(data.textevent);
+  const step = {
+    stepIndex: data.stepIndex,
+    durationType: duration.type,
+    duration,
+    targetType: targetTypeSchema.enum.open,
+    target: { type: targetTypeSchema.enum.open },
+    intensity: intensitySchema.enum.active,
+    ...textEventData
+  };
+  const flatRoad = data["@_FlatRoad"] ?? data.FlatRoad;
+  if (flatRoad !== void 0) {
+    step.extensions = {
+      ...step.extensions,
+      zwift: {
+        ...step.extensions?.zwift || {},
+        FlatRoad: flatRoad
+      }
+    };
+  }
+  return step;
+};
+
+// src/adapters/zwift-to-krd/intervals-processor.ts
+var normalizeAttributeNames = (data) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(data)) {
+    const normalizedKey = key.startsWith("@_") ? key.substring(2) : key;
+    normalized[normalizedKey] = value;
+  }
+  return normalized;
+};
+var processSingleStep = (interval, stepIndex, durationType) => {
+  const normalizedData = normalizeAttributeNames(interval.data);
+  const data = { ...normalizedData, stepIndex, durationType };
+  if (interval.type === "SteadyState") {
+    return { step: mapSteadyStateToKrd(data), indexIncrement: 1 };
+  } else if (interval.type === "Warmup") {
+    return { step: mapWarmupToKrd(data), indexIncrement: 1 };
+  } else if (interval.type === "Ramp") {
+    return { step: mapRampToKrd(data), indexIncrement: 1 };
+  } else if (interval.type === "Cooldown") {
+    return { step: mapCooldownToKrd(data), indexIncrement: 1 };
+  } else if (interval.type === "FreeRide") {
+    return { step: mapFreeRideToKrd(data), indexIncrement: 1 };
+  }
+  throw new Error(`Unknown interval type: ${interval.type}`);
+};
+var processInterval = (interval, stepIndex, durationType) => {
+  if (interval.type === "IntervalsT") {
+    const normalizedData = normalizeAttributeNames(interval.data);
+    const repetitionBlock = mapIntervalsTToKrd({
+      ...normalizedData,
+      stepIndex,
+      durationType
+    });
+    return {
+      step: repetitionBlock,
+      indexIncrement: repetitionBlock.steps.length
+    };
+  }
+  return processSingleStep(interval, stepIndex, durationType);
+};
+var processIntervals = (intervals, durationType) => {
+  const steps = [];
+  let stepIndex = 0;
+  for (const interval of intervals) {
+    const result = processInterval(interval, stepIndex, durationType);
+    steps.push(result.step);
+    stepIndex += result.indexIncrement;
+  }
+  return steps;
+};
+
+// src/adapters/zwift-to-krd/metadata-extractor.ts
+var extractMetadata = (workoutFile, sport) => ({
+  created: workoutFile["@_kaiord:timeCreated"] || (/* @__PURE__ */ new Date()).toISOString(),
+  sport,
+  manufacturer: workoutFile["@_kaiord:manufacturer"],
+  product: workoutFile["@_kaiord:product"],
+  serialNumber: workoutFile["@_kaiord:serialNumber"]
+});
+var extractFitExtensions = (workoutFile) => {
+  if (workoutFile["@_kaiord:fitType"] || workoutFile["@_kaiord:hrmFitProductId"]) {
+    return {
+      type: workoutFile["@_kaiord:fitType"],
+      hrm_fit_single_byte_product_id: workoutFile["@_kaiord:hrmFitProductId"]
+    };
+  }
+  return void 0;
+};
+
+// src/adapters/zwift-to-krd.converter.ts
+var convertZwiftToKRD = (zwiftData, logger) => {
+  logger.debug("Converting Zwift to KRD");
+  const workoutFile = zwiftData.workout_file;
+  const sport = workoutFile.sportType === "bike" ? "cycling" : workoutFile.sportType === "run" ? "running" : "generic";
+  const durationType = workoutFile.durationType === "distance" ? "distance" : "time";
+  const intervals = extractIntervals(workoutFile.workout);
+  const steps = processIntervals(intervals, durationType);
+  const metadata = extractMetadata(workoutFile, sport);
+  const fitExtensions = extractFitExtensions(workoutFile);
+  const extensions = {
+    structured_workout: {
+      name: workoutFile.name,
+      sport,
+      steps
+    },
+    zwift: {
+      author: workoutFile.author,
+      description: workoutFile.description,
+      durationType,
+      thresholdSecPerKm: workoutFile.thresholdSecPerKm,
+      tags: extractTags(workoutFile.tags)
+    }
+  };
+  if (fitExtensions) {
+    extensions.fit = fitExtensions;
+  }
+  return {
+    version: "1.0",
+    type: "structured_workout",
+    metadata,
+    extensions
+  };
+};
+
+// src/adapters/fast-xml-parser.ts
+var parseZwiftXml = (xmlString, logger) => {
+  logger.debug("Parsing Zwift file");
+  try {
+    const parser = new XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      parseAttributeValue: true
+    });
+    return parser.parse(xmlString);
+  } catch (error) {
+    logger.error("Failed to parse Zwift XML", { error });
+    throw createZwiftParsingError("Failed to parse Zwift file", error);
+  }
+};
+var createFastXmlZwiftReader = (logger, validator) => async (xmlString) => {
+  await validateInputZwiftXml(xmlString, validator, logger);
+  const zwiftData = parseZwiftXml(xmlString, logger);
+  validateZwiftStructure(zwiftData, logger);
+  logger.info("Zwift file parsed successfully");
+  return convertZwiftToKRD(zwiftData, logger);
+};
+var createFastXmlZwiftWriter = (logger, validator) => async (krd) => {
+  logger.debug("Converting KRD to Zwift format");
+  let xmlString;
+  try {
+    xmlString = convertKRDToZwift(krd, logger);
+  } catch (error) {
+    logger.error("Failed to convert KRD to Zwift", { error });
+    throw createZwiftParsingError("Failed to convert KRD to Zwift", error);
+  }
+  await validateGeneratedZwiftXml(xmlString, validator, logger);
+  logger.info("KRD to Zwift conversion successful");
+  return xmlString;
+};
+var validateXmlWellFormedness = (xmlString, logger) => {
+  const xmlValidation = XMLValidator.validate(xmlString, {
+    allowBooleanAttributes: true
+  });
+  if (xmlValidation !== true) {
+    logger.warn("Zwift XML well-formedness validation failed", {
+      error: xmlValidation.err
+    });
+    return {
+      valid: false,
+      errors: [
+        {
+          field: `line ${xmlValidation.err.line}`,
+          message: `XML validation failed: ${xmlValidation.err.msg}`
+        }
+      ]
+    };
+  }
+  return null;
+};
+
+// src/adapters/well-formedness-validator.ts
+var createWellFormednessValidator = (logger) => async (xmlString) => {
+  try {
+    logger.debug("Validating Zwift XML well-formedness (browser mode)");
+    const wellFormednessError = validateXmlWellFormedness(xmlString, logger);
+    if (wellFormednessError) {
+      return wellFormednessError;
+    }
+    logger.info(
+      "Zwift XML validated successfully (well-formedness only, XSD validation skipped in browser)"
+    );
+    return { valid: true, errors: [] };
+  } catch (error) {
+    logger.error("Zwift well-formedness validation failed", { error });
+    return {
+      valid: false,
+      errors: [
+        {
+          field: "root",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }
+      ]
+    };
+  }
+};
+
+// src/adapters/node-modules-loader.ts
+var isNode = typeof process !== "undefined" && (process.versions?.node || typeof process.env !== "undefined");
+var validateXML = null;
+var XSD_SCHEMA_PATH = null;
+var loadNodeModules = async () => {
+  if (!isNode) {
+    throw new Error("XSD validation is only available in Node.js environments");
+  }
+  if (validateXML && XSD_SCHEMA_PATH) {
+    return { validateXML, XSD_SCHEMA_PATH };
+  }
+  const { createRequire } = await import('module');
+  const { dirname, join } = await import('path');
+  const { fileURLToPath } = await import('url');
+  const require2 = createRequire(import.meta.url);
+  const { validateXML: validateXMLFn } = require2("xsd-schema-validator");
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const schemaPath = join(__dirname, "../schema/zwift-workout.xsd");
+  validateXML = validateXMLFn;
+  XSD_SCHEMA_PATH = schemaPath;
+  return { validateXML, XSD_SCHEMA_PATH };
+};
+
+// src/adapters/xsd-schema-validator.ts
+var validateAgainstXsdSchema = async (xmlString, logger) => {
+  const { validateXML: validateXMLFn, XSD_SCHEMA_PATH: schemaPath } = await loadNodeModules();
+  const xsdValidationResult = await validateXMLFn(xmlString, schemaPath);
+  if (!xsdValidationResult.valid) {
+    logger.warn("Zwift XSD validation failed", {
+      messages: xsdValidationResult.messages
+    });
+    return {
+      valid: false,
+      errors: xsdValidationResult.messages.map((msg) => ({
+        field: "schema",
+        message: msg
+      }))
+    };
+  }
+  return null;
+};
+
+// src/adapters/xsd-validator.ts
+var isBrowser = (() => {
+  try {
+    return typeof globalThis.window !== "undefined";
+  } catch {
+    return false;
+  }
+})();
+var createZwiftValidator = (logger) => {
+  if (isBrowser) {
+    logger.info(
+      "Browser environment detected, using well-formedness validation for Zwift XML (XSD validation not available)"
+    );
+    return createWellFormednessValidator(logger);
+  }
+  return createXsdZwiftValidator(logger);
+};
+var createXsdZwiftValidator = (logger) => async (xmlString) => {
+  try {
+    logger.debug("Validating Zwift XML structure");
+    const wellFormednessError = validateXmlWellFormedness(xmlString, logger);
+    if (wellFormednessError) {
+      return wellFormednessError;
+    }
+    logger.debug(
+      "XML well-formedness validated, proceeding with XSD validation"
+    );
+    const xsdError = await validateAgainstXsdSchema(xmlString, logger);
+    if (xsdError) {
+      return xsdError;
+    }
+    logger.info("Zwift XML validated successfully against XSD schema");
+    return { valid: true, errors: [] };
+  } catch (error) {
+    logger.error("Zwift validation failed", { error });
+    return {
+      valid: false,
+      errors: [
+        {
+          field: "root",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }
+      ]
+    };
+  }
+};
+
+// src/providers.ts
+var createZwoProviders = (logger) => {
+  const log = logger || createConsoleLogger();
+  const zwiftValidator = createZwiftValidator(log);
+  return {
+    zwiftReader: createFastXmlZwiftReader(log, zwiftValidator),
+    zwiftWriter: createFastXmlZwiftWriter(log, zwiftValidator),
+    zwiftValidator
+  };
+};
+
+export { createFastXmlZwiftReader, createFastXmlZwiftWriter, createXsdZwiftValidator, createZwiftValidator, createZwoProviders };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map