fit-file-parser 4.0.2 → 5.0.1

package/dist/binary.js

@@ -3,31 +3,48 @@ import { FIT } from './fit.js';
 import { getFitMessage, getFitMessageBaseType } from './messages.js';
 const CompressedLocalMsgNumMask = 0x60;
 const CompressedHeaderMask = 0x80;
+const CompressedTimestampMask = 0x1F;
 const GarminTimeOffset = 631065600000;
-let monitoring_timestamp = 0;
 const InvalidFieldData = Symbol('invalid FIT field data');
 const formatTypeMetadata = new Map();
-function requiresBoundedEndianDataView(type, size) {
+const uint8CompatibleTypes = new Set(['enum', 'uint8', 'byte']);
+function baseTypeSize(type) {
     switch (type) {
+        case 'enum':
+        case 'sint8':
+        case 'uint8':
+        case 'uint8z':
+        case 'byte':
+            return 1;
         case 'sint16':
         case 'uint16':
         case 'uint16z':
-            return size < 2;
+            return 2;
         case 'sint32':
         case 'uint32':
         case 'uint32z':
         case 'float32':
-            return size < 4;
+            return 4;
         case 'float64':
-            return size < 8;
-        case 'uint16_array':
-            return size % 2 !== 0;
-        case 'uint32_array':
-            return size % 4 !== 0;
+            return 8;
         default:
-            return false;
+            return undefined;
     }
 }
+function requiresBoundedEndianDataView(type, size) {
+    const elementSize = baseTypeSize(type);
+    return elementSize !== undefined && size % elementSize !== 0;
+}
+function areProfileBaseTypesCompatible(profileType, wireType) {
+    if (profileType === undefined || profileType === wireType) {
+        return true;
+    }
+    // FIT producers commonly interchange enum, uint8, and byte definitions.
+    // They have the same width and value representation; keeping the semantic
+    // profile type is safe while still rejecting width and sign conflicts.
+    return uint8CompatibleTypes.has(String(profileType))
+        && uint8CompatibleTypes.has(String(wireType));
+}
 export function addEndian(littleEndian, bytes) {
     let result = 0;
     if (!littleEndian)
@@ -37,77 +54,10 @@ export function addEndian(littleEndian, bytes) {
     }
     return result;
 }
-function readData(blob, dataView, fDef, startIndex, options) {
-    var _a;
-    if (fDef.type === 'uint8_array') {
-        const array8 = [];
-        for (let i = 0; i < fDef.size; i++) {
-            array8.push(blob[startIndex + i]);
-        }
-        return array8;
-    }
-    if (fDef.endianAbility) {
-        const requiresBoundedDataView = (_a = fDef.requiresBoundedDataView) !== null && _a !== void 0 ? _a : (fDef.requiresBoundedDataView = requiresBoundedEndianDataView(fDef.type, fDef.size));
-        let fieldDataView = dataView;
-        let fieldStartIndex = startIndex;
-        if (startIndex < 0
-            || startIndex + fDef.size > blob.length
-            || startIndex + fDef.size > dataView.byteLength) {
-            const paddedField = new Uint8Array(fDef.size);
-            for (let index = 0; index < fDef.size; index++) {
-                paddedField[index] = blob[startIndex + index];
-            }
-            fieldDataView = new DataView(paddedField.buffer);
-            fieldStartIndex = 0;
-        }
-        else if (requiresBoundedDataView) {
-            fieldDataView = new DataView(dataView.buffer, dataView.byteOffset + startIndex, fDef.size);
-            fieldStartIndex = 0;
-        }
-        try {
-            switch (fDef.type) {
-                case 'sint16':
-                    return fieldDataView.getInt16(fieldStartIndex, fDef.littleEndian);
-                case 'uint16':
-                case 'uint16z':
-                    return fieldDataView.getUint16(fieldStartIndex, fDef.littleEndian);
-                case 'sint32':
-                    return fieldDataView.getInt32(fieldStartIndex, fDef.littleEndian);
-                case 'uint32':
-                case 'uint32z':
-                    return fieldDataView.getUint32(fieldStartIndex, fDef.littleEndian);
-                case 'float32':
-                    return fieldDataView.getFloat32(fieldStartIndex, fDef.littleEndian);
-                case 'float64':
-                    return fieldDataView.getFloat64(fieldStartIndex, fDef.littleEndian);
-                case 'uint32_array': {
-                    const array32 = [];
-                    for (let i = 0; i < fDef.size; i += 4) {
-                        array32.push(fieldDataView.getUint32(fieldStartIndex + i, fDef.littleEndian));
-                    }
-                    return array32;
-                }
-                case 'uint16_array': {
-                    const array16 = [];
-                    for (let i = 0; i < fDef.size; i += 2) {
-                        array16.push(fieldDataView.getUint16(fieldStartIndex + i, fDef.littleEndian));
-                    }
-                    return array16;
-                }
-            }
-        }
-        catch (e) {
-            if (!options.force) {
-                throw e;
-            }
-        }
-        const temp = [];
-        for (let i = 0; i < fDef.size; i++) {
-            temp.push(blob[startIndex + i]);
-        }
-        return addEndian(fDef.littleEndian, temp);
-    }
-    if (fDef.type === 'string') {
+function readData(blob, dataView, fDef, startIndex) {
+    var _a, _b;
+    const rawType = (_b = (_a = fDef.rawType) !== null && _a !== void 0 ? _a : FIT.types.fit_base_type[fDef.baseTypeNo]) !== null && _b !== void 0 ? _b : fDef.type;
+    if (rawType === 'string') {
         const temp = [];
         for (let i = 0; i < fDef.size; i++) {
             if (blob[startIndex + i]) {
@@ -116,30 +66,77 @@ function readData(blob, dataView, fDef, startIndex, options) {
         }
         return Buffer.from(temp).toString('utf-8');
     }
-    if (fDef.type === 'byte_array') {
-        const temp = [];
-        for (let i = 0; i < fDef.size; i++) {
-            temp.push(blob[startIndex + i]);
-        }
-        return temp;
+    const elementSize = baseTypeSize(rawType);
+    if (elementSize === undefined) {
+        return InvalidFieldData;
+    }
+    if (fDef.size < elementSize
+        || fDef.size % elementSize !== 0
+        || startIndex < 0
+        || startIndex + fDef.size > blob.length
+        || startIndex + fDef.size > dataView.byteLength) {
+        return InvalidFieldData;
     }
-    if (fDef.type === 'sint8') {
-        const val = blob[startIndex];
-        return val > 127 ? val - 256 : val;
+    const isArray = fDef.array === true
+        || String(fDef.type).endsWith('_array')
+        || fDef.type === 'exercise_category_array'
+        || (fDef.isDeveloperField === true && fDef.size > elementSize);
+    const elementCount = isArray ? fDef.size / elementSize : 1;
+    const values = [];
+    for (let elementIndex = 0; elementIndex < elementCount; elementIndex++) {
+        const offset = startIndex + elementIndex * elementSize;
+        switch (rawType) {
+            case 'sint8': {
+                const value = blob[offset];
+                values.push(value > 127 ? value - 256 : value);
+                break;
+            }
+            case 'sint16':
+                values.push(dataView.getInt16(offset, fDef.littleEndian));
+                break;
+            case 'uint16':
+            case 'uint16z':
+                values.push(dataView.getUint16(offset, fDef.littleEndian));
+                break;
+            case 'sint32':
+                values.push(dataView.getInt32(offset, fDef.littleEndian));
+                break;
+            case 'uint32':
+            case 'uint32z':
+                values.push(dataView.getUint32(offset, fDef.littleEndian));
+                break;
+            case 'float32':
+                values.push(dataView.getFloat32(offset, fDef.littleEndian));
+                break;
+            case 'float64':
+                values.push(dataView.getFloat64(offset, fDef.littleEndian));
+                break;
+            default:
+                values.push(blob[offset]);
+                break;
+        }
     }
-    return blob[startIndex];
+    return isArray ? values : values[0];
 }
-function formatByType(data, type, scale, offset) {
+function formatByType(data, type, scale, offset, units) {
     switch (type) {
         case 'date_time':
         case 'local_date_time':
             return new Date(data * 1000 + GarminTimeOffset);
         case 'sint32':
-            return data * FIT.scConst;
+            return units === 'semicircles'
+                ? data * FIT.scConst
+                : scale ? data / scale + offset : data;
+        case 'sint8':
         case 'uint8':
+        case 'uint8z':
         case 'sint16':
-        case 'uint32':
         case 'uint16':
+        case 'uint16z':
+        case 'uint32':
+        case 'uint32z':
+        case 'float32':
+        case 'float64':
             return scale ? data / scale + offset : data;
         case 'uint32_array':
         case 'uint16_array':
@@ -154,6 +151,16 @@ function formatByType(data, type, scale, offset) {
                 });
             }
             return scale ? data / scale + offset : data;
+        case 'exercise_category_array':
+            if (Array.isArray(data)) {
+                return data.map((dataItem) => {
+                    if (isInvalidValue(dataItem, 'uint16')) {
+                        return null;
+                    }
+                    return formatByType(dataItem, 'exercise_category', scale, offset);
+                });
+            }
+            return formatByType(data, 'exercise_category', scale, offset);
         default:
             {
                 const typeMap = FIT.types[type];
@@ -186,7 +193,7 @@ function formatByType(data, type, scale, offset) {
                         dataItem.value = data & Number(key);
                     }
                     else {
-                        dataItem[value] = !!((data & Number(key)) >> 7); // Not sure if we need the >> 7 and casting to boolean but from all the masked props of fields so far this seems to be the case
+                        dataItem[value] = (data & Number(key)) !== 0;
                     }
                 }
                 return dataItem;
@@ -212,10 +219,9 @@ function isInvalidValue(data, type) {
         case 'string':
             return data === 0x00;
         case 'float32':
-            return data === 0xFFFFFFFF;
+            return Number.isNaN(data);
         case 'float64':
-            // eslint-disable-next-line no-loss-of-precision
-            return data === 0xFFFFFFFFFFFFFFFF;
+            return Number.isNaN(data);
         case 'uint8z':
             return data === 0x00;
         case 'uint16z':
@@ -243,6 +249,27 @@ function isInvalidBaseTypeValue(data, baseTypeNo) {
     const baseType = FIT.types.fit_base_type[baseTypeNo];
     return typeof baseType === 'string' ? isInvalidValue(data, baseType) : false;
 }
+function formatFieldValue(data, fDef, options, fields) {
+    var _a, _b, _c;
+    const field = fDef.name;
+    const scale = (_a = fDef.scale) !== null && _a !== void 0 ? _a : null;
+    const offset = (_b = fDef.offset) !== null && _b !== void 0 ? _b : 0;
+    if (Array.isArray(data)
+        && !String(fDef.type).endsWith('_array')
+        && fDef.type !== 'exercise_category_array') {
+        const rawType = (_c = fDef.rawType) !== null && _c !== void 0 ? _c : FIT.types.fit_base_type[fDef.baseTypeNo];
+        return data.map((item) => {
+            if (isInvalidValue(item, rawType)) {
+                return null;
+            }
+            return applyOptions(formatByType(item, fDef.type, scale, offset, fDef.units), field, options, fields);
+        });
+    }
+    return applyOptions(formatByType(data, fDef.type, scale, offset, fDef.units), field, options, fields);
+}
+function isOutputFieldName(field) {
+    return field !== 'unknown' && field !== '' && field !== undefined;
+}
 function convertTo(data, unitsList, unitName) {
     const options = FIT.options[unitsList];
     const unit = options[unitName];
@@ -270,7 +297,7 @@ function applyOptions(data, field, options, fields) {
         case 'vertical_speed':
         case 'avg_speed':
         case 'max_speed':
-        case 'speed_1s':
+        case 'speed1s':
         case 'ball_speed':
         case 'enhanced_avg_speed':
         case 'enhanced_max_speed':
@@ -301,8 +328,10 @@ function applyOptions(data, field, options, fields) {
             return convertTo(data, 'lengthUnits', options.lengthUnit);
         case 'temperature':
         case 'min_temperature':
+        case 'temperature_min':
         case 'avg_temperature':
         case 'max_temperature':
+        case 'temperature_max':
             return convertTo(data, 'temperatureUnits', options.temperatureUnit);
         case 'pressure':
         case 'start_pressure':
@@ -319,22 +348,8 @@ function applyOptions(data, field, options, fields) {
             return data;
     }
 }
-function applyGarminProductName(fields) {
-    if (fields.product_name !== undefined || fields.manufacturer !== 'garmin') {
-        return;
-    }
-    const product = fields.product;
-    if (typeof product !== 'number') {
-        return;
-    }
-    const productName = FIT.types.garmin_product[product];
-    if (typeof productName === 'string') {
-        // Keep the raw protocol ID and expose the SDK product name separately.
-        fields.product_name = productName;
-    }
-}
 function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, developerFields, options) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g;
     const description = (_a = developerFields[developerFieldDef.developerDataIndex]) === null || _a === void 0 ? void 0 : _a[developerFieldDef.fieldDefinitionNumber];
     if (!description) {
         developerFieldDef.resolvedFieldDef = undefined;
@@ -345,9 +360,12 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
         && developerFieldDef.resolvedFieldDef) {
         return developerFieldDef.resolvedFieldDef;
     }
-    const baseType = description.fit_base_type_id;
+    const describedBaseType = description.fit_base_type_id;
+    const baseType = typeof describedBaseType === 'number'
+        ? describedBaseType
+        : Number((_b = Object.entries(FIT.types.fit_base_type).find(([, typeName]) => typeName === describedBaseType)) === null || _b === void 0 ? void 0 : _b[0]);
     const type = FIT.types.fit_base_type[baseType];
-    if (typeof baseType !== 'number' || type === undefined) {
+    if (!Number.isInteger(baseType) || type === undefined) {
         developerFieldDef.resolvedFieldDef = undefined;
         developerFieldDef.resolvedFrom = undefined;
         if (options.force) {
@@ -357,15 +375,22 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
     }
     const resolvedFieldDef = {
         type,
+        rawType: type,
         fDefNo: developerFieldDef.fieldDefinitionNumber,
         size: developerFieldDef.size,
+        array: type !== 'string'
+            && developerFieldDef.size > ((_c = baseTypeSize(type)) !== null && _c !== void 0 ? _c : developerFieldDef.size),
         endianAbility: (baseType & 128) === 128,
         littleEndian,
         baseTypeNo: baseType,
-        name: (_b = description.field_name) !== null && _b !== void 0 ? _b : '',
+        name: (_d = description.field_name) !== null && _d !== void 0 ? _d : '',
         dataType: getFitMessageBaseType(baseType & 15),
-        scale: (_c = description.scale) !== null && _c !== void 0 ? _c : 1,
-        offset: (_d = description.offset) !== null && _d !== void 0 ? _d : 0,
+        scale: (_e = description.scale) !== null && _e !== void 0 ? _e : 1,
+        // FIT developer-field descriptions use `raw / scale - offset`. This
+        // parser's formatter retains the legacy equivalent signed offset and adds
+        // it after scaling.
+        offset: -((_f = description.offset) !== null && _f !== void 0 ? _f : 0),
+        units: (_g = description.units) !== null && _g !== void 0 ? _g : '',
         requiresBoundedDataView: requiresBoundedEndianDataView(type, developerFieldDef.size),
         developerDataIndex: developerFieldDef.developerDataIndex,
         isDeveloperField: true,
@@ -374,11 +399,12 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
     developerFieldDef.resolvedFrom = description;
     return resolvedFieldDef;
 }
-export function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength)) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+export function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength), decoderState = {}) {
+    var _a, _b, _c;
     const recordHeader = blob[startIndex];
     let localMessageType = recordHeader & 15;
-    if ((recordHeader & CompressedHeaderMask) === CompressedHeaderMask) {
+    const isCompressedTimestamp = (recordHeader & CompressedHeaderMask) === CompressedHeaderMask;
+    if (isCompressedTimestamp) {
         // compressed timestamp
         localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
     }
@@ -406,19 +432,26 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         for (let i = 0; i < numberOfFields; i++) {
             const fDefIndex = startIndex + 6 + i * 3;
             const baseType = blob[fDefIndex + 2];
-            const { field, type, scale, offset } = message.getAttributes(blob[fDefIndex]);
+            const wireType = FIT.types.fit_base_type[baseType];
+            const { field, type, baseType: profileBaseType, array, scale, offset, units, } = message.getAttributes(blob[fDefIndex]);
+            const profileCompatible = areProfileBaseTypesCompatible(profileBaseType, wireType);
             const fDef = {
-                type,
+                type: profileCompatible ? type : wireType,
+                rawType: wireType,
                 fDefNo: blob[fDefIndex],
                 size: blob[fDefIndex + 1],
+                array: profileCompatible
+                    ? array === true || String(type).endsWith('_array')
+                    : false,
                 endianAbility: (baseType & 128) === 128,
                 littleEndian: lEnd,
                 baseTypeNo: baseType,
-                name: field,
+                name: profileCompatible ? field : '',
                 dataType: getFitMessageBaseType(baseType & 15),
-                scale,
-                offset,
-                requiresBoundedDataView: requiresBoundedEndianDataView(type, blob[fDefIndex + 1]),
+                scale: profileCompatible ? scale : null,
+                offset: profileCompatible ? offset : 0,
+                units: profileCompatible ? units : '',
+                requiresBoundedDataView: requiresBoundedEndianDataView(wireType, blob[fDefIndex + 1]),
             };
             mTypeDef.fieldDefs.push(fDef);
         }
@@ -440,8 +473,6 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         };
     }
     const messageType = messageTypes[localMessageType] || messageTypes[0];
-    // TODO: handle compressed header ((recordHeader & 128) == 128)
-    // uncompressed header
     let messageSize = 0;
     let readDataFromIndex = startIndex + 1;
     const fields = {};
@@ -452,10 +483,15 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     let validFieldCount = 0;
     for (let i = 0; i < messageType.fieldDefs.length; i++) {
         const fDef = messageType.fieldDefs[i];
-        const data = readData(blob, dataView, fDef, readDataFromIndex, options);
-        if (!isInvalidValue(data, fDef.type) && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
+        const data = readData(blob, dataView, fDef, readDataFromIndex);
+        if (data !== InvalidFieldData
+            && !isInvalidValue(data, fDef.type)
+            && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
             rawData[i] = data;
             validFieldCount++;
+            if (!isCompressedTimestamp && fDef.fDefNo === 253 && typeof data === 'number') {
+                decoderState.lastTimestamp = data;
+            }
         }
         else {
             rawData[i] = InvalidFieldData;
@@ -468,8 +504,10 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         const rawDataIndex = messageType.fieldDefs.length + i;
         const fDef = resolveDeveloperFieldDefinition(developerFieldDef, messageType.littleEndian, developerFields, options);
         if (fDef) {
-            const data = readData(blob, dataView, fDef, readDataFromIndex, options);
-            if (!isInvalidValue(data, fDef.type) && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
+            const data = readData(blob, dataView, fDef, readDataFromIndex);
+            if (data !== InvalidFieldData
+                && !isInvalidValue(data, fDef.type)
+                && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
                 rawData[rawDataIndex] = data;
                 validFieldCount++;
             }
@@ -489,9 +527,8 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             continue;
         }
         const fDef = messageType.fieldDefs[i];
-        const field = fDef.name;
-        if (field !== 'unknown' && field !== '' && field !== undefined) {
-            fields[field] = data;
+        if (isOutputFieldName(fDef.name)) {
+            fields[fDef.name] = data;
         }
     }
     for (let i = 0; i < developerFieldDefs.length; i++) {
@@ -511,20 +548,8 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             continue;
         }
         const fDef = messageType.fieldDefs[i];
-        if (fDef.isDeveloperField) {
-            const field = fDef.name;
-            const { type } = fDef;
-            const scale = (_d = fDef.scale) !== null && _d !== void 0 ? _d : null;
-            const offset = (_e = fDef.offset) !== null && _e !== void 0 ? _e : 0;
-            fields[fDef.name] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
-        }
-        else {
-            const { name: field, type } = fDef;
-            const scale = (_f = fDef.scale) !== null && _f !== void 0 ? _f : null;
-            const offset = (_g = fDef.offset) !== null && _g !== void 0 ? _g : 0;
-            if (field !== 'unknown' && field !== '' && field !== undefined) {
-                fields[field] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
-            }
+        if (isOutputFieldName(fDef.name)) {
+            fields[fDef.name] = formatFieldValue(data, fDef, options, fields);
         }
     }
     for (let i = 0; i < developerFieldDefs.length; i++) {
@@ -535,10 +560,26 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         }
         const field = fDef.name;
         if (field !== 'unknown' && field !== '') {
-            fields[field] = applyOptions(formatByType(data, fDef.type, (_h = fDef.scale) !== null && _h !== void 0 ? _h : null, (_j = fDef.offset) !== null && _j !== void 0 ? _j : 0), field, options, fields);
+            fields[field] = formatFieldValue(data, fDef, options, fields);
+        }
+    }
+    if (isCompressedTimestamp) {
+        const previousTimestamp = decoderState.lastTimestamp;
+        if (previousTimestamp === undefined) {
+            if (!options.force) {
+                throw new Error('Compressed timestamp requires a previous timestamp');
+            }
+        }
+        else {
+            const timeOffset = recordHeader & CompressedTimestampMask;
+            const previousOffset = previousTimestamp & CompressedTimestampMask;
+            const rollover = timeOffset < previousOffset ? 0x20 : 0;
+            const timestamp = (previousTimestamp & ~CompressedTimestampMask) + timeOffset + rollover;
+            decoderState.lastTimestamp = timestamp;
+            fields.timestamp = new Date(timestamp * 1000 + GarminTimeOffset);
+            validFieldCount++;
         }
     }
-    applyGarminProductName(fields);
     if (validFieldCount > 0 && message.name === 'record' && options.elapsedRecordField) {
         fields.elapsed_time = (fields.timestamp - (startDate || 0)) / 1000;
         fields.timer_time = fields.elapsed_time - pausedTime;
@@ -549,17 +590,20 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         developerFields[fields.developer_data_index][fields.field_definition_number] = fields;
     }
     if (message.name === 'monitoring') {
-        // TODO weirdly uses global variables?
-        // we need to keep the raw timestamp value so we can calculate subsequent timestamp16 fields
-        if (fields.timestamp) {
-            monitoring_timestamp = fields.timestamp;
-            fields.timestamp = new Date(fields.timestamp * 1000 + GarminTimeOffset);
+        const timestampFieldIndex = messageType.fieldDefs.findIndex(fieldDefinition => fieldDefinition.fDefNo === 253);
+        const rawTimestamp = timestampFieldIndex >= 0
+            ? rawData[timestampFieldIndex]
+            : InvalidFieldData;
+        if (rawTimestamp !== InvalidFieldData && typeof rawTimestamp === 'number') {
+            decoderState.monitoringTimestamp = rawTimestamp;
+            fields.timestamp = new Date(rawTimestamp * 1000 + GarminTimeOffset);
         }
-        if (fields.timestamp16 && !fields.timestamp) {
-            monitoring_timestamp
-                += (fields.timestamp16 - (monitoring_timestamp & 0xFFFF)) & 0xFFFF;
-            // fields.timestamp = monitoring_timestamp;
-            fields.timestamp = new Date(monitoring_timestamp * 1000 + GarminTimeOffset);
+        else if (fields.timestamp16
+            && decoderState.monitoringTimestamp !== undefined
+            && !fields.timestamp) {
+            decoderState.monitoringTimestamp
+                += (fields.timestamp16 - (decoderState.monitoringTimestamp & 0xFFFF)) & 0xFFFF;
+            fields.timestamp = new Date(decoderState.monitoringTimestamp * 1000 + GarminTimeOffset);
         }
     }
     return {

package/dist/cjs/binary.d.ts

@@ -1,6 +1,5 @@
 import type { FitParserOptions } from './fit-parser.js';
-import type { FieldDefinition } from './fit.js';
-import type { MesgNum } from './fit_types.js';
+import type { FieldDefinition, MessageName } from './fit.js';
 import { Buffer } from 'buffer';
 export interface MessageTypeDefinition {
     littleEndian: boolean;
@@ -17,9 +16,13 @@ export interface DeveloperFieldDefinition {
     resolvedFieldDef?: FieldDefinition;
     resolvedFrom?: unknown;
 }
+export interface DecoderState {
+    lastTimestamp?: number;
+    monitoringTimestamp?: number;
+}
 export declare function addEndian(littleEndian: boolean, bytes: number[]): number;
-export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView): {
-    messageType: MesgNum | '';
+export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView, decoderState?: DecoderState): {
+    messageType: MessageName | 'definition' | '';
     nextIndex: number;
     message?: any;
 };