@zwave-js/nvmedit 13.2.0 → 13.4.0

package/build/lib/nvm3/adapter.js

@@ -0,0 +1,903 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NVM3Adapter = void 0;
+const core_1 = require("@zwave-js/core");
+const shared_1 = require("@zwave-js/shared");
+const helpers_1 = require("alcalzone-shared/helpers");
+const consts_1 = require("../../consts");
+const files_1 = require("./files");
+const DEFAULT_FILE_VERSION = "7.0.0";
+class NVM3Adapter {
+    constructor(nvm) {
+        this._nvm = nvm;
+    }
+    _nvm;
+    _initialized = false;
+    _protocolInfo;
+    _applicationInfo;
+    /** A list of pending changes that haven't been written to the NVM yet. `null` indicates a deleted entry. */
+    _pendingChanges = new Map();
+    getFileVersion(fileId) {
+        if (fileId === files_1.ProtocolVersionFileID
+            || fileId === files_1.ApplicationVersionFileID
+            || fileId === files_1.ApplicationVersionFile800ID) {
+            return DEFAULT_FILE_VERSION;
+        }
+        const section = (0, files_1.getNVMSectionByFileID)(fileId);
+        if (section === "application") {
+            return this._applicationInfo?.version ?? DEFAULT_FILE_VERSION;
+        }
+        else if (section === "protocol") {
+            return this._protocolInfo?.version ?? DEFAULT_FILE_VERSION;
+        }
+        return DEFAULT_FILE_VERSION;
+    }
+    async init() {
+        if (!this._protocolInfo) {
+            const protocolVersionFile = await this._getFile(files_1.ProtocolVersionFileID, true);
+            if (protocolVersionFile) {
+                const version = `${protocolVersionFile.major}.${protocolVersionFile.minor}.${protocolVersionFile.patch}`;
+                this._protocolInfo = {
+                    version,
+                    format: protocolVersionFile.format,
+                };
+            }
+        }
+        if (!this._applicationInfo) {
+            const applicationVersionFile700 = await this._getFile(files_1.ApplicationVersionFileID, true);
+            const applicationVersionFile800 = await this._getFile(files_1.ApplicationVersionFile800ID, true);
+            const applicationVersionFile = applicationVersionFile700
+                ?? applicationVersionFile800;
+            if (applicationVersionFile) {
+                const version = `${applicationVersionFile.major}.${applicationVersionFile.minor}.${applicationVersionFile.patch}`;
+                this._applicationInfo = {
+                    version,
+                    format: applicationVersionFile.format,
+                };
+            }
+        }
+        this._initialized = true;
+    }
+    /** Adds a complete file to the list of pending changes */
+    setFile(file) {
+        const { key, data } = file.serialize();
+        this._pendingChanges.set(key, data);
+    }
+    async hasFile(fileId) {
+        if (!this._initialized)
+            await this.init();
+        if (this._pendingChanges.has(fileId)) {
+            return this._pendingChanges.get(fileId) !== null;
+        }
+        else {
+            return this._nvm.has(fileId);
+        }
+    }
+    async _getFile(fileId, skipInit = false) {
+        if (!skipInit && !this._initialized)
+            await this.init();
+        // Prefer pending changes over the actual NVM, so changes can be composed
+        let data;
+        if (this._pendingChanges.has(fileId)) {
+            data = this._pendingChanges.get(fileId);
+        }
+        else {
+            data = await this._nvm.get(fileId);
+        }
+        if (!data)
+            return;
+        const fileVersion = this.getFileVersion(fileId);
+        return files_1.NVMFile.from(fileId, data, fileVersion);
+    }
+    async _expectFile(fileId, skipInit = false) {
+        const file = await this._getFile(fileId, skipInit);
+        if (!file) {
+            throw new core_1.ZWaveError(`NVM file ${(0, shared_1.num2hex)(fileId)} not found`, core_1.ZWaveErrorCodes.NVM_ObjectNotFound);
+        }
+        return file;
+    }
+    getFile(fileId, required) {
+        if (required) {
+            return this._expectFile(fileId);
+        }
+        else {
+            return this._getFile(fileId);
+        }
+    }
+    get(property, required) {
+        if (property.domain === "controller") {
+            return this.getControllerNVMProperty(property, !!required);
+        }
+        else if (property.domain === "lrnode") {
+            return this.getLRNodeNVMProperty(property, !!required);
+        }
+        else {
+            return this.getNodeNVMProperty(property, !!required);
+        }
+    }
+    async getControllerNVMProperty(property, required) {
+        const getFile = (fileId) => {
+            if (required) {
+                return this._expectFile(fileId);
+            }
+            else {
+                return this._getFile(fileId);
+            }
+        };
+        switch (property.type) {
+            case "protocolVersion": {
+                const file = await getFile(files_1.ProtocolVersionFileID);
+                if (!file)
+                    return;
+                return `${file.major}.${file.minor}.${file.patch}`;
+            }
+            case "protocolFileFormat": {
+                const file = await getFile(files_1.ProtocolVersionFileID);
+                return file?.format;
+            }
+            case "applicationVersion":
+            case "applicationFileFormat": {
+                const file700 = await this._getFile(files_1.ApplicationVersionFileID);
+                const file800 = await this._getFile(files_1.ApplicationVersionFile800ID);
+                const file = file700 ?? file800;
+                if (!file) {
+                    if (required) {
+                        throw new core_1.ZWaveError("ApplicationVersionFile not found!", core_1.ZWaveErrorCodes.NVM_ObjectNotFound);
+                    }
+                    else {
+                        return;
+                    }
+                }
+                if (property.type === "applicationVersion") {
+                    return `${file.major}.${file.minor}.${file.patch}`;
+                }
+                else if (property.type === "applicationFileFormat") {
+                    return file?.format;
+                }
+            }
+            case "applicationData": {
+                const file = await getFile(files_1.ApplicationDataFileID);
+                return file?.applicationData;
+            }
+            case "applicationName": {
+                const file = await getFile(files_1.ApplicationNameFileID);
+                return file?.name;
+            }
+            case "homeId":
+            case "nodeId":
+            case "lastNodeId":
+            case "staticControllerNodeId":
+            case "sucLastIndex":
+            case "controllerConfiguration":
+            case "sucAwarenessPushNeeded":
+            case "maxNodeId":
+            case "reservedId":
+            case "systemState":
+            case "lastNodeIdLR":
+            case "maxNodeIdLR":
+            case "reservedIdLR":
+            case "primaryLongRangeChannelId":
+            case "dcdcConfig": {
+                const file = await getFile(files_1.ControllerInfoFileID);
+                return file?.[property.type];
+            }
+            case "includedInsecurely":
+            case "includedSecurelyInsecureCCs":
+            case "includedSecurelySecureCCs": {
+                const file = await getFile(files_1.ApplicationCCsFileID);
+                return file?.[property.type];
+            }
+            case "rfRegion":
+            case "txPower":
+            case "measured0dBm":
+            case "enablePTI":
+            case "maxTXPower":
+            case "nodeIdType": {
+                const file = await getFile(files_1.ApplicationRFConfigFileID);
+                return file?.[property.type];
+            }
+            case "isListening":
+            case "optionalFunctionality":
+            case "genericDeviceClass":
+            case "specificDeviceClass": {
+                const file = await getFile(files_1.ApplicationTypeFileID);
+                return file?.[property.type];
+            }
+            case "preferredRepeaters": {
+                const file = await getFile(files_1.ProtocolPreferredRepeatersFileID);
+                return file?.nodeIds;
+            }
+            case "appRouteLock": {
+                const file = await getFile(files_1.ProtocolAppRouteLockNodeMaskFileID);
+                return file?.nodeIds;
+            }
+            case "routeSlaveSUC": {
+                const file = await getFile(files_1.ProtocolRouteSlaveSUCNodeMaskFileID);
+                return file?.nodeIds;
+            }
+            case "sucPendingUpdate": {
+                const file = await getFile(files_1.ProtocolSUCPendingUpdateNodeMaskFileID);
+                return file?.nodeIds;
+            }
+            case "pendingDiscovery": {
+                const file = await getFile(files_1.ProtocolPendingDiscoveryNodeMaskFileID);
+                return file?.nodeIds;
+            }
+            case "nodeIds": {
+                const file = await getFile(files_1.ProtocolNodeListFileID);
+                return file?.nodeIds;
+            }
+            case "lrNodeIds": {
+                const file = await getFile(files_1.ProtocolLRNodeListFileID);
+                return file?.nodeIds;
+            }
+            case "virtualNodeIds": {
+                const file = await getFile(files_1.ProtocolVirtualNodeMaskFileID);
+                return file?.nodeIds;
+            }
+            case "sucUpdateEntries": {
+                if (this._protocolInfo.format < 5) {
+                    const file = await getFile(files_1.SUCUpdateEntriesFileIDV0);
+                    return file?.updateEntries;
+                }
+                else {
+                    // V5 has split the entries into multiple files
+                    const updateEntries = [];
+                    for (let index = 0; index < consts_1.SUC_MAX_UPDATES; index += files_1.SUC_UPDATES_PER_FILE_V5) {
+                        // None of the files are required
+                        const file = await this._getFile((0, files_1.sucUpdateIndexToSUCUpdateEntriesFileIDV5)(index));
+                        if (!file)
+                            break;
+                        updateEntries.push(...file.updateEntries);
+                    }
+                    return updateEntries;
+                }
+            }
+            case "learnedHomeId":
+            case "commandClasses":
+            case "watchdogStarted":
+            case "powerLevelNormal":
+            case "powerLevelLow":
+            case "powerMode":
+            case "powerModeExtintEnable":
+            case "powerModeWutTimeout":
+                // 500 series only, not supported on 700+
+                return;
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+    }
+    async getNodeNVMProperty(property, required) {
+        const getFile = (fileId) => {
+            if (required) {
+                return this._expectFile(fileId);
+            }
+            else {
+                return this._getFile(fileId);
+            }
+        };
+        switch (property.type) {
+            case "info": {
+                if (this._protocolInfo.format < 1) {
+                    const file = await getFile((0, files_1.nodeIdToNodeInfoFileIDV0)(property.nodeId));
+                    return file?.nodeInfo;
+                }
+                else {
+                    const file = await getFile((0, files_1.nodeIdToNodeInfoFileIDV1)(property.nodeId));
+                    return file?.nodeInfos.find((info) => info.nodeId === property.nodeId);
+                }
+            }
+            case "routes": {
+                // The existence of routes is stored separately
+                const nodeMaskFile = await this.getFile(files_1.ProtocolRouteCacheExistsNodeMaskFileID);
+                // If the node is not marked as having routes, don't try to read them
+                if (!nodeMaskFile)
+                    return;
+                if (!nodeMaskFile.nodeIdSet.has(property.nodeId))
+                    return;
+                let routeCache;
+                if (this._protocolInfo.format < 1) {
+                    const file = await getFile((0, files_1.nodeIdToRouteCacheFileIDV0)(property.nodeId));
+                    routeCache = file?.routeCache;
+                }
+                else {
+                    const file = await getFile((0, files_1.nodeIdToRouteCacheFileIDV1)(property.nodeId));
+                    routeCache = file?.routeCaches.find((route) => route.nodeId === property.nodeId);
+                }
+                if (!routeCache)
+                    return;
+                return {
+                    lwr: routeCache.lwr,
+                    nlwr: routeCache.nlwr,
+                };
+            }
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+    }
+    async getLRNodeNVMProperty(property, required) {
+        const getFile = (fileId) => {
+            if (required) {
+                return this._expectFile(fileId);
+            }
+            else {
+                return this._getFile(fileId);
+            }
+        };
+        switch (property.type) {
+            case "info": {
+                const file = await getFile((0, files_1.nodeIdToLRNodeInfoFileIDV5)(property.nodeId));
+                return file?.nodeInfos.find((info) => info.nodeId === property.nodeId);
+            }
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+    }
+    async set(property, value) {
+        if (!this._initialized)
+            await this.init();
+        if (property.domain === "controller") {
+            return this.setControllerNVMProperty(property, value);
+        }
+        else if (property.domain === "lrnode") {
+            return this.setLRNodeNVMProperty(property, value);
+        }
+        else {
+            return this.setNodeNVMProperty(property, value);
+        }
+    }
+    async setControllerNVMProperty(property, value) {
+        const failFileMissing = () => {
+            throw new core_1.ZWaveError("Cannot set property in NVM for non-existing file", core_1.ZWaveErrorCodes.NVM_ObjectNotFound);
+        };
+        const expectFile = async (fileId) => {
+            const file = await this._getFile(fileId);
+            if (!file)
+                throw failFileMissing();
+            return file;
+        };
+        const changedFiles = [];
+        const deletedFiles = [];
+        switch (property.type) {
+            case "protocolVersion": {
+                const file = await expectFile(files_1.ProtocolVersionFileID);
+                const [major, minor, patch] = value.split(".")
+                    .map((part) => parseInt(part, 10));
+                file.major = major;
+                file.minor = minor;
+                file.patch = patch;
+                changedFiles.push(file);
+                break;
+            }
+            case "protocolFileFormat": {
+                const file = await expectFile(files_1.ProtocolVersionFileID);
+                file.format = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "applicationVersion": {
+                const file700 = await this._getFile(files_1.ApplicationVersionFileID);
+                const file800 = await this._getFile(files_1.ApplicationVersionFile800ID);
+                const file = file700 ?? file800;
+                if (!file) {
+                    throw new core_1.ZWaveError("ApplicationVersionFile not found!", core_1.ZWaveErrorCodes.NVM_ObjectNotFound);
+                }
+                const [major, minor, patch] = value.split(".")
+                    .map((part) => parseInt(part, 10));
+                file.major = major;
+                file.minor = minor;
+                file.patch = patch;
+                changedFiles.push(file);
+                break;
+            }
+            case "applicationFileFormat": {
+                const file = await expectFile(files_1.ApplicationVersionFileID);
+                file.format = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "applicationData": {
+                const file = new files_1.ApplicationDataFile({
+                    applicationData: value,
+                    fileVersion: this.getFileVersion(files_1.ApplicationDataFileID),
+                });
+                file.applicationData = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "applicationName": {
+                const file = new files_1.ApplicationNameFile({
+                    name: value,
+                    fileVersion: this.getFileVersion(files_1.ApplicationNameFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "homeId":
+            case "nodeId":
+            case "lastNodeId":
+            case "staticControllerNodeId":
+            case "sucLastIndex":
+            case "controllerConfiguration":
+            case "sucAwarenessPushNeeded":
+            case "maxNodeId":
+            case "reservedId":
+            case "systemState":
+            case "lastNodeIdLR":
+            case "maxNodeIdLR":
+            case "reservedIdLR":
+            case "primaryLongRangeChannelId":
+            case "dcdcConfig": {
+                const file = await expectFile(files_1.ControllerInfoFileID);
+                file[property.type] = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "includedInsecurely":
+            case "includedSecurelyInsecureCCs":
+            case "includedSecurelySecureCCs": {
+                const file = await expectFile(files_1.ApplicationCCsFileID);
+                file[property.type] = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "rfRegion":
+            case "txPower":
+            case "measured0dBm":
+            case "enablePTI":
+            case "maxTXPower":
+            case "nodeIdType": {
+                const file = await expectFile(files_1.ApplicationRFConfigFileID);
+                file[property.type] = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "isListening":
+            case "optionalFunctionality":
+            case "genericDeviceClass":
+            case "specificDeviceClass": {
+                const file = await expectFile(files_1.ApplicationTypeFileID);
+                file[property.type] = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "nodeIds": {
+                const file = await this._getFile(files_1.ProtocolNodeListFileID) ?? new files_1.ProtocolNodeListFile({
+                    nodeIds: [],
+                    fileVersion: this.getFileVersion(files_1.ProtocolNodeListFileID),
+                });
+                file.nodeIds = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "lrNodeIds": {
+                const file = await this._getFile(files_1.ProtocolLRNodeListFileID) ?? new files_1.ProtocolLRNodeListFile({
+                    nodeIds: [],
+                    fileVersion: this.getFileVersion(files_1.ProtocolLRNodeListFileID),
+                });
+                file.nodeIds = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "virtualNodeIds": {
+                const file = await this._getFile(files_1.ProtocolVirtualNodeMaskFileID) ?? new files_1.ProtocolVirtualNodeMaskFile({
+                    nodeIds: [],
+                    fileVersion: this.getFileVersion(files_1.ProtocolVirtualNodeMaskFileID),
+                });
+                file.nodeIds = value;
+                changedFiles.push(file);
+                break;
+            }
+            case "preferredRepeaters": {
+                const file = new files_1.ProtocolPreferredRepeatersFile({
+                    nodeIds: value,
+                    fileVersion: this.getFileVersion(files_1.ProtocolPreferredRepeatersFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "appRouteLock": {
+                const file = new files_1.ProtocolAppRouteLockNodeMaskFile({
+                    nodeIds: value,
+                    fileVersion: this.getFileVersion(files_1.ProtocolAppRouteLockNodeMaskFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "routeSlaveSUC": {
+                const file = new files_1.ProtocolRouteSlaveSUCNodeMaskFile({
+                    nodeIds: value,
+                    fileVersion: this.getFileVersion(files_1.ProtocolRouteSlaveSUCNodeMaskFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "sucPendingUpdate": {
+                const file = new files_1.ProtocolSUCPendingUpdateNodeMaskFile({
+                    nodeIds: value,
+                    fileVersion: this.getFileVersion(files_1.ProtocolSUCPendingUpdateNodeMaskFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "pendingDiscovery": {
+                const file = new files_1.ProtocolPendingDiscoveryNodeMaskFile({
+                    nodeIds: value,
+                    fileVersion: this.getFileVersion(files_1.ProtocolPendingDiscoveryNodeMaskFileID),
+                });
+                changedFiles.push(file);
+                break;
+            }
+            case "sucUpdateEntries": {
+                if (this._protocolInfo.format < 5) {
+                    const file = new files_1.SUCUpdateEntriesFileV0({
+                        updateEntries: value,
+                        fileVersion: this.getFileVersion(files_1.SUCUpdateEntriesFileIDV0),
+                    });
+                    changedFiles.push(file);
+                    break;
+                }
+                else {
+                    // V5 has split the entries into multiple files
+                    for (let index = 0; index < consts_1.SUC_MAX_UPDATES; index += files_1.SUC_UPDATES_PER_FILE_V5) {
+                        const fileId = (0, files_1.sucUpdateIndexToSUCUpdateEntriesFileIDV5)(index);
+                        const fileExists = await this.hasFile(fileId);
+                        const fileVersion = this.getFileVersion(fileId);
+                        const slice = value.slice(index, index + files_1.SUC_UPDATES_PER_FILE_V5);
+                        if (slice.length > 0) {
+                            const file = new files_1.SUCUpdateEntriesFileV5({
+                                updateEntries: slice,
+                                fileVersion,
+                            });
+                            changedFiles.push(file);
+                        }
+                        else if (fileExists) {
+                            deletedFiles.push(fileId);
+                        }
+                    }
+                }
+                break;
+            }
+            case "learnedHomeId":
+            case "commandClasses":
+            case "watchdogStarted":
+            case "powerLevelNormal":
+            case "powerLevelLow":
+            case "powerMode":
+            case "powerModeExtintEnable":
+            case "powerModeWutTimeout":
+                // 500 series only, not supported on 700+
+                return;
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+        for (const file of changedFiles) {
+            const { key, data } = file.serialize();
+            this._pendingChanges.set(key, data);
+        }
+        for (const file of deletedFiles) {
+            this._pendingChanges.set(file, null);
+        }
+    }
+    async setLRNodeNVMProperty(property, value) {
+        const changedFiles = [];
+        const deletedFiles = [];
+        switch (property.type) {
+            case "info": {
+                const fileId = (0, files_1.nodeIdToLRNodeInfoFileIDV5)(property.nodeId);
+                let file = await this._getFile(fileId);
+                if (value) {
+                    // Info added or modified
+                    file ??= new files_1.LRNodeInfoFileV5({
+                        nodeInfos: [],
+                        fileVersion: this.getFileVersion(fileId),
+                    });
+                    const existingIndex = file.nodeInfos.findIndex((info) => info.nodeId === property.nodeId);
+                    if (existingIndex !== -1) {
+                        file.nodeInfos[existingIndex] = value;
+                    }
+                    else {
+                        file.nodeInfos.push(value);
+                    }
+                    changedFiles.push(file);
+                }
+                else if (file) {
+                    // info deleted
+                    const existingIndex = file.nodeInfos.findIndex((info) => info.nodeId === property.nodeId);
+                    if (existingIndex !== -1) {
+                        file.nodeInfos.splice(existingIndex, 1);
+                        if (file.nodeInfos.length === 0) {
+                            deletedFiles.push(fileId);
+                        }
+                        else {
+                            changedFiles.push(file);
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+        for (const file of changedFiles) {
+            const { key, data } = file.serialize();
+            this._pendingChanges.set(key, data);
+        }
+        for (const file of deletedFiles) {
+            this._pendingChanges.set(file, null);
+        }
+    }
+    async setNodeNVMProperty(property, value) {
+        const changedFiles = [];
+        const deletedFiles = [];
+        switch (property.type) {
+            case "info": {
+                if (this._protocolInfo.format < 1) {
+                    // V0, single node info per file
+                    const fileId = (0, files_1.nodeIdToNodeInfoFileIDV0)(property.nodeId);
+                    let file = await this._getFile(fileId);
+                    if (value) {
+                        // Info added or modified
+                        file ??= new files_1.NodeInfoFileV0({
+                            nodeInfo: undefined,
+                            fileVersion: this.getFileVersion(fileId),
+                        });
+                        file.nodeInfo = value;
+                        changedFiles.push(file);
+                    }
+                    else {
+                        // info deleted
+                        deletedFiles.push(fileId);
+                    }
+                }
+                else {
+                    // V1+, multiple node infos per file
+                    const fileId = (0, files_1.nodeIdToNodeInfoFileIDV1)(property.nodeId);
+                    let file = await this._getFile(fileId);
+                    if (value) {
+                        // Info added or modified
+                        file ??= new files_1.NodeInfoFileV1({
+                            nodeInfos: [],
+                            fileVersion: this.getFileVersion(fileId),
+                        });
+                        const existingIndex = file.nodeInfos.findIndex((info) => info.nodeId === property.nodeId);
+                        if (existingIndex !== -1) {
+                            file.nodeInfos[existingIndex] = value;
+                        }
+                        else {
+                            file.nodeInfos.push(value);
+                        }
+                        changedFiles.push(file);
+                    }
+                    else if (file) {
+                        // info deleted
+                        const existingIndex = file.nodeInfos.findIndex((info) => info.nodeId === property.nodeId);
+                        if (existingIndex !== -1) {
+                            file.nodeInfos.splice(existingIndex, 1);
+                            if (file.nodeInfos.length === 0) {
+                                deletedFiles.push(fileId);
+                            }
+                            else {
+                                changedFiles.push(file);
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case "routes": {
+                if (this._protocolInfo.format < 1) {
+                    // V0, single route per file
+                    const fileId = (0, files_1.nodeIdToRouteCacheFileIDV0)(property.nodeId);
+                    let file = await this._getFile(fileId);
+                    if (value) {
+                        // Route added or modified
+                        file ??= new files_1.RouteCacheFileV0({
+                            routeCache: undefined,
+                            fileVersion: this.getFileVersion(fileId),
+                        });
+                        file.routeCache = {
+                            nodeId: property.nodeId,
+                            lwr: value.lwr,
+                            nlwr: value.nlwr,
+                        };
+                        changedFiles.push(file);
+                    }
+                    else if (file) {
+                        // Route deleted
+                        deletedFiles.push(fileId);
+                    }
+                }
+                else {
+                    // V1+, multiple routes per file
+                    const fileId = (0, files_1.nodeIdToRouteCacheFileIDV1)(property.nodeId);
+                    const file = await this._getFile(fileId) ?? new files_1.RouteCacheFileV1({
+                        routeCaches: [],
+                        fileVersion: this.getFileVersion(fileId),
+                    });
+                    const existingIndex = file.routeCaches.findIndex((route) => route.nodeId === property.nodeId);
+                    const newRoute = {
+                        nodeId: property.nodeId,
+                        lwr: value.lwr,
+                        nlwr: value.nlwr,
+                    };
+                    if (existingIndex !== -1) {
+                        file.routeCaches[existingIndex] = newRoute;
+                    }
+                    else {
+                        file.routeCaches.push(newRoute);
+                    }
+                    changedFiles.push(file);
+                }
+                // The existence of routes is stored separately
+                const nodeMaskFile = await this._getFile(files_1.ProtocolRouteCacheExistsNodeMaskFileID)
+                    ?? new files_1.ProtocolRouteCacheExistsNodeMaskFile({
+                        nodeIds: [],
+                        fileVersion: this.getFileVersion(files_1.ProtocolRouteCacheExistsNodeMaskFileID),
+                    });
+                if (!value && nodeMaskFile.nodeIdSet.has(property.nodeId)) {
+                    nodeMaskFile.nodeIdSet.delete(property.nodeId);
+                    changedFiles.push(nodeMaskFile);
+                }
+                else if (value && !nodeMaskFile.nodeIdSet.has(property.nodeId)) {
+                    nodeMaskFile.nodeIdSet.add(property.nodeId);
+                    changedFiles.push(nodeMaskFile);
+                }
+                break;
+            }
+            default:
+                (0, helpers_1.assertNever)(property.type);
+        }
+        for (const file of changedFiles) {
+            const { key, data } = file.serialize();
+            this._pendingChanges.set(key, data);
+        }
+        for (const file of deletedFiles) {
+            this._pendingChanges.set(file, null);
+        }
+    }
+    async delete(property) {
+        if (property.domain === "controller") {
+            switch (property.type) {
+                case "protocolVersion":
+                case "protocolFileFormat": {
+                    this._pendingChanges.set(files_1.ProtocolVersionFileID, null);
+                    return;
+                }
+                case "applicationVersion":
+                case "applicationFileFormat": {
+                    if (await this.hasFile(files_1.ApplicationVersionFileID)) {
+                        this._pendingChanges.set(files_1.ApplicationVersionFileID, null);
+                    }
+                    if (await this.hasFile(files_1.ApplicationVersionFile800ID)) {
+                        this._pendingChanges.set(files_1.ApplicationVersionFile800ID, null);
+                    }
+                    return;
+                }
+                case "applicationData": {
+                    this._pendingChanges.set(files_1.ApplicationDataFileID, null);
+                    return;
+                }
+                case "applicationName": {
+                    this._pendingChanges.set(files_1.ApplicationNameFileID, null);
+                    return;
+                }
+                case "homeId":
+                case "nodeId":
+                case "lastNodeId":
+                case "staticControllerNodeId":
+                case "sucLastIndex":
+                case "controllerConfiguration":
+                case "sucAwarenessPushNeeded":
+                case "maxNodeId":
+                case "reservedId":
+                case "systemState":
+                case "lastNodeIdLR":
+                case "maxNodeIdLR":
+                case "reservedIdLR":
+                case "primaryLongRangeChannelId":
+                case "dcdcConfig": {
+                    this._pendingChanges.set(files_1.ControllerInfoFileID, null);
+                    return;
+                }
+                case "includedInsecurely":
+                case "includedSecurelyInsecureCCs":
+                case "includedSecurelySecureCCs": {
+                    this._pendingChanges.set(files_1.ApplicationCCsFileID, null);
+                    return;
+                }
+                case "rfRegion":
+                case "txPower":
+                case "measured0dBm":
+                case "enablePTI":
+                case "maxTXPower":
+                case "nodeIdType": {
+                    this._pendingChanges.set(files_1.ApplicationRFConfigFileID, null);
+                    return;
+                }
+                case "isListening":
+                case "optionalFunctionality":
+                case "genericDeviceClass":
+                case "specificDeviceClass": {
+                    this._pendingChanges.set(files_1.ApplicationTypeFileID, null);
+                    return;
+                }
+                case "nodeIds": {
+                    this._pendingChanges.set(files_1.ProtocolNodeListFileID, null);
+                    return;
+                }
+                case "lrNodeIds": {
+                    this._pendingChanges.set(files_1.ProtocolLRNodeListFileID, null);
+                    return;
+                }
+                case "virtualNodeIds": {
+                    this._pendingChanges.set(files_1.ProtocolVirtualNodeMaskFileID, null);
+                    return;
+                }
+                case "preferredRepeaters": {
+                    this._pendingChanges.set(files_1.ProtocolPreferredRepeatersFileID, null);
+                    return;
+                }
+                case "appRouteLock": {
+                    this._pendingChanges.set(files_1.ProtocolAppRouteLockNodeMaskFileID, null);
+                    return;
+                }
+                case "routeSlaveSUC": {
+                    this._pendingChanges.set(files_1.ProtocolRouteSlaveSUCNodeMaskFileID, null);
+                    return;
+                }
+                case "sucPendingUpdate": {
+                    this._pendingChanges.set(files_1.ProtocolSUCPendingUpdateNodeMaskFileID, null);
+                    return;
+                }
+                case "pendingDiscovery": {
+                    this._pendingChanges.set(files_1.ProtocolPendingDiscoveryNodeMaskFileID, null);
+                    return;
+                }
+                case "sucUpdateEntries": {
+                    if (this._protocolInfo.format < 5) {
+                        this._pendingChanges.set(files_1.SUCUpdateEntriesFileIDV0, null);
+                    }
+                    else {
+                        for (let id = files_1.SUCUpdateEntriesFileV5IDBase; id <= files_1.SUCUpdateEntriesFileV5IDMax; id++) {
+                            if (await this.hasFile(id)) {
+                                this._pendingChanges.set(id, null);
+                            }
+                        }
+                    }
+                    return;
+                }
+                case "learnedHomeId":
+                case "commandClasses":
+                case "watchdogStarted":
+                case "powerLevelNormal":
+                case "powerLevelLow":
+                case "powerMode":
+                case "powerModeExtintEnable":
+                case "powerModeWutTimeout":
+                    // 500 series only, not supported on 700+
+                    return;
+                default:
+                    (0, helpers_1.assertNever)(property);
+            }
+        }
+        else if (property.domain === "lrnode") {
+            // Node properties are handled by set(..., undefined) because
+            // it requires both modifying and deleting files
+            return this.setLRNodeNVMProperty(property, undefined);
+        }
+        else if (property.domain === "node") {
+            // Node properties are handled by set(..., undefined) because
+            // it requires both modifying and deleting files
+            return this.setNodeNVMProperty(property, undefined);
+        }
+    }
+    hasPendingChanges() {
+        return this._pendingChanges.size > 0;
+    }
+    async commit() {
+        await this._nvm.setMany([...this._pendingChanges]);
+    }
+}
+exports.NVM3Adapter = NVM3Adapter;
+//# sourceMappingURL=adapter.js.map