fit-file-parser 6.2.0 → 6.2.2

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Change Log
 
+## 6.2.2 - 2026-10-11
+
+### Fixed
+
+- Restore ordinary decoding of existing Bryton and Magene FIT files whose
+  normal record headers set reserved bit 4. Their activity data was readable
+  before 5.2.0 and is recovered without modifying the original bytes.
+- Require complete definitions and native/developer payloads for messages
+  using reserved-header compatibility, including ordinary data records that
+  reference a definition with the reserved bit set.
+
+### Compatibility
+
+- Strict parsing, full raw-message retention, and the standalone raw reader
+  continue rejecting reserved header bits. Bit 5 in data headers remains
+  invalid in all modes. Checksum behavior still follows `force`.
+- No new options or parsed output fields. Existing successful imports need no
+  migration; retry previously rejected originals with the updated parser.
+
+## 6.2.1 - 2026-10-10
+
+### Added
+
+- Add the opt-in `strict` parser option to require complete files and records,
+  valid definitions, and no trailing bytes in every parsing API. Checksum
+  validation remains controlled by `force`.
+
+### Fixed
+
+- Apply the same recovery policy to `parseFilesAsync()`, `parseAsync()`, and
+  callback parsing. The all-file API now accepts missing CRC bytes with
+  `force: true` when `strict` is disabled, and ignores a non-FIT suffix.
+- Keep existing decoder behavior, recovery, and output when `strict` is not
+  requested, including handling of malformed records and definitions.
+- Apply additional definition and record bounds checks only in strict mode.
+
+### Compatibility
+
+- `force` still defaults to `true`; `strict` defaults to `false`.
+- `strict: true` requires exactly one file for `parseAsync()` and callback
+  parsing, or complete concatenated files for `parseFilesAsync()`.
+- Temperature mappings and unit conversions are unchanged.
+
 ## 6.2.0 - 2026-10-10
 
 ### Added

package/README.md

@@ -77,12 +77,23 @@ for (const file of files) {
 
 Each result has independent message definitions, developer descriptions,
 timestamps, and activity collections. Results are never merged. A single FIT
-file returns a one-element array. Empty input, incomplete files (including
-missing file CRC bytes), and trailing non-FIT bytes reject the entire call,
-even with `force: true`. Records and definitions extending beyond the declared
-data section are also rejected. CRC validation follows the `force` option for every
-file. Failures reject with an `Error`. The existing `parseAsync()` and callback
-APIs continue to parse the first FIT file only.
+file returns a one-element array. All parsing APIs share the same `force` and
+`strict` options. By default, complete fields in a partial final record can be
+recovered, and a non-FIT suffix after parsed files is ignored. With `force: true`,
+missing CRC bytes are also accepted, including when the next FIT header starts
+at the declared data boundary or after one CRC byte. The parser never scans
+record payloads for guessed file boundaries.
+
+Use `{ force: false, strict: true }` to require complete files and records,
+valid checksums, and no trailing bytes. `{ force: true, strict: true }` enforces
+the same structure while tolerating known checksum failures. Any file that
+cannot be parsed rejects the whole call with an `Error`. Empty input, invalid
+headers, and declared data beyond the available input
+remain errors in every mode.
+
+The existing `parseAsync()` and callback APIs return the first FIT file only.
+With `strict: true`, they require exactly one file; use `parseFilesAsync()` for
+strict validation of concatenated input.
 
 ### Callback API
 
@@ -120,6 +131,7 @@ All options are optional.
 | --------------------------- | --------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
 | `mode`                      | `list`, `cascade`, `both`               | `list`    | Controls whether primary activity collections are returned as root lists, nested data, or both.                                                |
 | `force`                     | `true`, `false`                         | `true`    | Skips header and file CRC validation and enables supported best-effort field recovery. Structural header and data bounds are always validated. |
+| `strict`                    | `true`, `false`                         | `false`   | Requires CRC bytes, complete records, valid definitions, and no trailing bytes. CRC validation remains controlled by `force`.                  |
 | `speedUnit`                 | `m/s`, `km/h`, `mph`                    | `m/s`     | Converts speed-related fields.                                                                                                                 |
 | `lengthUnit`                | `m`, `km`, `mi`                         | `m`       | Converts distance, altitude, and other length-related fields.                                                                                  |
 | `temperatureUnit`           | `celsius`, `°C`, `kelvin`, `fahrenheit` | `celsius` | Converts temperature fields. `°C` remains available as a legacy alias.                                                                         |
@@ -133,6 +145,31 @@ All options are optional.
 too short, have an invalid header size or signature, or declare data beyond the
 available bytes are rejected in both modes.
 
+`strict: false` keeps the existing decoder behavior, including its handling of
+malformed records and definitions. `parseAsync()` and callback callers keep
+their current defaults, recovery, and output. `parseFilesAsync()` uses that
+same decoder independently for each file.
+
+Ordinary decoding tolerates the reserved bit 4 in normal record headers used
+by some existing device files. Messages using this compatibility behavior must
+have complete definitions and payloads inside the declared data section. Bit 5
+in data headers remains invalid. Strict mode, full raw-message retention, and
+the standalone raw reader continue rejecting reserved header bits. Original
+bytes and the caller's checksum policy are unchanged.
+
+`strict: true` adds definition and record bounds checks so CRC bytes cannot be
+decoded as measurements. Full raw-message retention (`includeRawMessages`)
+continues to require complete records as it did before this option was added.
+
+Choose options according to the input you accept:
+
+| Options                          | Policy                                                    |
+| -------------------------------- | --------------------------------------------------------- |
+| Default                          | Best effort, including missing or invalid CRCs.           |
+| `{ force: false }`               | Validate CRCs while keeping existing field recovery.      |
+| `{ force: true, strict: true }`  | Require complete structure while tolerating invalid CRCs. |
+| `{ force: false, strict: true }` | Require complete structure and valid CRCs.                |
+
 ### Lossless developer fields
 
 By default, developer fields retain the existing decoded, name-keyed output.

package/dist/binary.d.ts

@@ -8,6 +8,8 @@ export interface MessageTypeDefinition {
     fieldDefs: FieldDefinition[];
     developerFieldDefs?: DeveloperFieldDefinition[];
     rawData?: any[];
+    completeDefinition?: boolean;
+    reservedHeaderBit?: boolean;
 }
 export interface DeveloperFieldDefinition {
     developerDataIndex: number;

package/dist/binary.js

@@ -417,6 +417,8 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     const recordHeader = blob[startIndex];
     let localMessageType = recordHeader & 15;
     const isCompressedTimestamp = (recordHeader & CompressedHeaderMask) === CompressedHeaderMask;
+    const reservedHeaderBit = !isCompressedTimestamp && (recordHeader & 0x10) !== 0;
+    const strictHeaders = options.strict || retainsRawMessages(options);
     if (isCompressedTimestamp) {
         // compressed timestamp
         localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
@@ -424,15 +426,16 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     else if ((recordHeader & 64) === 64) {
         // is definition message
         // startIndex + 1 is reserved
-        if (retainsRawMessages(options) && startIndex + 6 > dataEnd) {
+        const requireCompleteDefinition = strictHeaders || reservedHeaderBit;
+        if (requireCompleteDefinition && startIndex + 6 > dataEnd) {
             throw new Error('Invalid FIT definition bounds');
         }
         const hasDeveloperData = (recordHeader & 32) === 32;
         const lEnd = blob[startIndex + 2] === 0;
         const numberOfFields = blob[startIndex + 5];
         const nativeDefinitionsEnd = startIndex + 6 + numberOfFields * 3;
-        if (retainsRawMessages(options)
-            && ((recordHeader & 16) !== 0
+        if (requireCompleteDefinition
+            && ((strictHeaders && reservedHeaderBit)
                 || blob[startIndex + 1] !== 0
                 || blob[startIndex + 2] > 1
                 || nativeDefinitionsEnd > dataEnd
@@ -444,7 +447,7 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             : 0;
         const definitionEnd = nativeDefinitionsEnd
             + (hasDeveloperData ? 1 + numberOfDeveloperDataFields * 3 : 0);
-        if (retainsRawMessages(options) && definitionEnd > dataEnd) {
+        if (requireCompleteDefinition && definitionEnd > dataEnd) {
             throw new Error('Invalid FIT developer definition bounds');
         }
         const mTypeDef = {
@@ -457,6 +460,13 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             fieldDefs: [],
             developerFieldDefs: [],
             rawData: [],
+            // A later data header may use the reserved bit with an ordinary
+            // definition. Do not extend legacy partial-record recovery to that case.
+            completeDefinition: startIndex + 6 <= dataEnd
+                && blob[startIndex + 1] === 0
+                && blob[startIndex + 2] <= 1
+                && definitionEnd <= dataEnd,
+            reservedHeaderBit,
         };
         const message = getFitMessage(mTypeDef.globalMessageNumber);
         for (let i = 0; i < numberOfFields; i++) {
@@ -509,13 +519,20 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             nextIndex: hasDeveloperData ? nextIndexWithDeveloperData : nextIndex,
         };
     }
-    if (!isCompressedTimestamp && (recordHeader & 0x30) !== 0) {
+    // Some existing producer files set bit 4 without changing the record layout.
+    // Recover only that bit in ordinary decoding; bit 5 and strict/raw parsing
+    // retain their previous rejection policy. Never rewrite the source bytes.
+    if (!isCompressedTimestamp && ((recordHeader & 0x20) !== 0 || (strictHeaders && reservedHeaderBit))) {
         throw new Error('Invalid FIT data record header');
     }
     const messageType = messageTypes[localMessageType];
     if (!messageType) {
         throw new Error('FIT data record has no local definition');
     }
+    const reservedHeaderCompatibility = reservedHeaderBit || messageType.reservedHeaderBit;
+    if (reservedHeaderCompatibility && !messageType.completeDefinition) {
+        throw new Error('Invalid FIT definition for reserved header compatibility');
+    }
     let messageSize = 0;
     let readDataFromIndex = startIndex + 1;
     const fields = {};
@@ -530,7 +547,7 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     const rawDeveloperFields = includeRawDeveloperFields || includeRawMessage ? [] : undefined;
     const unmappedFields = options.includeUnmappedMessages ? [] : undefined;
     const unmappedDeveloperFields = options.includeUnmappedMessages ? [] : undefined;
-    if (retainsRawMessages(options)) {
+    if (strictHeaders || reservedHeaderCompatibility) {
         const nativeSize = messageType.fieldDefs.reduce((total, field, index) => (total + (isCompressedTimestamp && index === 0 && field.fDefNo === 253 ? 0 : field.size)), 0);
         const developerSize = developerFieldDefs.reduce((total, field) => total + field.size, 0);
         if (startIndex + 1 + nativeSize + developerSize > dataEnd) {
@@ -665,7 +682,7 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     if (isCompressedTimestamp) {
         const previousTimestamp = decoderState.lastTimestamp;
         if (previousTimestamp === undefined) {
-            if (!options.force) {
+            if (!options.force || options.strict) {
                 throw new Error('Compressed timestamp requires a previous timestamp');
             }
         }

package/dist/cjs/binary.d.ts

@@ -8,6 +8,8 @@ export interface MessageTypeDefinition {
     fieldDefs: FieldDefinition[];
     developerFieldDefs?: DeveloperFieldDefinition[];
     rawData?: any[];
+    completeDefinition?: boolean;
+    reservedHeaderBit?: boolean;
 }
 export interface DeveloperFieldDefinition {
     developerDataIndex: number;

package/dist/cjs/binary.js

@@ -423,6 +423,8 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     const recordHeader = blob[startIndex];
     let localMessageType = recordHeader & 15;
     const isCompressedTimestamp = (recordHeader & CompressedHeaderMask) === CompressedHeaderMask;
+    const reservedHeaderBit = !isCompressedTimestamp && (recordHeader & 0x10) !== 0;
+    const strictHeaders = options.strict || retainsRawMessages(options);
     if (isCompressedTimestamp) {
         // compressed timestamp
         localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
@@ -430,15 +432,16 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     else if ((recordHeader & 64) === 64) {
         // is definition message
         // startIndex + 1 is reserved
-        if (retainsRawMessages(options) && startIndex + 6 > dataEnd) {
+        const requireCompleteDefinition = strictHeaders || reservedHeaderBit;
+        if (requireCompleteDefinition && startIndex + 6 > dataEnd) {
             throw new Error('Invalid FIT definition bounds');
         }
         const hasDeveloperData = (recordHeader & 32) === 32;
         const lEnd = blob[startIndex + 2] === 0;
         const numberOfFields = blob[startIndex + 5];
         const nativeDefinitionsEnd = startIndex + 6 + numberOfFields * 3;
-        if (retainsRawMessages(options)
-            && ((recordHeader & 16) !== 0
+        if (requireCompleteDefinition
+            && ((strictHeaders && reservedHeaderBit)
                 || blob[startIndex + 1] !== 0
                 || blob[startIndex + 2] > 1
                 || nativeDefinitionsEnd > dataEnd
@@ -450,7 +453,7 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             : 0;
         const definitionEnd = nativeDefinitionsEnd
             + (hasDeveloperData ? 1 + numberOfDeveloperDataFields * 3 : 0);
-        if (retainsRawMessages(options) && definitionEnd > dataEnd) {
+        if (requireCompleteDefinition && definitionEnd > dataEnd) {
             throw new Error('Invalid FIT developer definition bounds');
         }
         const mTypeDef = {
@@ -463,6 +466,13 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             fieldDefs: [],
             developerFieldDefs: [],
             rawData: [],
+            // A later data header may use the reserved bit with an ordinary
+            // definition. Do not extend legacy partial-record recovery to that case.
+            completeDefinition: startIndex + 6 <= dataEnd
+                && blob[startIndex + 1] === 0
+                && blob[startIndex + 2] <= 1
+                && definitionEnd <= dataEnd,
+            reservedHeaderBit,
         };
         const message = (0, messages_js_1.getFitMessage)(mTypeDef.globalMessageNumber);
         for (let i = 0; i < numberOfFields; i++) {
@@ -515,13 +525,20 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             nextIndex: hasDeveloperData ? nextIndexWithDeveloperData : nextIndex,
         };
     }
-    if (!isCompressedTimestamp && (recordHeader & 0x30) !== 0) {
+    // Some existing producer files set bit 4 without changing the record layout.
+    // Recover only that bit in ordinary decoding; bit 5 and strict/raw parsing
+    // retain their previous rejection policy. Never rewrite the source bytes.
+    if (!isCompressedTimestamp && ((recordHeader & 0x20) !== 0 || (strictHeaders && reservedHeaderBit))) {
         throw new Error('Invalid FIT data record header');
     }
     const messageType = messageTypes[localMessageType];
     if (!messageType) {
         throw new Error('FIT data record has no local definition');
     }
+    const reservedHeaderCompatibility = reservedHeaderBit || messageType.reservedHeaderBit;
+    if (reservedHeaderCompatibility && !messageType.completeDefinition) {
+        throw new Error('Invalid FIT definition for reserved header compatibility');
+    }
     let messageSize = 0;
     let readDataFromIndex = startIndex + 1;
     const fields = {};
@@ -536,7 +553,7 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     const rawDeveloperFields = includeRawDeveloperFields || includeRawMessage ? [] : undefined;
     const unmappedFields = options.includeUnmappedMessages ? [] : undefined;
     const unmappedDeveloperFields = options.includeUnmappedMessages ? [] : undefined;
-    if (retainsRawMessages(options)) {
+    if (strictHeaders || reservedHeaderCompatibility) {
         const nativeSize = messageType.fieldDefs.reduce((total, field, index) => (total + (isCompressedTimestamp && index === 0 && field.fDefNo === 253 ? 0 : field.size)), 0);
         const developerSize = developerFieldDefs.reduce((total, field) => total + field.size, 0);
         if (startIndex + 1 + nativeSize + developerSize > dataEnd) {
@@ -671,7 +688,7 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     if (isCompressedTimestamp) {
         const previousTimestamp = decoderState.lastTimestamp;
         if (previousTimestamp === undefined) {
-            if (!options.force) {
+            if (!options.force || options.strict) {
                 throw new Error('Compressed timestamp requires a previous timestamp');
             }
         }

package/dist/cjs/fit-parser.d.ts

@@ -7,7 +7,10 @@ export { getFitCoursePointId, getFitGarminProductDisplayName, getFitGarminProduc
 export { FitMessageReaderError, fitTimestampToUnixMilliseconds, getFitBaseTypeId, readFitMessages, readFitStringField, readFitUnsignedField, } from './raw-message-reader.js';
 export type { FitMessageReaderErrorCode, FitMessageReaderIssue, FitMessageReaderIssueCode, FitMessageReaderOptions, FitMessageReaderResult, FitRawDeveloperField, FitRawField, FitRawMessage, } from './raw-message-reader.js';
 export interface FitParserOptions {
+    /** Skips CRC validation and enables supported best-effort recovery. Defaults to true. */
     force?: boolean;
+    /** Requires complete files and records, and rejects trailing bytes. Defaults to false. */
+    strict?: boolean;
     speedUnit?: string;
     lengthUnit?: string;
     temperatureUnit?: string;
@@ -29,9 +32,9 @@ export default class FitParser {
     constructor(options?: FitParserOptions);
     parseAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit>;
     /**
-     * Parses every complete FIT file in an input, preserving file order and
-     * independent decoder state. Rejects incomplete files and trailing bytes;
-     * each file uses this parser's options, including its CRC policy.
+     * Parses FIT files in input order with independent decoder state. Uses the
+     * same force and strict policies as parseAsync; strict mode rejects trailing
+     * bytes, while the default ignores a non-FIT suffix after parsed files.
      * Rejects with an Error when any file cannot be parsed.
      */
     parseFilesAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit[]>;

package/dist/cjs/fit-parser.js

@@ -31,21 +31,31 @@ Object.defineProperty(exports, "getFitBaseTypeId", { enumerable: true, get: func
 Object.defineProperty(exports, "readFitMessages", { enumerable: true, get: function () { return raw_message_reader_js_1.readFitMessages; } });
 Object.defineProperty(exports, "readFitStringField", { enumerable: true, get: function () { return raw_message_reader_js_1.readFitStringField; } });
 Object.defineProperty(exports, "readFitUnsignedField", { enumerable: true, get: function () { return raw_message_reader_js_1.readFitUnsignedField; } });
+function hasFitHeader(blob, start) {
+    const headerLength = blob[start];
+    return blob.length - start >= headerLength
+        && (headerLength === 12 || headerLength === 14)
+        && blob[start + 8] === 0x2E
+        && blob[start + 9] === 0x46
+        && blob[start + 10] === 0x49
+        && blob[start + 11] === 0x54;
+}
 class FitParser {
     constructor(options = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         this.options = {
             force: options.force != null ? options.force : true,
+            strict: (_a = options.strict) !== null && _a !== void 0 ? _a : false,
             speedUnit: options.speedUnit || 'm/s',
             lengthUnit: options.lengthUnit || 'm',
             temperatureUnit: options.temperatureUnit || 'celsius',
             elapsedRecordField: options.elapsedRecordField || false,
             pressureUnit: options.pressureUnit || 'bar',
             mode: options.mode || 'list',
-            includeRawDeveloperFields: (_a = options.includeRawDeveloperFields) !== null && _a !== void 0 ? _a : false,
-            includeRawMessages: (_b = options.includeRawMessages) !== null && _b !== void 0 ? _b : false,
-            includeUnmappedMessages: (_c = options.includeUnmappedMessages) !== null && _c !== void 0 ? _c : false,
-            rawMessagesOnly: (_d = options.rawMessagesOnly) !== null && _d !== void 0 ? _d : false,
+            includeRawDeveloperFields: (_b = options.includeRawDeveloperFields) !== null && _b !== void 0 ? _b : false,
+            includeRawMessages: (_c = options.includeRawMessages) !== null && _c !== void 0 ? _c : false,
+            includeUnmappedMessages: (_d = options.includeUnmappedMessages) !== null && _d !== void 0 ? _d : false,
+            rawMessagesOnly: (_e = options.rawMessagesOnly) !== null && _e !== void 0 ? _e : false,
         };
     }
     parseAsync(content) {
@@ -61,9 +71,9 @@ class FitParser {
         });
     }
     /**
-     * Parses every complete FIT file in an input, preserving file order and
-     * independent decoder state. Rejects incomplete files and trailing bytes;
-     * each file uses this parser's options, including its CRC policy.
+     * Parses FIT files in input order with independent decoder state. Uses the
+     * same force and strict policies as parseAsync; strict mode rejects trailing
+     * bytes, while the default ignores a non-FIT suffix after parsed files.
      * Rejects with an Error when any file cannot be parsed.
      */
     parseFilesAsync(content) {
@@ -75,10 +85,13 @@ class FitParser {
             let start = 0;
             do {
                 const remaining = blob.length - start;
+                const headerLength = blob[start];
+                if (results.length > 0 && !this.options.strict && !hasFitHeader(blob, start)) {
+                    break;
+                }
                 if (remaining < 12) {
                     throw new Error('File to small to be a FIT file');
                 }
-                const headerLength = blob[start];
                 if (headerLength !== 12 && headerLength !== 14) {
                     throw new Error('Incorrect header size');
                 }
@@ -94,13 +107,20 @@ class FitParser {
                 const dataLength = new DataView(blob.buffer, blob.byteOffset + start, remaining)
                     .getUint32(4, true);
                 const crcStart = start + headerLength + dataLength;
-                if (crcStart > blob.length) {
-                    throw new Error('File data exceeds input length');
-                }
-                if (crcStart + 2 > blob.length) {
-                    throw new Error('File CRC missing');
+                // File completeness and CRC checks belong to the shared parser below,
+                // preserving the same validation policy and error order in every API.
+                let end = Math.min(crcStart + 2, blob.length);
+                // Missing CRC bytes can also precede the next file. Check only the
+                // declared boundary and its one-byte CRC variant; never scan activity
+                // payloads for a guessed file boundary.
+                if (this.options.force && !this.options.strict) {
+                    if (hasFitHeader(blob, crcStart)) {
+                        end = crcStart;
+                    }
+                    else if (hasFitHeader(blob, crcStart + 1)) {
+                        end = crcStart + 1;
+                    }
                 }
-                const end = crcStart + 2;
                 try {
                     results.push(yield new Promise((resolve, reject) => {
                         this.parseFile(blob.slice(start, end).buffer, (error, data) => {
@@ -110,7 +130,7 @@ class FitParser {
                             else if (data) {
                                 resolve(data);
                             }
-                        }, true);
+                        });
                     }));
                 }
                 catch (error) {
@@ -124,7 +144,7 @@ class FitParser {
     parse(content, callback) {
         this.parseFile(content, callback);
     }
-    parseFile(content, callback, validateRecordBounds = false) {
+    parseFile(content, callback) {
         var _a, _b, _c;
         const blob = content instanceof ArrayBuffer
             ? new Uint8Array(content)
@@ -167,10 +187,14 @@ class FitParser {
             callback('File data exceeds input length', undefined);
             return;
         }
-        if (!this.options.force && crcStart + 2 > blob.length) {
+        if ((!this.options.force || this.options.strict) && crcStart + 2 > blob.length) {
             callback('File CRC missing', undefined);
             return;
         }
+        if (this.options.strict && crcStart + 2 < blob.length) {
+            callback('Unexpected bytes after FIT file', undefined);
+            return;
+        }
         if (!this.options.force) {
             const crcFile = blob[crcStart] + (blob[crcStart + 1] << 8);
             const crcFileCalc = (0, binary_js_1.calculateCRC)(blob, 0, crcStart);
@@ -234,9 +258,7 @@ class FitParser {
         let pausedTime = 0;
         while (loopIndex < crcStart) {
             const { globalMessageNumber, littleEndian, message, messageType, nextIndex, compressedTimestamp, rawFields: recordRawFields, rawDeveloperFields: recordRawDeveloperFields, unmappedFields: recordUnmappedFields, unmappedDeveloperFields: recordUnmappedDeveloperFields, } = (0, binary_js_1.readRecord)(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView, decoderState, crcStart);
-            // Complete-file parsing also validates bounds without requiring raw
-            // retention. The single-file API keeps its existing recovery behavior.
-            if (validateRecordBounds
+            if (this.options.strict
                 && (!Number.isInteger(nextIndex) || nextIndex <= loopIndex || nextIndex > crcStart)) {
                 throw new Error('Invalid FIT record bounds');
             }

package/dist/fit-parser.d.ts

@@ -7,7 +7,10 @@ export { getFitCoursePointId, getFitGarminProductDisplayName, getFitGarminProduc
 export { FitMessageReaderError, fitTimestampToUnixMilliseconds, getFitBaseTypeId, readFitMessages, readFitStringField, readFitUnsignedField, } from './raw-message-reader.js';
 export type { FitMessageReaderErrorCode, FitMessageReaderIssue, FitMessageReaderIssueCode, FitMessageReaderOptions, FitMessageReaderResult, FitRawDeveloperField, FitRawField, FitRawMessage, } from './raw-message-reader.js';
 export interface FitParserOptions {
+    /** Skips CRC validation and enables supported best-effort recovery. Defaults to true. */
     force?: boolean;
+    /** Requires complete files and records, and rejects trailing bytes. Defaults to false. */
+    strict?: boolean;
     speedUnit?: string;
     lengthUnit?: string;
     temperatureUnit?: string;
@@ -29,9 +32,9 @@ export default class FitParser {
     constructor(options?: FitParserOptions);
     parseAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit>;
     /**
-     * Parses every complete FIT file in an input, preserving file order and
-     * independent decoder state. Rejects incomplete files and trailing bytes;
-     * each file uses this parser's options, including its CRC policy.
+     * Parses FIT files in input order with independent decoder state. Uses the
+     * same force and strict policies as parseAsync; strict mode rejects trailing
+     * bytes, while the default ignores a non-FIT suffix after parsed files.
      * Rejects with an Error when any file cannot be parsed.
      */
     parseFilesAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit[]>;

package/dist/fit-parser.js

@@ -12,21 +12,31 @@ import { mapDataIntoLap, mapDataIntoSession } from './helper.js';
 export { FitBaseType, FitEncoder } from './fit-encoder.js';
 export { getFitCoursePointId, getFitGarminProductDisplayName, getFitGarminProductName, getFitManufacturerName, getFitSportId, getFitSportName, getFitSubSportId, getFitSubSportName, } from './profile-lookup.js';
 export { FitMessageReaderError, fitTimestampToUnixMilliseconds, getFitBaseTypeId, readFitMessages, readFitStringField, readFitUnsignedField, } from './raw-message-reader.js';
+function hasFitHeader(blob, start) {
+    const headerLength = blob[start];
+    return blob.length - start >= headerLength
+        && (headerLength === 12 || headerLength === 14)
+        && blob[start + 8] === 0x2E
+        && blob[start + 9] === 0x46
+        && blob[start + 10] === 0x49
+        && blob[start + 11] === 0x54;
+}
 export default class FitParser {
     constructor(options = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         this.options = {
             force: options.force != null ? options.force : true,
+            strict: (_a = options.strict) !== null && _a !== void 0 ? _a : false,
             speedUnit: options.speedUnit || 'm/s',
             lengthUnit: options.lengthUnit || 'm',
             temperatureUnit: options.temperatureUnit || 'celsius',
             elapsedRecordField: options.elapsedRecordField || false,
             pressureUnit: options.pressureUnit || 'bar',
             mode: options.mode || 'list',
-            includeRawDeveloperFields: (_a = options.includeRawDeveloperFields) !== null && _a !== void 0 ? _a : false,
-            includeRawMessages: (_b = options.includeRawMessages) !== null && _b !== void 0 ? _b : false,
-            includeUnmappedMessages: (_c = options.includeUnmappedMessages) !== null && _c !== void 0 ? _c : false,
-            rawMessagesOnly: (_d = options.rawMessagesOnly) !== null && _d !== void 0 ? _d : false,
+            includeRawDeveloperFields: (_b = options.includeRawDeveloperFields) !== null && _b !== void 0 ? _b : false,
+            includeRawMessages: (_c = options.includeRawMessages) !== null && _c !== void 0 ? _c : false,
+            includeUnmappedMessages: (_d = options.includeUnmappedMessages) !== null && _d !== void 0 ? _d : false,
+            rawMessagesOnly: (_e = options.rawMessagesOnly) !== null && _e !== void 0 ? _e : false,
         };
     }
     parseAsync(content) {
@@ -42,9 +52,9 @@ export default class FitParser {
         });
     }
     /**
-     * Parses every complete FIT file in an input, preserving file order and
-     * independent decoder state. Rejects incomplete files and trailing bytes;
-     * each file uses this parser's options, including its CRC policy.
+     * Parses FIT files in input order with independent decoder state. Uses the
+     * same force and strict policies as parseAsync; strict mode rejects trailing
+     * bytes, while the default ignores a non-FIT suffix after parsed files.
      * Rejects with an Error when any file cannot be parsed.
      */
     parseFilesAsync(content) {
@@ -56,10 +66,13 @@ export default class FitParser {
             let start = 0;
             do {
                 const remaining = blob.length - start;
+                const headerLength = blob[start];
+                if (results.length > 0 && !this.options.strict && !hasFitHeader(blob, start)) {
+                    break;
+                }
                 if (remaining < 12) {
                     throw new Error('File to small to be a FIT file');
                 }
-                const headerLength = blob[start];
                 if (headerLength !== 12 && headerLength !== 14) {
                     throw new Error('Incorrect header size');
                 }
@@ -75,13 +88,20 @@ export default class FitParser {
                 const dataLength = new DataView(blob.buffer, blob.byteOffset + start, remaining)
                     .getUint32(4, true);
                 const crcStart = start + headerLength + dataLength;
-                if (crcStart > blob.length) {
-                    throw new Error('File data exceeds input length');
-                }
-                if (crcStart + 2 > blob.length) {
-                    throw new Error('File CRC missing');
+                // File completeness and CRC checks belong to the shared parser below,
+                // preserving the same validation policy and error order in every API.
+                let end = Math.min(crcStart + 2, blob.length);
+                // Missing CRC bytes can also precede the next file. Check only the
+                // declared boundary and its one-byte CRC variant; never scan activity
+                // payloads for a guessed file boundary.
+                if (this.options.force && !this.options.strict) {
+                    if (hasFitHeader(blob, crcStart)) {
+                        end = crcStart;
+                    }
+                    else if (hasFitHeader(blob, crcStart + 1)) {
+                        end = crcStart + 1;
+                    }
                 }
-                const end = crcStart + 2;
                 try {
                     results.push(yield new Promise((resolve, reject) => {
                         this.parseFile(blob.slice(start, end).buffer, (error, data) => {
@@ -91,7 +111,7 @@ export default class FitParser {
                             else if (data) {
                                 resolve(data);
                             }
-                        }, true);
+                        });
                     }));
                 }
                 catch (error) {
@@ -105,7 +125,7 @@ export default class FitParser {
     parse(content, callback) {
         this.parseFile(content, callback);
     }
-    parseFile(content, callback, validateRecordBounds = false) {
+    parseFile(content, callback) {
         var _a, _b, _c;
         const blob = content instanceof ArrayBuffer
             ? new Uint8Array(content)
@@ -148,10 +168,14 @@ export default class FitParser {
             callback('File data exceeds input length', undefined);
             return;
         }
-        if (!this.options.force && crcStart + 2 > blob.length) {
+        if ((!this.options.force || this.options.strict) && crcStart + 2 > blob.length) {
             callback('File CRC missing', undefined);
             return;
         }
+        if (this.options.strict && crcStart + 2 < blob.length) {
+            callback('Unexpected bytes after FIT file', undefined);
+            return;
+        }
         if (!this.options.force) {
             const crcFile = blob[crcStart] + (blob[crcStart + 1] << 8);
             const crcFileCalc = calculateCRC(blob, 0, crcStart);
@@ -215,9 +239,7 @@ export default class FitParser {
         let pausedTime = 0;
         while (loopIndex < crcStart) {
             const { globalMessageNumber, littleEndian, message, messageType, nextIndex, compressedTimestamp, rawFields: recordRawFields, rawDeveloperFields: recordRawDeveloperFields, unmappedFields: recordUnmappedFields, unmappedDeveloperFields: recordUnmappedDeveloperFields, } = readRecord(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView, decoderState, crcStart);
-            // Complete-file parsing also validates bounds without requiring raw
-            // retention. The single-file API keeps its existing recovery behavior.
-            if (validateRecordBounds
+            if (this.options.strict
                 && (!Number.isInteger(nextIndex) || nextIndex <= loopIndex || nextIndex > crcStart)) {
                 throw new Error('Invalid FIT record bounds');
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fit-file-parser",
   "type": "module",
-  "version": "6.2.0",
+  "version": "6.2.2",
   "private": false,
   "description": "JavaScript and TypeScript library for parsing and encoding FIT files, with developer-field support, raw message access, and ESM/CommonJS builds.",
   "author": {