@zwave-js/nvmedit 13.3.0 → 13.4.0

package/build/lib/NVM3.js

@@ -0,0 +1,650 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NVM3 = void 0;
+const core_1 = require("@zwave-js/core");
+const shared_1 = require("@zwave-js/shared");
+const definitions_1 = require("./common/definitions");
+const utils_1 = require("./common/utils");
+const consts_1 = require("./nvm3/consts");
+const files_1 = require("./nvm3/files");
+const object_1 = require("./nvm3/object");
+const page_1 = require("./nvm3/page");
+const utils_2 = require("./nvm3/utils");
+class NVM3 {
+    constructor(io) {
+        this._io = io;
+    }
+    _io;
+    _access = definitions_1.NVMAccess.None;
+    _info;
+    get info() {
+        return this._info;
+    }
+    async ensureReadable() {
+        if (this._access === definitions_1.NVMAccess.Read
+            || this._access === definitions_1.NVMAccess.ReadWrite) {
+            return;
+        }
+        if (this._access === definitions_1.NVMAccess.Write) {
+            await this._io.close();
+        }
+        this._access = await this._io.open(definitions_1.NVMAccess.Read);
+    }
+    async ensureWritable() {
+        if (this._access === definitions_1.NVMAccess.Write
+            || this._access === definitions_1.NVMAccess.ReadWrite) {
+            return;
+        }
+        if (this._access === definitions_1.NVMAccess.Read) {
+            await this._io.close();
+        }
+        this._access = await this._io.open(definitions_1.NVMAccess.Write);
+    }
+    async init() {
+        await this.ensureReadable();
+        let pageOffset = 0;
+        // Determine NVM size, scan pages
+        const pages = [];
+        let isSharedFileSystem = false;
+        while (pageOffset < this._io.size) {
+            // console.debug(
+            // 	`NVM3 init() - reading page header at offset ${
+            // 		num2hex(pageOffset)
+            // 	}`,
+            // );
+            const header = await readPageHeader(this._io, pageOffset);
+            pages.push({
+                ...header,
+                objects: [],
+            });
+            pageOffset += header.pageSize;
+        }
+        // Scan each page for objects
+        for (const page of pages) {
+            // Scan objects in this page
+            let objectOffset = page.offset + consts_1.NVM3_PAGE_HEADER_SIZE;
+            const nextPageOffset = page.offset + page.pageSize;
+            while (objectOffset < nextPageOffset) {
+                // console.debug(
+                // 	`NVM3 init() - reading object header. page offset ${
+                // 		num2hex(page.offset)
+                // 	}, object offset ${num2hex(objectOffset)}`,
+                // );
+                const objectHeader = await readObjectHeader(this._io, objectOffset);
+                if (objectHeader) {
+                    page.objects.push(objectHeader);
+                    objectOffset += objectHeader.alignedSize;
+                    // Detect the 800 series shared protocol & application NVM file system
+                    // by looking for the 800 series application version file
+                    if (objectHeader.key === files_1.ApplicationVersionFile800ID) {
+                        isSharedFileSystem = true;
+                    }
+                }
+                else {
+                    // Reached the end of the data in this page
+                    break;
+                }
+            }
+        }
+        // By convention, we only use the applicationPages in that case
+        let applicationPages;
+        let protocolPages;
+        if (isSharedFileSystem) {
+            applicationPages = pages;
+            protocolPages = [];
+        }
+        else {
+            applicationPages = pages.filter((p) => p.offset < consts_1.ZWAVE_APPLICATION_NVM_SIZE);
+            protocolPages = pages.filter((p) => p.offset >= consts_1.ZWAVE_APPLICATION_NVM_SIZE);
+        }
+        // NVM3 layouts pages in a ring buffer. Pages are written from front to back, then occupied pages
+        // are erased and overwritten. Pages at the start of the memory section may have an erase count that's 1 higher
+        // than the pages at the end.
+        const pageInfoToSectionInfo = (pages) => {
+            // Find the current page, which is either:
+            // - The last page with the high erase count that contains an object
+            const maxEraseCount = Math.max(...pages.map((p) => p.eraseCount));
+            let currentPageIndex = pages.findLastIndex((p) => p.eraseCount === maxEraseCount && p.objects.length > 0);
+            // - or if there is none, the last page with the lower erase count that contains an object
+            if (currentPageIndex === -1) {
+                currentPageIndex = pages.findLastIndex((p) => p.objects.length > 0);
+            }
+            // - Or if no objects exist at all, the beginning of the section
+            if (currentPageIndex === -1)
+                currentPageIndex = 0;
+            // Find the next free byte of the current page
+            const currentPage = pages[currentPageIndex];
+            let offset = consts_1.NVM3_PAGE_HEADER_SIZE;
+            for (const object of currentPage.objects) {
+                offset += object.alignedSize;
+            }
+            const objectLocations = new Map();
+            for (let i = 0; i < pages.length; i++) {
+                const page = pages[i];
+                for (const object of page.objects) {
+                    const location = objectLocations.get(object.key);
+                    if (location == undefined) {
+                        // Object seen for the first time, remember the page it is in
+                        objectLocations.set(object.key, i);
+                    }
+                    else if ((object.fragmentType === consts_1.FragmentType.None
+                        || object.fragmentType === consts_1.FragmentType.First)
+                        && (page.eraseCount >= pages[location].eraseCount)) {
+                        // Object was seen before. Only remember it if it is the only
+                        // or first fragment and the object appears in a later location
+                        // of the ring buffer
+                        objectLocations.set(object.key, i);
+                    }
+                }
+            }
+            return {
+                pages,
+                offsetInPage: offset,
+                currentPage: currentPageIndex,
+                objectLocations,
+            };
+        };
+        if (isSharedFileSystem) {
+            this._info = {
+                isSharedFileSystem: true,
+                sections: {
+                    all: pageInfoToSectionInfo(applicationPages),
+                },
+            };
+        }
+        else {
+            this._info = {
+                isSharedFileSystem: false,
+                sections: {
+                    application: pageInfoToSectionInfo(applicationPages),
+                    protocol: pageInfoToSectionInfo(protocolPages),
+                },
+            };
+        }
+        return this._info;
+    }
+    getNVMSectionForFile(fileId) {
+        // Determine which ring buffer to read in
+        return this._info.isSharedFileSystem
+            ? this._info.sections.all
+            : this._info.sections[(0, files_1.getNVMSectionByFileID)(fileId)];
+    }
+    async has(fileId) {
+        this._info ??= await this.init();
+        // Determine which ring buffer to read in
+        const section = this.getNVMSectionForFile(fileId);
+        return section.objectLocations.has(fileId);
+    }
+    readObjectData(object) {
+        return (0, utils_1.nvmReadBuffer)(this._io, object.offset + object.headerSize, object.fragmentSize);
+    }
+    async get(fileId) {
+        this._info ??= await this.init();
+        // Determine which ring buffer to read in
+        const section = this.getNVMSectionForFile(fileId);
+        const pages = section.pages;
+        // TODO: There should be no need for scanning, since we know the object locations after init().
+        // Start scanning backwards through the pages ring buffer, starting with the current page
+        let parts;
+        let complete = false;
+        let objType;
+        const resetFragments = () => {
+            // if (parts?.length) {
+            // 	console.debug("Resetting fragmented object");
+            // }
+            parts = undefined;
+            complete = false;
+        };
+        pages: for (let offset = 0; offset < pages.length; offset++) {
+            const index = (section.currentPage - offset + pages.length)
+                % pages.length;
+            const page = pages[index];
+            // console.debug(
+            // 	`NVM3.get(${fileId}): scanning page ${index} at offset ${
+            // 		num2hex(page.offset)
+            // 	}`,
+            // );
+            // Scan objects in this page, read backwards.
+            // The last non-deleted object wins
+            objects: for (let j = page.objects.length - 1; j >= 0; j--) {
+                const object = page.objects[j];
+                const readObject = () => this.readObjectData(object);
+                if (object.key !== fileId) {
+                    // Reset any fragmented objects when encountering a different key
+                    resetFragments();
+                    continue objects;
+                }
+                if (object.type === consts_1.ObjectType.Deleted) {
+                    // Last action for this object was a deletion. There is no data.
+                    return;
+                }
+                else if (object.fragmentType === consts_1.FragmentType.None) {
+                    // console.debug(
+                    // 	`NVM3.get(${fileId}): found complete object - header offset ${
+                    // 		num2hex(object.offset)
+                    // 	}, content offset ${
+                    // 		num2hex(object.offset + object.headerSize)
+                    // 	}, length ${object.fragmentSize}`,
+                    // );
+                    // This is a complete object
+                    parts = [await readObject()];
+                    objType = object.type;
+                    complete = true;
+                    break pages;
+                }
+                else if (object.fragmentType === consts_1.FragmentType.Last) {
+                    // console.debug(
+                    // 	`NVM3.get(${fileId}): found LAST fragment - header offset ${
+                    // 		num2hex(object.offset)
+                    // 	}, content offset ${
+                    // 		num2hex(object.offset + object.headerSize)
+                    // 	}, length ${object.fragmentSize}`,
+                    // );
+                    parts = [await readObject()];
+                    objType = object.type;
+                    complete = false;
+                }
+                else if (object.fragmentType === consts_1.FragmentType.Next) {
+                    if (parts?.length && objType === object.type) {
+                        // console.debug(
+                        // 	`NVM3.get(${fileId}): found NEXT fragment - header offset ${
+                        // 		num2hex(object.offset)
+                        // 	}, content offset ${
+                        // 		num2hex(object.offset + object.headerSize)
+                        // 	}, length ${object.fragmentSize}`,
+                        // );
+                        parts.unshift(await readObject());
+                    }
+                    else {
+                        // This shouldn't be here
+                        resetFragments();
+                    }
+                }
+                else if (object.fragmentType === consts_1.FragmentType.First) {
+                    if (parts?.length && objType === object.type) {
+                        // console.debug(
+                        // 	`NVM3.get(${fileId}): found FIRST fragment - header offset ${
+                        // 		num2hex(object.offset)
+                        // 	}, content offset ${
+                        // 		num2hex(object.offset + object.headerSize)
+                        // 	}, length ${object.fragmentSize}`,
+                        // );
+                        parts.unshift(await readObject());
+                        complete = true;
+                        break pages;
+                    }
+                    else {
+                        // This shouldn't be here
+                        resetFragments();
+                    }
+                }
+            }
+        }
+        if (!parts?.length || !complete || objType == undefined)
+            return;
+        return Buffer.concat(parts);
+    }
+    async writeObjects(objects) {
+        const section = this.getNVMSectionForFile(objects[0].key);
+        let page = section.pages[section.currentPage];
+        let remainingSpace = page.pageSize
+            - consts_1.NVM3_PAGE_HEADER_SIZE
+            - section.offsetInPage;
+        // TODO: See if we can avoid double writes on a page change
+        /** Moves to the next page and erases it if necessary */
+        const nextPage = async () => {
+            section.currentPage = (section.currentPage + 1)
+                % section.pages.length;
+            page = section.pages[section.currentPage];
+            // Find headers of objects that need to be preserved
+            const toPreserve = [...section.objectLocations].filter(([, pageIndex]) => pageIndex === section.currentPage)
+                .map(([fileID]) => page.objects.findLast((h) => h.key === fileID))
+                .filter((h) => h != undefined)
+                .filter((h) => h.type !== consts_1.ObjectType.Deleted);
+            // And add the objects to the TODO list
+            for (const header of toPreserve) {
+                const data = await this.get(header.key);
+                console.error(`Need to preserve object ${(0, shared_1.num2hex)(header.key)}
+  page index: ${section.currentPage}
+  object type: ${(0, shared_1.getEnumMemberName)(consts_1.ObjectType, header.type)}
+  data:        ${data != undefined ? `${data.length} bytes` : "(no data)"}`);
+                objects.push({
+                    key: header.key,
+                    type: header.type,
+                    fragmentType: consts_1.FragmentType.None,
+                    data,
+                });
+            }
+            if (page.objects.length > 0) {
+                // The page needs to be erased
+                page.eraseCount++;
+                page.objects = [];
+                const pageHeaderBuffer = (0, page_1.serializePageHeader)(page);
+                const pageBuffer = Buffer.alloc(page.pageSize, 0xff);
+                pageHeaderBuffer.copy(pageBuffer, 0);
+                await (0, utils_1.nvmWriteBuffer)(this._io, page.offset, pageBuffer);
+            }
+            section.offsetInPage = consts_1.NVM3_PAGE_HEADER_SIZE;
+            remainingSpace = page.pageSize - consts_1.NVM3_PAGE_HEADER_SIZE;
+        };
+        // Go through the list of objects and write all of them to the NVM
+        for (const object of objects) {
+            const isLargeObject = object.type === consts_1.ObjectType.DataLarge
+                || object.type === consts_1.ObjectType.CounterLarge;
+            let fragments;
+            if (isLargeObject) {
+                // Large objects may be fragmented
+                // We need to start a new page, if the remaining space is not enough for
+                // the object header plus additional data
+                if (remainingSpace <= consts_1.NVM3_OBJ_HEADER_SIZE_LARGE) {
+                    await nextPage();
+                }
+                fragments = (0, object_1.fragmentLargeObject)(object, remainingSpace, page.pageSize - consts_1.NVM3_PAGE_HEADER_SIZE);
+            }
+            else {
+                // Small objects cannot be fragmented. If they don't fit,
+                // they need to go on the next page.
+                const requiredSpace = (0, object_1.getRequiredSpace)(object);
+                if (requiredSpace > remainingSpace) {
+                    await nextPage();
+                }
+                fragments = [object];
+            }
+            // Write each fragment to the NVM. If there are multiple fragments,
+            // each one but the first needs to be written at the beginning of a new page
+            for (let i = 0; i < fragments.length; i++) {
+                if (i > 0)
+                    await nextPage();
+                const fragment = fragments[i];
+                const objBuffer = (0, object_1.serializeObject)(fragment);
+                const objOffset = page.offset + section.offsetInPage;
+                await this._io.write(objOffset, objBuffer);
+                const requiredSpace = (0, object_1.getRequiredSpace)(fragment);
+                section.offsetInPage += requiredSpace;
+                remainingSpace -= requiredSpace;
+                // Remember which objects exist in this page
+                page.objects.push((0, object_1.getObjectHeader)(object, objOffset));
+                // And remember where this object lives
+                if (object.type === consts_1.ObjectType.Deleted) {
+                    section.objectLocations.delete(object.key);
+                }
+                else if (fragment.fragmentType === consts_1.FragmentType.None
+                    || fragment.fragmentType === consts_1.FragmentType.First) {
+                    section.objectLocations.set(fragment.key, section.currentPage);
+                }
+            }
+        }
+    }
+    async set(property, value) {
+        if (!this._info)
+            await this.init();
+        await this.ensureWritable();
+        await this.writeObjects([{
+                key: property,
+                type: value.length <= consts_1.NVM3_MAX_OBJ_SIZE_SMALL
+                    ? consts_1.ObjectType.DataSmall
+                    : consts_1.ObjectType.DataLarge,
+                // writeObject deals with fragmentation
+                fragmentType: consts_1.FragmentType.None,
+                data: value,
+            }]);
+    }
+    /** Writes multiple values to the NVM at once. `null` / `undefined` cause the value to be deleted */
+    async setMany(values) {
+        if (!this._info)
+            await this.init();
+        await this.ensureWritable();
+        // Group objects by their NVM section
+        const objectsBySection = new Map();
+        for (const [key, value] of values) {
+            const sectionOffset = this.getNVMSectionForFile(key).pages[0].offset;
+            if (!objectsBySection.has(sectionOffset)) {
+                objectsBySection.set(sectionOffset, []);
+            }
+            objectsBySection.get(sectionOffset).push([key, value]);
+        }
+        // And call writeObjects for each group
+        for (const objectGroups of objectsBySection.values()) {
+            await this.writeObjects(objectGroups.map(([key, value]) => (value
+                ? {
+                    key,
+                    type: value.length <= consts_1.NVM3_MAX_OBJ_SIZE_SMALL
+                        ? consts_1.ObjectType.DataSmall
+                        : consts_1.ObjectType.DataLarge,
+                    // writeObject deals with fragmentation
+                    fragmentType: consts_1.FragmentType.None,
+                    data: value,
+                }
+                : {
+                    key,
+                    type: consts_1.ObjectType.Deleted,
+                    fragmentType: consts_1.FragmentType.None,
+                })));
+        }
+    }
+    async delete(property) {
+        if (!this._info)
+            await this.init();
+        await this.ensureWritable();
+        await this.writeObjects([{
+                key: property,
+                type: consts_1.ObjectType.Deleted,
+                fragmentType: consts_1.FragmentType.None,
+            }]);
+    }
+    async erase(options) {
+        const { deviceFamily = 2047, writeSize = consts_1.PageWriteSize.WRITE_SIZE_16, memoryMapped = true, sharedFileSystem = false, } = options ?? {};
+        const maxPageSize = sharedFileSystem
+            ? consts_1.FLASH_MAX_PAGE_SIZE_800
+            : consts_1.FLASH_MAX_PAGE_SIZE_700;
+        const pageSize = Math.min(options?.pageSize ?? maxPageSize, maxPageSize);
+        // Make sure we won't be writing incomplete pages
+        if (this._io.size % pageSize !== 0) {
+            throw new core_1.ZWaveError(`Invalid page size. NVM size ${this._io.size} must be a multiple of the page size ${pageSize}.`, core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (!sharedFileSystem && consts_1.ZWAVE_APPLICATION_NVM_SIZE % pageSize !== 0) {
+            throw new core_1.ZWaveError(`Invalid page size. The application NVM size ${consts_1.ZWAVE_APPLICATION_NVM_SIZE} must be a multiple of the page size ${pageSize}.`, core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (!sharedFileSystem
+            && (this._io.size - consts_1.ZWAVE_APPLICATION_NVM_SIZE) % pageSize !== 0) {
+            throw new core_1.ZWaveError(`Invalid page size. The protocol NVM size ${this._io.size
+                - consts_1.ZWAVE_APPLICATION_NVM_SIZE} must be a multiple of the page size ${pageSize}.`, core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        await this.ensureWritable();
+        // Create empty pages, write them to the NVM
+        const applicationPages = [];
+        const protocolPages = [];
+        const numPages = this._io.size / pageSize;
+        for (let i = 0; i < numPages; i++) {
+            const offset = i * pageSize;
+            const pageBuffer = Buffer.alloc(pageSize, 0xff);
+            const pageHeader = {
+                offset,
+                version: 0x01,
+                eraseCount: 0,
+                encrypted: false,
+                deviceFamily,
+                memoryMapped,
+                pageSize,
+                status: consts_1.PageStatus.OK,
+                writeSize,
+            };
+            (0, page_1.serializePageHeader)(pageHeader).copy(pageBuffer, 0);
+            await (0, utils_1.nvmWriteBuffer)(this._io, offset, pageBuffer);
+            if (sharedFileSystem || offset < consts_1.ZWAVE_APPLICATION_NVM_SIZE) {
+                applicationPages.push({ ...pageHeader, objects: [] });
+            }
+            else {
+                protocolPages.push({ ...pageHeader, objects: [] });
+            }
+        }
+        // Remember the pages we just created for further use
+        this._info = sharedFileSystem
+            ? {
+                isSharedFileSystem: true,
+                sections: {
+                    all: {
+                        currentPage: 0,
+                        objectLocations: new Map(),
+                        offsetInPage: consts_1.NVM3_PAGE_HEADER_SIZE,
+                        pages: applicationPages,
+                    },
+                },
+            }
+            : {
+                isSharedFileSystem: false,
+                sections: {
+                    application: {
+                        currentPage: 0,
+                        objectLocations: new Map(),
+                        offsetInPage: consts_1.NVM3_PAGE_HEADER_SIZE,
+                        pages: applicationPages,
+                    },
+                    protocol: {
+                        currentPage: 0,
+                        objectLocations: new Map(),
+                        offsetInPage: consts_1.NVM3_PAGE_HEADER_SIZE,
+                        pages: protocolPages,
+                    },
+                },
+            };
+    }
+}
+exports.NVM3 = NVM3;
+async function readPageHeader(io, offset) {
+    if (offset > io.size - consts_1.NVM3_PAGE_HEADER_SIZE) {
+        throw new core_1.ZWaveError("Incomplete page in buffer!", core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    const buffer = (await io.read(offset, consts_1.NVM3_PAGE_HEADER_SIZE)).buffer;
+    const { version, eraseCount } = tryGetVersionAndEraseCount(buffer);
+    // Page status
+    const status = buffer.readUInt32LE(12);
+    const devInfo = buffer.readUInt16LE(16);
+    const deviceFamily = devInfo & 0x7ff;
+    const writeSize = (devInfo >> 11) & 0b1;
+    const memoryMapped = !!((devInfo >> 12) & 0b1);
+    let pageSize = (0, page_1.pageSizeFromBits)((devInfo >> 13) & 0b111);
+    if (pageSize > 0xffff) {
+        // Some controllers have no valid info in the page size bits, resulting
+        // in an impossibly large page size. To try and figure out the actual page
+        // size without knowing the hardware, we scan the buffer for the next valid
+        // page start.
+        for (let exponent = 0; exponent < 0b111; exponent++) {
+            const testPageSize = (0, page_1.pageSizeFromBits)(exponent);
+            const nextOffset = offset + testPageSize;
+            if (
+            // exactly end of NVM OR
+            io.size === nextOffset
+                // next page
+                || await isValidPageHeaderAtOffset(io, nextOffset)) {
+                pageSize = testPageSize;
+                break;
+            }
+        }
+    }
+    if (pageSize > 0xffff) {
+        throw new core_1.ZWaveError("Could not determine page size!", core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    if (io.size < offset + pageSize) {
+        throw new core_1.ZWaveError(`NVM contains incomplete page at offset ${(0, shared_1.num2hex)(offset)}!`, core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    const formatInfo = buffer.readUInt16LE(18);
+    const encrypted = !(formatInfo & 0b1);
+    return {
+        offset,
+        version,
+        eraseCount,
+        status,
+        encrypted,
+        pageSize,
+        writeSize,
+        memoryMapped,
+        deviceFamily,
+    };
+}
+function tryGetVersionAndEraseCount(header) {
+    const version = header.readUInt16LE(0);
+    const magic = header.readUInt16LE(2);
+    if (magic !== consts_1.NVM3_PAGE_MAGIC) {
+        throw new core_1.ZWaveError("Not a valid NVM3 page!", core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    if (version !== 0x01) {
+        throw new core_1.ZWaveError(`Unsupported NVM3 page version: ${version}`, core_1.ZWaveErrorCodes.NVM_NotSupported);
+    }
+    // The erase counter is saved twice, once normally, once inverted
+    let eraseCount = header.readUInt32LE(4);
+    const eraseCountCode = eraseCount >>> consts_1.NVM3_PAGE_COUNTER_SIZE;
+    eraseCount &= consts_1.NVM3_PAGE_COUNTER_MASK;
+    (0, utils_2.validateBergerCode)(eraseCount, eraseCountCode, consts_1.NVM3_PAGE_COUNTER_SIZE);
+    let eraseCountInv = header.readUInt32LE(8);
+    const eraseCountInvCode = eraseCountInv >>> consts_1.NVM3_PAGE_COUNTER_SIZE;
+    eraseCountInv &= consts_1.NVM3_PAGE_COUNTER_MASK;
+    (0, utils_2.validateBergerCode)(eraseCountInv, eraseCountInvCode, consts_1.NVM3_PAGE_COUNTER_SIZE);
+    if (eraseCount !== (~eraseCountInv & consts_1.NVM3_PAGE_COUNTER_MASK)) {
+        throw new core_1.ZWaveError("Invalid erase count!", core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    return { version, eraseCount };
+}
+async function isValidPageHeaderAtOffset(io, offset) {
+    if (offset > io.size - consts_1.NVM3_PAGE_HEADER_SIZE) {
+        return false;
+    }
+    const { buffer } = await io.read(offset, consts_1.NVM3_PAGE_HEADER_SIZE);
+    try {
+        tryGetVersionAndEraseCount(buffer);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readObjectHeader(io, offset) {
+    let headerSize = 4;
+    const hdr1 = await (0, utils_1.nvmReadUInt32LE)(io, offset);
+    // Skip over blank page areas
+    if (hdr1 === 0xffffffff)
+        return;
+    const key = (hdr1 >> consts_1.NVM3_OBJ_KEY_SHIFT) & consts_1.NVM3_OBJ_KEY_MASK;
+    let objType = hdr1 & consts_1.NVM3_OBJ_TYPE_MASK;
+    let fragmentSize = 0;
+    let hdr2;
+    const isLarge = objType === consts_1.ObjectType.DataLarge
+        || objType === consts_1.ObjectType.CounterLarge;
+    if (isLarge) {
+        hdr2 = await (0, utils_1.nvmReadUInt32LE)(io, offset + 4);
+        headerSize += 4;
+        fragmentSize = hdr2 & consts_1.NVM3_OBJ_LARGE_LEN_MASK;
+    }
+    else if (objType > consts_1.ObjectType.DataSmall) {
+        // In small objects with data, the length and object type are stored in the same value
+        fragmentSize = objType - consts_1.ObjectType.DataSmall;
+        objType = consts_1.ObjectType.DataSmall;
+    }
+    else if (objType === consts_1.ObjectType.CounterSmall) {
+        fragmentSize = consts_1.NVM3_COUNTER_SIZE;
+    }
+    const fragmentType = isLarge
+        ? (hdr1 >>> consts_1.NVM3_OBJ_FRAGTYPE_SHIFT) & consts_1.NVM3_OBJ_FRAGTYPE_MASK
+        : consts_1.FragmentType.None;
+    if (isLarge) {
+        (0, utils_2.validateBergerCodeMulti)([hdr1, hdr2], 32 + consts_1.NVM3_CODE_LARGE_SHIFT);
+    }
+    else {
+        (0, utils_2.validateBergerCodeMulti)([hdr1], consts_1.NVM3_CODE_SMALL_SHIFT);
+    }
+    if (io.size < offset + headerSize + fragmentSize) {
+        throw new core_1.ZWaveError(`NVM contains incomplete object at offset ${(0, shared_1.num2hex)(offset)}!`, core_1.ZWaveErrorCodes.NVM_InvalidFormat);
+    }
+    const alignedFragmentSize = (0, object_1.getAlignedSize)(fragmentSize);
+    const alignedSize = headerSize + alignedFragmentSize;
+    return {
+        key,
+        offset,
+        type: objType,
+        fragmentType,
+        headerSize,
+        fragmentSize,
+        alignedSize,
+    };
+}
+//# sourceMappingURL=NVM3.js.map