@murphai/murph 1.3.1 → 1.3.2

package/node_modules/@murphai/importers/dist/device-providers/junction-bounded-features.js

@@ -4,10 +4,11 @@ import { resolveJunctionOrigin } from "./junction-origin.js";
 import { stableStringify } from "./raw-ingest-receipt.js";
 import { asPlainObject, finiteNumber, stringId } from "./shared-normalization.js";
 export const JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA = "junction.ecg_voltage_feature.v1";
-export const JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA = "junction.workout_stream_feature.v1";
+export const JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA = "junction.workout_stream_feature.v2";
 const ECG_IDS = ["junctionGroupId", "recordingId", "recording_id"];
 const WORKOUT_IDS = ["workoutId", "workout_id", "id"];
 const MAX_FEATURE_BYTES = 16_384;
+const MAX_WORKOUT_SPLITS = 64;
 const ECG_FIELDS = new Set([
     "schema", "id", "recordingId", "sessionStart", "sessionEnd",
     "durationSeconds", "voltageSampleCount", "voltageUnit", "voltageMin", "voltageMax",
@@ -17,8 +18,24 @@ const ECG_FIELDS = new Set([
 const WORKOUT_FIELDS = new Set([
     "schema", "id", "workoutId", "sport", "startAt", "endAt",
     "durationSeconds", "distanceMeters", "averageHeartRate", "maxHeartRate",
-    "sampleCount", "sourceProviderSlug", "sourceType", "sourceInstanceId",
+    "firstHalfAverageHeartRate", "secondHalfAverageHeartRate",
+    "averageCadence", "maxCadence", "cadenceUnit", "averagePower", "maxPower",
+    "averageSpeed", "maxSpeed", "sampleCount", "splits", "version",
+    "workoutDayKey",
+    "sourceProviderSlug", "sourceType", "sourceInstanceId",
 ]);
+const WORKOUT_SPLIT_FIELDS = new Set([
+    "index", "distanceMeters", "durationSeconds", "endedAt",
+    "averageHeartRate", "averageCadence", "cadenceUnit", "averagePower",
+]);
+export class JunctionWorkoutStreamTimestampCardinalityError extends TypeError {
+    diagnostic;
+    constructor(diagnostic) {
+        super(`Junction workout stream must contain 1-${diagnostic.maxTimestampCount} timestamps.`);
+        this.name = "JunctionWorkoutStreamTimestampCardinalityError";
+        this.diagnostic = Object.freeze({ ...diagnostic });
+    }
+}
 export function reduceJunctionElectrocardiogramVoltageRecords(records, limits) {
     positiveInteger(limits.maxRecordings, "ECG recording limit");
     positiveInteger(limits.maxSamples, "ECG sample limit");
@@ -75,35 +92,50 @@ export function reduceJunctionWorkoutStreamPayload(input) {
     const summary = record(input.summary, "workout summary");
     const stream = record(input.stream, "workout stream");
     const times = array(stream.time, "workout time");
-    if (times.length === 0 || times.length > input.maxSamples) {
-        invalid(`workout stream must contain 1-${input.maxSamples} timestamps`);
+    if (times.length === 0) {
+        throw new JunctionWorkoutStreamTimestampCardinalityError({
+            kind: "empty",
+            maxTimestampCount: input.maxSamples,
+            timestampCount: 0,
+        });
     }
-    const heartRateSeries = parallelArray(stream.heartrate, times.length, "heartrate");
+    if (times.length > input.maxSamples) {
+        throw new JunctionWorkoutStreamTimestampCardinalityError({
+            kind: "over_limit",
+            maxTimestampCount: input.maxSamples,
+            timestampCount: times.length,
+        });
+    }
+    const heartRateSeries = parallelArray(stream.heartrate ?? stream.heart_rate, times.length, "heartrate");
     const distanceSeries = parallelArray(stream.distance, times.length, "distance");
-    if (heartRateSeries.cardinalityMismatch || distanceSeries.cardinalityMismatch) {
+    const cadenceSeries = parallelArray(stream.cadence, times.length, "cadence");
+    const powerSeries = parallelArray(stream.power, times.length, "power");
+    const speedSeries = parallelArray(stream.velocity_smooth, times.length, "velocity_smooth");
+    if (heartRateSeries.cardinalityMismatch
+        || distanceSeries.cardinalityMismatch
+        || cadenceSeries.cardinalityMismatch
+        || powerSeries.cardinalityMismatch
+        || speedSeries.cardinalityMismatch) {
         return undefined;
     }
     const heartRates = heartRateSeries.values;
     const distances = distanceSeries.values;
-    if (!heartRates && !distances)
+    const cadence = cadenceSeries.values;
+    const power = powerSeries.values;
+    const speeds = speedSeries.values;
+    const sport = firstString(summary, ["sport.slug", "sportSlug", "sport_slug", "sport.name", "sport"]);
+    const cadenceUnit = resolveWorkoutCadenceUnit(sport);
+    if (!heartRates && !distances && !(cadence && cadenceUnit) && !power && !speeds) {
         invalid("workout stream had no supported metrics");
-    let firstMs = Number.POSITIVE_INFINITY;
+    }
+    const points = [];
     let lastMs = Number.NEGATIVE_INFINITY;
-    let maximum = Number.NEGATIVE_INFINITY;
-    let average = 0;
-    let heartRateCount = 0;
+    let lastDistance = Number.NEGATIVE_INFINITY;
     let distanceMeters;
     for (let index = 0; index < times.length; index += 1) {
         const at = timestampMs(times[index]);
-        firstMs = Math.min(firstMs, at);
-        lastMs = Math.max(lastMs, at);
-        const heartRate = optionalNumber(heartRates?.[index], "heart rate");
-        if (heartRate !== undefined) {
-            if (heartRate < 20 || heartRate > 300)
-                invalid("heart rate was invalid");
-            heartRateCount += 1;
-            maximum = Math.max(maximum, heartRate);
-            average += (heartRate - average) / heartRateCount;
+        if (at < lastMs) {
+            invalid("workout timestamps were not monotonic");
         }
         const distance = optionalNumber(distances?.[index], "distance");
         if (distance !== undefined) {
@@ -111,31 +143,68 @@ export function reduceJunctionWorkoutStreamPayload(input) {
                 invalid("workout distance was negative");
             distanceMeters = Math.max(distanceMeters ?? 0, distance);
         }
+        const pointDistance = distance !== undefined && distance >= lastDistance
+            ? distance
+            : undefined;
+        if (pointDistance !== undefined) {
+            lastDistance = pointDistance;
+        }
+        points.push(stripUndefined({
+            distanceMeters: pointDistance,
+            index,
+            timeMs: at,
+        }));
+        lastMs = at;
+    }
+    const firstMs = points[0]?.timeMs;
+    const finalMs = points.at(-1)?.timeMs;
+    if (firstMs === undefined || finalMs === undefined) {
+        invalid("workout stream was empty");
     }
+    const heartRateStats = workoutSeriesStats(heartRates, points, "heart rate", 20, 300, true);
     const workoutId = consistentId(summary, WORKOUT_IDS, "workout summary");
     const origin = resolveJunctionOrigin(summary);
     if (!workoutId || !origin.sourceProviderSlug) {
         invalid("workout summary lacked identity");
     }
+    const cadenceStats = cadenceUnit
+        ? workoutSeriesStats(cadence, points, "cadence", 0, 400)
+        : undefined;
+    const powerStats = workoutSeriesStats(power, points, "power", 0, 5_000);
+    const speedStats = workoutSeriesStats(speeds, points, "speed", 0, 150);
+    const startAtRaw = firstString(summary, ["time_start", "timeStart", "startAt", "start_at", "start"]);
     const startAt = firstTimestamp(summary, ["time_start", "timeStart", "startAt", "start_at", "start"])
         ?? new Date(firstMs).toISOString();
     const endAt = firstTimestamp(summary, ["time_end", "timeEnd", "endAt", "end_at", "end"])
-        ?? new Date(lastMs).toISOString();
+        ?? new Date(finalMs).toISOString();
     const durationSeconds = (Date.parse(endAt) - Date.parse(startAt)) / 1_000;
     if (durationSeconds < 0)
         invalid("workout duration was invalid");
+    const splits = buildWorkoutSplits(stream, points, sport);
     const feature = stripUndefined({
         schema: JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA,
         id: workoutId,
         workoutId,
-        sport: firstString(summary, ["sport.slug", "sportSlug", "sport_slug", "sport.name", "sport"]),
+        sport,
         startAt,
         endAt,
         durationSeconds: round(durationSeconds),
         distanceMeters: distanceMeters === undefined ? undefined : round(distanceMeters),
-        averageHeartRate: heartRateCount ? round(average) : undefined,
-        maxHeartRate: heartRateCount ? round(maximum) : undefined,
+        averageHeartRate: heartRateStats?.average,
+        maxHeartRate: heartRateStats?.maximum,
+        firstHalfAverageHeartRate: heartRateStats?.firstHalfAverage,
+        secondHalfAverageHeartRate: heartRateStats?.secondHalfAverage,
+        averageCadence: cadenceStats?.average,
+        maxCadence: cadenceStats?.maximum,
+        cadenceUnit: cadenceStats ? cadenceUnit : undefined,
+        averagePower: powerStats?.average,
+        maxPower: powerStats?.maximum,
+        averageSpeed: speedStats?.average,
+        maxSpeed: speedStats?.maximum,
         sampleCount: times.length,
+        splits,
+        version: firstTimestamp(summary, ["updated_at", "updatedAt"]) ?? endAt,
+        workoutDayKey: resolveWorkoutDayKey(summary, startAtRaw, startAt),
         sourceProviderSlug: origin.sourceProviderSlug,
         sourceType: origin.sourceType,
         sourceInstanceId: origin.sourceInstanceId ?? undefined,
@@ -143,6 +212,256 @@ export function reduceJunctionWorkoutStreamPayload(input) {
     assertFeature("workout_stream", feature);
     return feature;
 }
+function workoutSeriesStats(values, points, label, minimum, maximum, includeHalves = false) {
+    if (!values || points.length === 0) {
+        return undefined;
+    }
+    const midpoint = (points[0]?.timeMs ?? 0)
+        + ((points.at(-1)?.timeMs ?? 0) - (points[0]?.timeMs ?? 0)) / 2;
+    let average = 0;
+    let count = 0;
+    let highest = Number.NEGATIVE_INFINITY;
+    let firstHalfAverage = 0;
+    let firstHalfCount = 0;
+    let secondHalfAverage = 0;
+    let secondHalfCount = 0;
+    for (const point of points) {
+        const value = optionalNumber(values[point.index], label);
+        if (value === undefined) {
+            continue;
+        }
+        if (value < minimum || value > maximum) {
+            invalid(`${label} was invalid`);
+        }
+        count += 1;
+        average += (value - average) / count;
+        highest = Math.max(highest, value);
+        if (includeHalves && point.timeMs < midpoint) {
+            firstHalfCount += 1;
+            firstHalfAverage += (value - firstHalfAverage) / firstHalfCount;
+        }
+        else if (includeHalves) {
+            secondHalfCount += 1;
+            secondHalfAverage += (value - secondHalfAverage) / secondHalfCount;
+        }
+    }
+    return count === 0
+        ? undefined
+        : stripUndefined({
+            average: round(average),
+            firstHalfAverage: firstHalfCount > 0 ? round(firstHalfAverage) : undefined,
+            maximum: round(highest),
+            secondHalfAverage: secondHalfCount > 0 ? round(secondHalfAverage) : undefined,
+        });
+}
+function buildWorkoutSplits(stream, points, sport) {
+    const distancePoints = points.filter((point) => point.distanceMeters !== undefined);
+    const firstPoint = distancePoints[0];
+    const lastPoint = distancePoints.at(-1);
+    if (!firstPoint || !lastPoint || distancePoints.length < 2) {
+        return [];
+    }
+    const splitDistanceMeters = sport?.toLowerCase().includes("swim") ? 100 : 1_000;
+    const firstBoundaryIndex = Math.ceil(firstPoint.distanceMeters / splitDistanceMeters);
+    const firstSplitIndex = firstBoundaryIndex + 1;
+    const lastSplitIndex = Math.floor(lastPoint.distanceMeters / splitDistanceMeters);
+    if (firstSplitIndex > lastSplitIndex) {
+        return [];
+    }
+    const firstBoundary = findWorkoutSplitBoundary(distancePoints, firstBoundaryIndex * splitDistanceMeters, 1);
+    if (!firstBoundary) {
+        return [];
+    }
+    const heartRates = parallelArray(stream.heartrate ?? stream.heart_rate, points.length, "heartrate").values;
+    const cadence = parallelArray(stream.cadence, points.length, "cadence").values;
+    const power = parallelArray(stream.power, points.length, "power").values;
+    const cadenceUnit = resolveWorkoutCadenceUnit(sport);
+    const splits = [];
+    let previousBoundaryTimeMs = firstBoundary.timeMs;
+    let searchIndex = firstBoundary.searchIndex;
+    for (let splitIndex = firstSplitIndex; splitIndex <= lastSplitIndex && splits.length < MAX_WORKOUT_SPLITS; splitIndex += 1) {
+        const boundary = findWorkoutSplitBoundary(distancePoints, splitIndex * splitDistanceMeters, searchIndex);
+        if (!boundary) {
+            break;
+        }
+        const durationSeconds = (boundary.timeMs - previousBoundaryTimeMs) / 1_000;
+        if (durationSeconds > 0) {
+            const averageCadence = cadenceUnit
+                ? workoutSeriesWindowAverage(cadence, points, previousBoundaryTimeMs, boundary.timeMs, splits.length === 0, "cadence", 0, 400)
+                : undefined;
+            splits.push(stripUndefined({
+                index: splitIndex,
+                distanceMeters: splitDistanceMeters,
+                durationSeconds: round(durationSeconds),
+                endedAt: new Date(boundary.timeMs).toISOString(),
+                averageHeartRate: workoutSeriesWindowAverage(heartRates, points, previousBoundaryTimeMs, boundary.timeMs, splits.length === 0, "heart rate", 20, 300),
+                averageCadence,
+                cadenceUnit: averageCadence === undefined ? undefined : cadenceUnit,
+                averagePower: workoutSeriesWindowAverage(power, points, previousBoundaryTimeMs, boundary.timeMs, splits.length === 0, "power", 0, 5_000),
+            }));
+        }
+        previousBoundaryTimeMs = boundary.timeMs;
+        searchIndex = boundary.searchIndex;
+    }
+    return splits;
+}
+function workoutSeriesWindowAverage(values, points, startTimeMs, endTimeMs, includeStart, label, minimum, maximum) {
+    if (!values) {
+        return undefined;
+    }
+    let average = 0;
+    let count = 0;
+    for (const point of points) {
+        if ((includeStart ? point.timeMs < startTimeMs : point.timeMs <= startTimeMs)
+            || point.timeMs > endTimeMs) {
+            continue;
+        }
+        const value = optionalNumber(values[point.index], label);
+        if (value === undefined) {
+            continue;
+        }
+        if (value < minimum || value > maximum) {
+            invalid(`${label} was invalid`);
+        }
+        count += 1;
+        average += (value - average) / count;
+    }
+    return count > 0 ? round(average) : undefined;
+}
+function findWorkoutSplitBoundary(points, targetDistance, initialSearchIndex) {
+    let searchIndex = Math.max(1, initialSearchIndex);
+    while (searchIndex < points.length
+        && (points[searchIndex]?.distanceMeters ?? Number.NEGATIVE_INFINITY) < targetDistance) {
+        searchIndex += 1;
+    }
+    const upper = points[searchIndex];
+    const lower = points[Math.max(0, searchIndex - 1)];
+    if (!lower
+        || !upper
+        || upper.distanceMeters < targetDistance
+        || lower.distanceMeters > targetDistance) {
+        return undefined;
+    }
+    if (lower.distanceMeters === targetDistance) {
+        return { searchIndex, timeMs: lower.timeMs };
+    }
+    const distanceSpan = upper.distanceMeters - lower.distanceMeters;
+    const timeMs = distanceSpan <= 0
+        ? upper.timeMs
+        : lower.timeMs + (upper.timeMs - lower.timeMs)
+            * Math.max(0, Math.min(1, (targetDistance - lower.distanceMeters) / distanceSpan));
+    return { searchIndex, timeMs };
+}
+function resolveWorkoutCadenceUnit(sport) {
+    const normalized = sport?.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-");
+    if (!normalized) {
+        return undefined;
+    }
+    if (/(?:^|-)(?:hike|hiking|run|running|walk|walking)(?:-|$)/u.test(normalized)) {
+        return "steps-per-minute";
+    }
+    return /(?:^|-)(?:bike|biking|cycle|cycling|ride|riding|spin|spinning)(?:-|$)/u
+        .test(normalized)
+        ? "rpm"
+        : undefined;
+}
+const WORKOUT_LOCAL_DATE_PATHS = [
+    "calendarDate",
+    "calendar_date",
+    "localDate",
+    "local_date",
+];
+const WORKOUT_OFFSET_MINUTE_PATHS = [
+    "timeZoneOffsetMinutes",
+    "time_zone_offset_minutes",
+    "timezoneOffsetMinutes",
+    "timezone_offset_minutes",
+    "utcOffsetMinutes",
+    "utc_offset_minutes",
+];
+const WORKOUT_OFFSET_SECOND_PATHS = [
+    "timezone_offset",
+    "timezoneOffset",
+    "timeZoneOffset",
+    "time_zone_offset",
+    "timezoneOffsetSeconds",
+    "timezone_offset_seconds",
+    "timeZoneOffsetSeconds",
+    "time_zone_offset_seconds",
+    "utcOffsetSeconds",
+    "utc_offset_seconds",
+];
+function resolveWorkoutDayKey(summary, startAtRaw, startAt) {
+    for (const path of WORKOUT_LOCAL_DATE_PATHS) {
+        const dayKey = strictDayKey(firstString(summary, [path]));
+        if (dayKey) {
+            return dayKey;
+        }
+    }
+    if (!startAtRaw) {
+        return undefined;
+    }
+    const explicitSemantics = firstString(summary, [
+        "timestampSemantics",
+        "timestamp_semantics",
+    ]);
+    const semantics = explicitSemantics === "utc"
+        || explicitSemantics === "offset"
+        || explicitSemantics === "floating"
+        || explicitSemantics === "unknown"
+        ? explicitSemantics
+        : /z$/iu.test(startAtRaw)
+            ? "utc"
+            : /[+-]\d{2}:?\d{2}$/u.test(startAtRaw)
+                ? "offset"
+                : /^\d{4}-\d{2}-\d{2}(?:$|[ t]\d{2}:\d{2})/iu.test(startAtRaw)
+                    ? "floating"
+                    : "unknown";
+    if (semantics === "offset" || semantics === "floating") {
+        return strictDayKey(startAtRaw);
+    }
+    const offsetSeconds = firstWorkoutOffset(summary, WORKOUT_OFFSET_MINUTE_PATHS, 60)
+        ?? firstWorkoutOffset(summary, WORKOUT_OFFSET_SECOND_PATHS, 1);
+    if (offsetSeconds === undefined || Math.abs(offsetSeconds) > 24 * 60 * 60) {
+        return undefined;
+    }
+    const startMs = Date.parse(startAt);
+    return Number.isFinite(startMs)
+        ? new Date(startMs + offsetSeconds * 1_000).toISOString().slice(0, 10)
+        : undefined;
+}
+function firstWorkoutOffset(summary, paths, numericMultiplier) {
+    for (const path of paths) {
+        const value = readPath(summary, path);
+        const numeric = finiteNumber(value);
+        if (numeric !== undefined) {
+            return numeric * numericMultiplier;
+        }
+        if (typeof value !== "string") {
+            continue;
+        }
+        const match = /^([+-])(\d{2}):?(\d{2})$/u.exec(value.trim());
+        if (!match) {
+            continue;
+        }
+        const hours = Number(match[2]);
+        const minutes = Number(match[3]);
+        if (hours <= 24 && minutes <= 59) {
+            return (match[1] === "-" ? -1 : 1) * (hours * 60 + minutes) * 60;
+        }
+    }
+    return undefined;
+}
+function strictDayKey(value) {
+    const dayKey = /^\d{4}-\d{2}-\d{2}/u.exec(value ?? "")?.[0];
+    if (!dayKey) {
+        return undefined;
+    }
+    const parsed = new Date(`${dayKey}T00:00:00.000Z`);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString().startsWith(dayKey)
+        ? dayKey
+        : undefined;
+}
 export function resolveJunctionBoundedFeatureRecords(resource, records) {
     const selected = new Map();
     const policy = resolveJunctionTimeseriesResourcePolicy(resource);
@@ -262,19 +581,34 @@ function assertFeature(resource, feature) {
     const count = finiteNumber(feature[ecg ? "voltageSampleCount" : "sampleCount"]);
     const numericFields = ecg
         ? ["durationSeconds", "voltageMin", "voltageMax", "voltageMean", "voltageRms", "leadCount"]
-        : ["durationSeconds", "distanceMeters", "averageHeartRate", "maxHeartRate"];
+        : [
+            "durationSeconds", "distanceMeters", "averageHeartRate", "maxHeartRate",
+            "firstHalfAverageHeartRate", "secondHalfAverageHeartRate",
+            "averageCadence", "maxCadence", "averagePower", "maxPower",
+            "averageSpeed", "maxSpeed",
+        ];
     const invalidNumber = numericFields.some((key) => {
         const value = feature[key];
         return (ecg || key === "durationSeconds" || value !== undefined)
             && finiteNumber(value) === undefined;
     });
-    const scalarOnly = Object.values(feature).every((value) => typeof value === "string" || typeof value === "number");
+    const boundedShape = Object.entries(feature).every(([key, value]) => key === "splits"
+        ? !ecg && Array.isArray(value)
+        : typeof value === "string" || typeof value === "number");
     const policy = resolveJunctionTimeseriesResourcePolicy(resource);
     const countLimit = ecg ? policy?.maxSamplesPerWindow : policy?.maxSamplesPerRecord;
     const duration = finiteNumber(feature.durationSeconds);
     const distance = finiteNumber(feature.distanceMeters);
     const averageHeartRate = finiteNumber(feature.averageHeartRate);
     const maxHeartRate = finiteNumber(feature.maxHeartRate);
+    const firstHalfAverageHeartRate = finiteNumber(feature.firstHalfAverageHeartRate);
+    const secondHalfAverageHeartRate = finiteNumber(feature.secondHalfAverageHeartRate);
+    const averageCadence = finiteNumber(feature.averageCadence);
+    const maxCadence = finiteNumber(feature.maxCadence);
+    const averagePower = finiteNumber(feature.averagePower);
+    const maxPower = finiteNumber(feature.maxPower);
+    const averageSpeed = finiteNumber(feature.averageSpeed);
+    const maxSpeed = finiteNumber(feature.maxSpeed);
     const voltageMin = finiteNumber(feature.voltageMin);
     const voltageMax = finiteNumber(feature.voltageMax);
     const voltageMean = finiteNumber(feature.voltageMean);
@@ -282,7 +616,7 @@ function assertFeature(resource, feature) {
     const leadCount = finiteNumber(feature.leadCount);
     if (feature.schema !== schema
         || Object.keys(feature).some((key) => !fields.has(key))
-        || !scalarOnly
+        || !boundedShape
         || Buffer.byteLength(JSON.stringify(feature), "utf8") > MAX_FEATURE_BYTES
         || !resolveJunctionOrigin(feature).sourceProviderSlug
         || !start
@@ -300,6 +634,19 @@ function assertFeature(resource, feature) {
         || (!ecg && averageHeartRate !== undefined && (averageHeartRate < 20 || averageHeartRate > 300))
         || (!ecg && maxHeartRate !== undefined && (maxHeartRate < 20 || maxHeartRate > 300))
         || (!ecg && averageHeartRate !== undefined && maxHeartRate !== undefined && averageHeartRate > maxHeartRate)
+        || (!ecg && firstHalfAverageHeartRate !== undefined && (firstHalfAverageHeartRate < 20 || firstHalfAverageHeartRate > 300))
+        || (!ecg && secondHalfAverageHeartRate !== undefined && (secondHalfAverageHeartRate < 20 || secondHalfAverageHeartRate > 300))
+        || (!ecg && averageCadence !== undefined && (averageCadence < 0 || averageCadence > 400))
+        || (!ecg && maxCadence !== undefined && (maxCadence < 0 || maxCadence > 400))
+        || (!ecg && averageCadence !== undefined && maxCadence !== undefined && averageCadence > maxCadence)
+        || (!ecg && averagePower !== undefined && (averagePower < 0 || averagePower > 5_000))
+        || (!ecg && maxPower !== undefined && (maxPower < 0 || maxPower > 5_000))
+        || (!ecg && averagePower !== undefined && maxPower !== undefined && averagePower > maxPower)
+        || (!ecg && averageSpeed !== undefined && (averageSpeed < 0 || averageSpeed > 150))
+        || (!ecg && maxSpeed !== undefined && (maxSpeed < 0 || maxSpeed > 150))
+        || (!ecg && averageSpeed !== undefined && maxSpeed !== undefined && averageSpeed > maxSpeed)
+        || (!ecg && feature.workoutDayKey !== undefined && strictDayKey(firstString(feature, ["workoutDayKey"])) !== feature.workoutDayKey)
+        || (!ecg && !firstTimestamp(feature, ["version"]))
         || (ecg && (voltageMin === undefined || voltageMax === undefined || voltageMean === undefined || voltageRms === undefined))
         || (ecg && voltageMin !== undefined && voltageMax !== undefined && voltageMin > voltageMax)
         || (ecg && voltageMean !== undefined && voltageMin !== undefined && voltageMean < voltageMin)
@@ -308,8 +655,54 @@ function assertFeature(resource, feature) {
         || (ecg && (leadCount === undefined || !Number.isSafeInteger(leadCount) || leadCount < 1))
         || (ecg && !firstString(feature, ["voltageUnit"])))
         invalid(`${resource} feature was invalid`);
+    if (!ecg) {
+        assertWorkoutSplits(feature.splits);
+    }
     consistentId(feature, ecg ? ECG_IDS : WORKOUT_IDS, "feature");
 }
+function assertWorkoutSplits(value) {
+    if (!Array.isArray(value) || value.length > MAX_WORKOUT_SPLITS) {
+        invalid("workout feature splits were invalid");
+    }
+    let previousIndex = 0;
+    let previousEndedAt = Number.NEGATIVE_INFINITY;
+    for (const [offset, rawSplit] of value.entries()) {
+        const split = record(rawSplit, `workout split ${offset + 1}`);
+        const index = finiteNumber(split.index);
+        const distance = finiteNumber(split.distanceMeters);
+        const duration = finiteNumber(split.durationSeconds);
+        const endedAt = firstTimestamp(split, ["endedAt"]);
+        const averageSplitHeartRate = finiteNumber(split.averageHeartRate);
+        const averageSplitCadence = finiteNumber(split.averageCadence);
+        const averageSplitPower = finiteNumber(split.averagePower);
+        const cadenceUnit = firstString(split, ["cadenceUnit"]);
+        if (Object.keys(split).some((key) => !WORKOUT_SPLIT_FIELDS.has(key))
+            || Object.values(split).some((entry) => typeof entry !== "string" && typeof entry !== "number")
+            || index === undefined
+            || !Number.isSafeInteger(index)
+            || index <= previousIndex
+            || distance === undefined
+            || distance <= 0
+            || duration === undefined
+            || duration <= 0
+            || !endedAt
+            || Date.parse(endedAt) <= previousEndedAt
+            || (averageSplitHeartRate !== undefined
+                && (averageSplitHeartRate < 20 || averageSplitHeartRate > 300))
+            || (averageSplitCadence !== undefined
+                && (averageSplitCadence < 0 || averageSplitCadence > 400))
+            || (averageSplitPower !== undefined
+                && (averageSplitPower < 0 || averageSplitPower > 5_000))
+            || ((averageSplitCadence === undefined) !== (cadenceUnit === undefined))
+            || (cadenceUnit !== undefined
+                && cadenceUnit !== "rpm"
+                && cadenceUnit !== "steps-per-minute")) {
+            invalid(`workout split ${offset + 1} was invalid`);
+        }
+        previousIndex = index;
+        previousEndedAt = Date.parse(endedAt);
+    }
+}
 function compareSamples(left, right) {
     return left.timestampMs - right.timestampMs || left.lead.localeCompare(right.lead);
 }