@zwave-js/nvmedit 13.3.0 → 13.5.0

package/build/convert.js

@@ -5,8 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeHasInfo = nodeHasInfo;
 exports.nvmObjectsToJSON = nvmObjectsToJSON;
-exports.jsonToNVMObjects_v7_0_0 = jsonToNVMObjects_v7_0_0;
-exports.jsonToNVMObjects_v7_11_0 = jsonToNVMObjects_v7_11_0;
 exports.nvmToJSON = nvmToJSON;
 exports.nvm500ToJSON = nvm500ToJSON;
 exports.jsonToNVM = jsonToNVM;
@@ -19,11 +17,18 @@ const safe_2 = require("@zwave-js/shared/safe");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const semver_1 = __importDefault(require("semver"));
 const consts_1 = require("./consts");
-const files_1 = require("./files");
-const ApplicationNameFile_1 = require("./files/ApplicationNameFile");
-const nvm_1 = require("./nvm3/nvm");
-const utils_1 = require("./nvm3/utils");
-const NVMParser_1 = require("./nvm500/NVMParser");
+const NVM3_1 = require("./lib/NVM3");
+const NVM500_1 = require("./lib/NVM500");
+const routeCache_1 = require("./lib/common/routeCache");
+const NVMMemoryIO_1 = require("./lib/io/NVMMemoryIO");
+const adapter_1 = require("./lib/nvm3/adapter");
+const consts_2 = require("./lib/nvm3/consts");
+const files_1 = require("./lib/nvm3/files");
+const ApplicationNameFile_1 = require("./lib/nvm3/files/ApplicationNameFile");
+const utils_1 = require("./lib/nvm3/utils");
+const adapter_2 = require("./lib/nvm500/adapter");
+const impls_1 = require("./lib/nvm500/impls");
+const shared_1 = require("./lib/nvm500/shared");
 function nodeHasInfo(node) {
     return !node.isVirtual || Object.keys(node).length > 1;
 }
@@ -99,13 +104,13 @@ function nvmObjectsToJSON(objects) {
     };
     const getFileOrThrow = (id, fileVersion) => {
         const obj = getObjectOrThrow(id);
-        return files_1.NVMFile.from(obj, fileVersion);
+        return files_1.NVMFile.from(obj.key, obj.data, fileVersion);
     };
     const getFile = (id, fileVersion) => {
         const obj = getObject(id);
-        if (!obj)
+        if (!obj || !obj.data)
             return undefined;
-        return files_1.NVMFile.from(obj, fileVersion);
+        return files_1.NVMFile.from(obj.key, obj.data, fileVersion);
     };
     // === Protocol NVM files ===
     // Figure out how to parse the individual files
@@ -270,7 +275,8 @@ function nvmObjectsToJSON(objects) {
             }
             : {}),
         sucUpdateEntries,
-        applicationData: applicationDataFile?.data.toString("hex") ?? null,
+        applicationData: applicationDataFile?.applicationData.toString("hex")
+            ?? null,
         applicationName: applicationNameFile?.name ?? null,
     };
     // Make sure all props are defined
@@ -366,223 +372,439 @@ function nvmJSONControllerToFileOptions(ctrlr) {
     }
     return ret;
 }
-function serializeCommonApplicationObjects(nvm) {
-    const ret = [];
-    const applTypeFile = new files_1.ApplicationTypeFile({
-        ...(0, safe_2.pick)(nvm.controller, [
+/** Reads an NVM buffer of a 700+ series stick and returns its JSON representation */
+async function nvmToJSON(buffer, debugLogs = false) {
+    const io = new NVMMemoryIO_1.NVMMemoryIO(buffer);
+    const nvm3 = new NVM3_1.NVM3(io);
+    const info = await nvm3.init();
+    const adapter = new adapter_1.NVM3Adapter(nvm3);
+    if (debugLogs) {
+        // Dump all pages, all raw objects in each page, and each object in its final state
+        await (0, utils_1.dumpNVM)(nvm3);
+    }
+    const firstPageHeader = info.isSharedFileSystem
+        ? info.sections.all.pages[0]
+        : info.sections.protocol.pages[0];
+    const meta = {
+        sharedFileSystem: info.isSharedFileSystem,
+        ...(0, safe_2.pick)(firstPageHeader, [
+            "pageSize",
+            "writeSize",
+            "memoryMapped",
+            "deviceFamily",
+        ]),
+    };
+    const nodes = new Map();
+    const getNode = (id) => {
+        if (!nodes.has(id))
+            nodes.set(id, createEmptyPhysicalNode());
+        return nodes.get(id);
+    };
+    const lrNodes = new Map();
+    const getLRNode = (id) => {
+        if (!lrNodes.has(id))
+            lrNodes.set(id, createEmptyLRNode());
+        return lrNodes.get(id);
+    };
+    const protocolFileFormat = await adapter.get({
+        domain: "controller",
+        type: "protocolFileFormat",
+    }, true);
+    // Bail early if the NVM uses a protocol file format that's newer than we support
+    if (protocolFileFormat > consts_1.MAX_PROTOCOL_FILE_FORMAT) {
+        throw new safe_1.ZWaveError(`Unsupported protocol file format: ${protocolFileFormat}`, safe_1.ZWaveErrorCodes.NVM_NotSupported, { protocolFileFormat });
+    }
+    const protocolVersion = await adapter.get({
+        domain: "controller",
+        type: "protocolVersion",
+    }, true);
+    // Read all flags for all nodes
+    const appRouteLock = new Set(await adapter.get({
+        domain: "controller",
+        type: "appRouteLock",
+    }, true));
+    const routeSlaveSUC = new Set(await adapter.get({
+        domain: "controller",
+        type: "routeSlaveSUC",
+    }, true));
+    const sucPendingUpdate = new Set(await adapter.get({
+        domain: "controller",
+        type: "sucPendingUpdate",
+    }, true));
+    const virtualNodeIds = new Set(await adapter.get({
+        domain: "controller",
+        type: "virtualNodeIds",
+    }, true));
+    const pendingDiscovery = new Set(await adapter.get({
+        domain: "controller",
+        type: "pendingDiscovery",
+    }, true));
+    // Figure out which nodes exist
+    const nodeIds = await adapter.get({
+        domain: "controller",
+        type: "nodeIds",
+    }, true);
+    // And create each node entry, including virtual ones
+    for (const id of nodeIds) {
+        const node = getNode(id);
+        // Find node info
+        const nodeInfo = await adapter.get({
+            domain: "node",
+            nodeId: id,
+            type: "info",
+        }, true);
+        Object.assign(node, nodeInfo);
+        // Evaluate flags
+        node.isVirtual = virtualNodeIds.has(id);
+        node.appRouteLock = appRouteLock.has(id);
+        node.routeSlaveSUC = routeSlaveSUC.has(id);
+        node.sucPendingUpdate = sucPendingUpdate.has(id);
+        node.pendingDiscovery = pendingDiscovery.has(id);
+        const routes = await adapter.get({
+            domain: "node",
+            nodeId: id,
+            type: "routes",
+        });
+        if (routes) {
+            node.lwr = routes.lwr;
+            node.nlwr = routes.nlwr;
+        }
+        // @ts-expect-error Some fields include a nodeId, but we don't need it
+        delete node.nodeId;
+    }
+    // If they exist, read info about LR nodes
+    const lrNodeIds = await adapter.get({
+        domain: "controller",
+        type: "lrNodeIds",
+    });
+    if (lrNodeIds) {
+        for (const id of lrNodeIds) {
+            const node = getLRNode(id);
+            // Find node info
+            const nodeInfo = await adapter.get({
+                domain: "lrnode",
+                nodeId: id,
+                type: "info",
+            }, true);
+            Object.assign(node, nodeInfo);
+        }
+    }
+    // Read info about the controller
+    const sucUpdateEntries = await adapter.get({
+        domain: "controller",
+        type: "sucUpdateEntries",
+    }, true);
+    const applicationVersion = await adapter.get({
+        domain: "controller",
+        type: "applicationVersion",
+    }, true);
+    const applicationFileFormat = await adapter.get({
+        domain: "controller",
+        type: "applicationFileFormat",
+    }, true);
+    const applicationData = await adapter.get({
+        domain: "controller",
+        type: "applicationData",
+    });
+    const applicationName = await adapter.get({
+        domain: "controller",
+        type: "applicationName",
+    });
+    const preferredRepeaters = await adapter.get({
+        domain: "controller",
+        type: "preferredRepeaters",
+    });
+    // The following are a bit awkward to read one by one, so we just take the files
+    const controllerInfoFile = await adapter.getFile(files_1.ControllerInfoFileID, true);
+    const rfConfigFile = await adapter.getFile(files_1.ApplicationRFConfigFileID);
+    const applicationCCsFile = await adapter.getFile(files_1.ApplicationCCsFileID, true);
+    const applicationTypeFile = await adapter.getFile(files_1.ApplicationTypeFileID, true);
+    const controller = {
+        protocolVersion,
+        applicationVersion,
+        homeId: `0x${controllerInfoFile.homeId.toString("hex")}`,
+        ...(0, safe_2.pick)(controllerInfoFile, [
+            "nodeId",
+            "lastNodeId",
+            "staticControllerNodeId",
+            "sucLastIndex",
+            "controllerConfiguration",
+            "sucAwarenessPushNeeded",
+            "maxNodeId",
+            "reservedId",
+            "systemState",
+            "lastNodeIdLR",
+            "maxNodeIdLR",
+            "reservedIdLR",
+            "primaryLongRangeChannelId",
+            "dcdcConfig",
+        ]),
+        ...(0, safe_2.pick)(applicationTypeFile, [
             "isListening",
             "optionalFunctionality",
             "genericDeviceClass",
             "specificDeviceClass",
         ]),
-        fileVersion: nvm.controller.applicationVersion,
-    });
-    ret.push(applTypeFile.serialize());
-    const applCCsFile = new files_1.ApplicationCCsFile({
-        ...(0, safe_2.pick)(nvm.controller.commandClasses, [
+        commandClasses: (0, safe_2.pick)(applicationCCsFile, [
             "includedInsecurely",
             "includedSecurelyInsecureCCs",
             "includedSecurelySecureCCs",
         ]),
-        fileVersion: nvm.controller.applicationVersion,
-    });
-    ret.push(applCCsFile.serialize());
-    if (nvm.controller.rfConfig) {
-        const applRFConfigFile = new files_1.ApplicationRFConfigFile({
-            ...(0, safe_2.pick)(nvm.controller.rfConfig, [
-                "rfRegion",
-                "txPower",
-                "measured0dBm",
-            ]),
-            enablePTI: nvm.controller.rfConfig.enablePTI ?? undefined,
-            maxTXPower: nvm.controller.rfConfig.maxTXPower ?? undefined,
-            nodeIdType: nvm.controller.rfConfig.nodeIdType ?? undefined,
-            fileVersion: nvm.controller.applicationVersion,
-        });
-        ret.push(applRFConfigFile.serialize());
-    }
-    if (nvm.controller.applicationData) {
-        // TODO: ensure this is 512 bytes long
-        const applDataFile = new files_1.ApplicationDataFile({
-            data: Buffer.from(nvm.controller.applicationData, "hex"),
-            fileVersion: nvm.controller.applicationVersion,
-        });
-        ret.push(applDataFile.serialize());
-    }
-    if (nvm.controller.applicationName && nvm.meta?.sharedFileSystem) {
-        // The application name only seems to be used with the shared file system
-        const applNameFile = new ApplicationNameFile_1.ApplicationNameFile({
-            name: nvm.controller.applicationName,
-            fileVersion: nvm.controller.applicationVersion,
-        });
-        ret.push(applNameFile.serialize());
-    }
-    return ret;
-}
-function serializeCommonProtocolObjects(nvm) {
-    const ret = [];
-    const appRouteLock = new Set();
-    const routeSlaveSUC = new Set();
-    const sucPendingUpdate = new Set();
-    const isVirtual = new Set();
-    const pendingDiscovery = new Set();
-    for (const [id, node] of Object.entries(nvm.nodes)) {
-        const nodeId = parseInt(id);
-        if (!nodeHasInfo(node)) {
-            isVirtual.add(nodeId);
-            continue;
-        }
-        else {
-            if (node.isVirtual)
-                isVirtual.add(nodeId);
-            if (node.appRouteLock)
-                appRouteLock.add(nodeId);
-            if (node.routeSlaveSUC)
-                routeSlaveSUC.add(nodeId);
-            if (node.sucPendingUpdate)
-                sucPendingUpdate.add(nodeId);
-            if (node.pendingDiscovery)
-                pendingDiscovery.add(nodeId);
-        }
-    }
-    ret.push(new files_1.ControllerInfoFile(nvmJSONControllerToFileOptions(nvm.controller)).serialize());
-    ret.push(new files_1.ProtocolAppRouteLockNodeMaskFile({
-        nodeIds: [...appRouteLock],
-        fileVersion: nvm.controller.protocolVersion,
-    }).serialize());
-    ret.push(new files_1.ProtocolRouteSlaveSUCNodeMaskFile({
-        nodeIds: [...routeSlaveSUC],
-        fileVersion: nvm.controller.protocolVersion,
-    }).serialize());
-    ret.push(new files_1.ProtocolSUCPendingUpdateNodeMaskFile({
-        nodeIds: [...sucPendingUpdate],
-        fileVersion: nvm.controller.protocolVersion,
-    }).serialize());
-    ret.push(new files_1.ProtocolVirtualNodeMaskFile({
-        nodeIds: [...isVirtual],
-        fileVersion: nvm.controller.protocolVersion,
-    }).serialize());
-    ret.push(new files_1.ProtocolPendingDiscoveryNodeMaskFile({
-        nodeIds: [...pendingDiscovery],
-        fileVersion: nvm.controller.protocolVersion,
-    }).serialize());
-    // TODO: format >= 2: { .key = FILE_ID_LRANGE_NODE_EXIST, .size = FILE_SIZE_LRANGE_NODE_EXIST, .name = "LRANGE_NODE_EXIST"},
-    if (nvm.controller.preferredRepeaters?.length) {
-        ret.push(new files_1.ProtocolPreferredRepeatersFile({
-            nodeIds: nvm.controller.preferredRepeaters,
-            fileVersion: nvm.controller.protocolVersion,
-        }).serialize());
+        preferredRepeaters,
+        ...(rfConfigFile
+            ? {
+                rfConfig: {
+                    rfRegion: rfConfigFile.rfRegion,
+                    txPower: rfConfigFile.txPower,
+                    measured0dBm: rfConfigFile.measured0dBm,
+                    enablePTI: rfConfigFile.enablePTI ?? null,
+                    maxTXPower: rfConfigFile.maxTXPower ?? null,
+                    nodeIdType: rfConfigFile.nodeIdType ?? null,
+                },
+            }
+            : {}),
+        sucUpdateEntries,
+        applicationData: applicationData?.toString("hex") ?? null,
+        applicationName: applicationName ?? null,
+    };
+    // Make sure all props are defined
+    const optionalControllerProps = [
+        "sucAwarenessPushNeeded",
+        "lastNodeIdLR",
+        "maxNodeIdLR",
+        "reservedIdLR",
+        "primaryLongRangeChannelId",
+        "dcdcConfig",
+        "rfConfig",
+        "preferredRepeaters",
+        "applicationData",
+    ];
+    for (const prop of optionalControllerProps) {
+        if (controller[prop] === undefined)
+            controller[prop] = null;
     }
-    if (nvm.format < 5) {
-        ret.push(new files_1.SUCUpdateEntriesFileV0({
-            updateEntries: nvm.controller.sucUpdateEntries,
-            fileVersion: nvm.controller.protocolVersion,
-        }).serialize());
+    const ret = {
+        format: protocolFileFormat,
+        controller,
+        nodes: (0, utils_1.mapToObject)(nodes),
+        meta,
+    };
+    if (applicationFileFormat !== 0) {
+        ret.applicationFileFormat = applicationFileFormat;
     }
-    else {
-        // V5 has split the SUC update entries into multiple files
-        for (let index = 0; index < consts_1.SUC_MAX_UPDATES; index += files_1.SUC_UPDATES_PER_FILE_V5) {
-            const slice = nvm.controller.sucUpdateEntries.slice(index, index + files_1.SUC_UPDATES_PER_FILE_V5);
-            if (slice.length === 0)
-                break;
-            const file = new files_1.SUCUpdateEntriesFileV5({
-                updateEntries: slice,
-                fileVersion: nvm.controller.protocolVersion,
-            });
-            file.fileId = (0, files_1.sucUpdateIndexToSUCUpdateEntriesFileIDV5)(index);
-            ret.push(file.serialize());
-        }
+    if (lrNodes.size > 0) {
+        ret.lrNodes = (0, utils_1.mapToObject)(lrNodes);
     }
     return ret;
 }
-function jsonToNVMObjects_v7_0_0(json, targetSDKVersion) {
-    const target = (0, safe_2.cloneDeep)(json);
-    target.controller.protocolVersion = "7.0.0";
-    target.format = 0;
-    target.controller.applicationVersion = targetSDKVersion.format();
-    const applicationObjects = new Map();
-    const protocolObjects = new Map();
-    const addApplicationObjects = (...objects) => {
-        for (const o of objects) {
-            applicationObjects.set(o.key, o);
-        }
-    };
-    const addProtocolObjects = (...objects) => {
-        for (const o of objects) {
-            protocolObjects.set(o.key, o);
-        }
+/** Reads an NVM buffer of a 500-series stick and returns its JSON representation */
+async function nvm500ToJSON(buffer) {
+    const io = new NVMMemoryIO_1.NVMMemoryIO(buffer);
+    const nvm = new NVM500_1.NVM500(io);
+    const info = await nvm.init();
+    const meta = {
+        library: info.library,
+        ...(0, safe_2.pick)(info.nvmDescriptor, [
+            "manufacturerID",
+            "firmwareID",
+            "productType",
+            "productID",
+        ]),
     };
-    // Application files
-    const applVersionFile = new files_1.ApplicationVersionFile({
-        // The SDK compares 4-byte values where the format is set to 0 to determine whether a migration is needed
-        format: 0,
-        major: targetSDKVersion.major,
-        minor: targetSDKVersion.minor,
-        patch: targetSDKVersion.patch,
-        fileVersion: target.controller.applicationVersion, // does not matter for this file
-    });
-    addApplicationObjects(applVersionFile.serialize());
-    addApplicationObjects(...serializeCommonApplicationObjects(target));
-    // Protocol files
-    const protocolVersionFile = new files_1.ProtocolVersionFile({
-        format: target.format,
-        major: 7,
-        minor: 0,
-        patch: 0,
-        fileVersion: target.controller.protocolVersion, // does not matter for this file
-    });
-    addProtocolObjects(protocolVersionFile.serialize());
-    const nodeInfoFiles = new Map();
-    const routeCacheFiles = new Map();
-    const nodeInfoExists = new Set();
-    const routeCacheExists = new Set();
-    for (const [id, node] of Object.entries(target.nodes)) {
-        const nodeId = parseInt(id);
-        if (!nodeHasInfo(node))
+    const adapter = new adapter_2.NVM500Adapter(nvm);
+    // Read all flags for all nodes
+    const appRouteLock = new Set(await adapter.get({
+        domain: "controller",
+        type: "appRouteLock",
+    }, true));
+    const routeSlaveSUC = new Set(await adapter.get({
+        domain: "controller",
+        type: "routeSlaveSUC",
+    }, true));
+    const sucPendingUpdate = new Set(await adapter.get({
+        domain: "controller",
+        type: "sucPendingUpdate",
+    }, true));
+    const virtualNodeIds = new Set(await adapter.get({
+        domain: "controller",
+        type: "virtualNodeIds",
+    }) ?? []);
+    const pendingDiscovery = new Set(await adapter.get({
+        domain: "controller",
+        type: "pendingDiscovery",
+    }, true));
+    // Figure out which nodes exist along with their info
+    const nodes = {};
+    for (let nodeId = 1; nodeId <= safe_1.MAX_NODES; nodeId++) {
+        const nodeInfo = await adapter.get({
+            domain: "node",
+            nodeId,
+            type: "info",
+        });
+        const isVirtual = virtualNodeIds.has(nodeId);
+        if (!nodeInfo) {
+            if (isVirtual) {
+                nodes[nodeId] = { isVirtual: true };
+            }
             continue;
-        nodeInfoExists.add(nodeId);
-        // Create/update node info file
-        const nodeInfoFileIndex = (0, files_1.nodeIdToNodeInfoFileIDV0)(nodeId);
-        nodeInfoFiles.set(nodeInfoFileIndex, new files_1.NodeInfoFileV0({
-            nodeInfo: nvmJSONNodeToNodeInfo(nodeId, node),
-            fileVersion: target.controller.protocolVersion,
-        }));
-        // Create/update route cache file (if there is a route)
-        if (node.lwr || node.nlwr) {
-            routeCacheExists.add(nodeId);
-            const routeCacheFileIndex = (0, files_1.nodeIdToRouteCacheFileIDV0)(nodeId);
-            routeCacheFiles.set(routeCacheFileIndex, new files_1.RouteCacheFileV0({
-                routeCache: {
-                    nodeId,
-                    lwr: node.lwr ?? (0, files_1.getEmptyRoute)(),
-                    nlwr: node.nlwr ?? (0, files_1.getEmptyRoute)(),
-                },
-                fileVersion: target.controller.protocolVersion,
-            }));
         }
+        const routes = await adapter.get({
+            domain: "node",
+            nodeId,
+            type: "routes",
+        });
+        // @ts-expect-error Some fields include a nodeId, but we don't need it
+        delete nodeInfo.nodeId;
+        nodes[nodeId] = {
+            ...nodeInfo,
+            specificDeviceClass: nodeInfo.specificDeviceClass ?? null,
+            isVirtual,
+            appRouteLock: appRouteLock.has(nodeId),
+            routeSlaveSUC: routeSlaveSUC.has(nodeId),
+            sucPendingUpdate: sucPendingUpdate.has(nodeId),
+            pendingDiscovery: pendingDiscovery.has(nodeId),
+            lwr: routes?.lwr ?? null,
+            nlwr: routes?.nlwr ?? null,
+        };
     }
-    addProtocolObjects(...serializeCommonProtocolObjects(target));
-    addProtocolObjects(new files_1.ProtocolNodeListFile({
-        nodeIds: [...nodeInfoExists],
-        fileVersion: target.controller.protocolVersion,
-    }).serialize());
-    addProtocolObjects(new files_1.ProtocolRouteCacheExistsNodeMaskFile({
-        nodeIds: [...routeCacheExists],
-        fileVersion: target.controller.protocolVersion,
-    }).serialize());
-    if (nodeInfoFiles.size > 0) {
-        addProtocolObjects(...[...nodeInfoFiles.values()].map((f) => f.serialize()));
-    }
-    if (routeCacheFiles.size > 0) {
-        addProtocolObjects(...[...routeCacheFiles.values()].map((f) => f.serialize()));
+    // Read info about the controller
+    const ownNodeId = await adapter.get({
+        domain: "controller",
+        type: "nodeId",
+    }, true);
+    const ownHomeId = await adapter.get({
+        domain: "controller",
+        type: "homeId",
+    }, true);
+    let learnedHomeId = await adapter.get({
+        domain: "controller",
+        type: "learnedHomeId",
+    });
+    if (learnedHomeId?.equals(Buffer.alloc(4, 0))) {
+        learnedHomeId = undefined;
     }
+    const lastNodeId = await adapter.get({
+        domain: "controller",
+        type: "lastNodeId",
+    }, true);
+    const maxNodeId = await adapter.get({
+        domain: "controller",
+        type: "maxNodeId",
+    }, true);
+    const reservedId = await adapter.get({
+        domain: "controller",
+        type: "reservedId",
+    }, true);
+    const staticControllerNodeId = await adapter.get({
+        domain: "controller",
+        type: "staticControllerNodeId",
+    }, true);
+    const sucLastIndex = await adapter.get({
+        domain: "controller",
+        type: "sucLastIndex",
+    }, true);
+    const controllerConfiguration = await adapter.get({
+        domain: "controller",
+        type: "controllerConfiguration",
+    }, true);
+    const commandClasses = await adapter.get({
+        domain: "controller",
+        type: "commandClasses",
+    }, true);
+    const sucUpdateEntries = await adapter.get({
+        domain: "controller",
+        type: "sucUpdateEntries",
+    }, true);
+    const applicationData = await adapter.get({
+        domain: "controller",
+        type: "applicationData",
+    });
+    const preferredRepeaters = await adapter.get({
+        domain: "controller",
+        type: "preferredRepeaters",
+    }, true);
+    const systemState = await adapter.get({
+        domain: "controller",
+        type: "systemState",
+    }, true);
+    const watchdogStarted = await adapter.get({
+        domain: "controller",
+        type: "watchdogStarted",
+    }, true);
+    const powerLevelNormal = await adapter.get({
+        domain: "controller",
+        type: "powerLevelNormal",
+    }, true);
+    const powerLevelLow = await adapter.get({
+        domain: "controller",
+        type: "powerLevelLow",
+    }, true);
+    const powerMode = await adapter.get({
+        domain: "controller",
+        type: "powerMode",
+    }, true);
+    const powerModeExtintEnable = await adapter.get({
+        domain: "controller",
+        type: "powerModeExtintEnable",
+    }, true);
+    const powerModeWutTimeout = await adapter.get({
+        domain: "controller",
+        type: "powerModeWutTimeout",
+    }, true);
+    const controller = {
+        protocolVersion: info.nvmDescriptor.protocolVersion,
+        applicationVersion: info.nvmDescriptor.firmwareVersion,
+        ownHomeId: `0x${ownHomeId.toString("hex")}`,
+        learnedHomeId: learnedHomeId
+            ? `0x${learnedHomeId.toString("hex")}`
+            : null,
+        nodeId: ownNodeId,
+        lastNodeId,
+        staticControllerNodeId,
+        sucLastIndex,
+        controllerConfiguration,
+        sucUpdateEntries,
+        maxNodeId,
+        reservedId,
+        systemState,
+        watchdogStarted,
+        rfConfig: {
+            powerLevelNormal,
+            powerLevelLow,
+            powerMode,
+            powerModeExtintEnable,
+            powerModeWutTimeout,
+        },
+        preferredRepeaters,
+        commandClasses,
+        applicationData: applicationData?.toString("hex") ?? null,
+    };
     return {
-        applicationObjects,
-        protocolObjects,
+        format: 500,
+        meta,
+        controller,
+        nodes,
     };
 }
-function jsonToNVMObjects_v7_11_0(json, targetSDKVersion) {
-    const target = (0, safe_2.cloneDeep)(json);
+async function jsonToNVM(json, targetSDKVersion) {
+    const parsedVersion = semver_1.default.parse(targetSDKVersion);
+    if (!parsedVersion) {
+        throw new safe_1.ZWaveError(`Invalid SDK version: ${targetSDKVersion}`, safe_1.ZWaveErrorCodes.Argument_Invalid);
+    }
+    // Erase the NVM
+    const sharedFileSystem = json.meta?.sharedFileSystem;
+    const nvmSize = sharedFileSystem
+        ? consts_2.ZWAVE_SHARED_NVM_SIZE
+        : (consts_2.ZWAVE_APPLICATION_NVM_SIZE + consts_2.ZWAVE_PROTOCOL_NVM_SIZE);
+    const ret = Buffer.allocUnsafe(nvmSize);
+    const io = new NVMMemoryIO_1.NVMMemoryIO(ret);
+    const nvm3 = new NVM3_1.NVM3(io);
+    await nvm3.erase(json.meta);
+    const serializeFile = async (file) => {
+        const { key, data } = file.serialize();
+        await nvm3.set(key, data);
+    };
+    // Figure out which SDK version we are targeting
     let targetApplicationVersion;
     let targetProtocolVersion;
     let targetProtocolFormat;
@@ -613,39 +835,66 @@ function jsonToNVMObjects_v7_11_0(json, targetSDKVersion) {
         targetProtocolVersion = semver_1.default.parse("7.12.0");
         targetProtocolFormat = 2;
     }
-    else {
-        // All versions below 7.11.0 are handled in the _v7_0_0 method
+    else if (semver_1.default.gte(targetSDKVersion, "7.11.0")) {
         targetProtocolVersion = semver_1.default.parse("7.11.0");
         targetProtocolFormat = 1;
     }
-    target.format = targetProtocolFormat;
-    target.controller.applicationVersion = targetApplicationVersion.format();
+    else {
+        targetProtocolVersion = semver_1.default.parse("7.0.0");
+        targetProtocolFormat = 0;
+    }
+    const target = (0, safe_2.cloneDeep)(json);
     target.controller.protocolVersion = targetProtocolVersion.format();
-    const applicationObjects = new Map();
-    const protocolObjects = new Map();
-    const addApplicationObjects = (...objects) => {
-        for (const o of objects) {
-            applicationObjects.set(o.key, o);
-        }
-    };
-    const addProtocolObjects = (...objects) => {
-        for (const o of objects) {
-            protocolObjects.set(o.key, o);
-        }
-    };
-    // Application files
-    const ApplicationVersionConstructor = json.meta?.sharedFileSystem
+    target.format = targetProtocolFormat;
+    target.controller.applicationVersion = parsedVersion.format();
+    // Write application and protocol version files, because they are required
+    // for the NVM3 adapter to work.
+    const ApplicationVersionConstructor = sharedFileSystem
         ? files_1.ApplicationVersionFile800
         : files_1.ApplicationVersionFile;
     const applVersionFile = new ApplicationVersionConstructor({
-        // The SDK compares 4-byte values where the format is set to 0 to determine whether a migration is needed
         format: 0,
         major: targetApplicationVersion.major,
         minor: targetApplicationVersion.minor,
         patch: targetApplicationVersion.patch,
-        fileVersion: target.controller.applicationVersion, // does not matter for this file
+        fileVersion: targetProtocolVersion.format(), // does not matter for this file
+    });
+    await serializeFile(applVersionFile);
+    const protocolVersionFile = new files_1.ProtocolVersionFile({
+        format: targetProtocolFormat,
+        major: targetProtocolVersion.major,
+        minor: targetProtocolVersion.minor,
+        patch: targetProtocolVersion.patch,
+        fileVersion: targetProtocolVersion.format(), // does not matter for this file
+    });
+    await serializeFile(protocolVersionFile);
+    {
+        const { key, data } = protocolVersionFile.serialize();
+        await nvm3.set(key, data);
+    }
+    // Now use the adapter where possible. Some properties have to be set together though,
+    // so we set the files directly
+    const adapter = new adapter_1.NVM3Adapter(nvm3);
+    // Start with the application data
+    const applTypeFile = new files_1.ApplicationTypeFile({
+        ...(0, safe_2.pick)(target.controller, [
+            "isListening",
+            "optionalFunctionality",
+            "genericDeviceClass",
+            "specificDeviceClass",
+        ]),
+        fileVersion: target.controller.applicationVersion,
+    });
+    adapter.setFile(applTypeFile);
+    const applCCsFile = new files_1.ApplicationCCsFile({
+        ...(0, safe_2.pick)(target.controller.commandClasses, [
+            "includedInsecurely",
+            "includedSecurelyInsecureCCs",
+            "includedSecurelySecureCCs",
+        ]),
+        fileVersion: target.controller.applicationVersion,
     });
-    addApplicationObjects(applVersionFile.serialize());
+    adapter.setFile(applCCsFile);
     // When converting it can be that the rfConfig doesn't exist. Make sure
     // that it is initialized with proper defaults.
     target.controller.rfConfig ??= {
@@ -665,71 +914,76 @@ function jsonToNVMObjects_v7_11_0(json, targetSDKVersion) {
     if (semver_1.default.gte(targetSDKVersion, "7.21.0")) {
         target.controller.rfConfig.nodeIdType ??= safe_1.NodeIDType.Short;
     }
-    addApplicationObjects(...serializeCommonApplicationObjects(target));
-    // Protocol files
-    const protocolVersionFile = new files_1.ProtocolVersionFile({
-        format: targetProtocolFormat,
-        major: targetProtocolVersion.major,
-        minor: targetProtocolVersion.minor,
-        patch: targetProtocolVersion.patch,
-        fileVersion: target.controller.protocolVersion, // does not matter for this file
+    const applRFConfigFile = new files_1.ApplicationRFConfigFile({
+        ...(0, safe_2.pick)(target.controller.rfConfig, [
+            "rfRegion",
+            "txPower",
+            "measured0dBm",
+        ]),
+        enablePTI: target.controller.rfConfig.enablePTI ?? undefined,
+        maxTXPower: target.controller.rfConfig.maxTXPower ?? undefined,
+        nodeIdType: target.controller.rfConfig.nodeIdType ?? undefined,
+        fileVersion: target.controller.applicationVersion,
     });
-    addProtocolObjects(protocolVersionFile.serialize());
-    const nodeInfoFiles = new Map();
-    const lrNodeInfoFiles = new Map();
-    const routeCacheFiles = new Map();
+    adapter.setFile(applRFConfigFile);
+    if (target.controller.applicationData) {
+        await adapter.set({ domain: "controller", type: "applicationData" }, Buffer.from(target.controller.applicationData, "hex"));
+    }
+    // The application name only seems to be used on 800 series with the shared file system
+    if (target.controller.applicationName && target.meta?.sharedFileSystem) {
+        await adapter.set({ domain: "controller", type: "applicationName" }, target.controller.applicationName);
+    }
+    // Now the protocol data
+    // TODO: node IDs and LR node IDs should probably be handled by the NVM adapter when
+    // setting the node info. But then we need to make sure here that the files are guaranteed to exist
     const nodeInfoExists = new Set();
     const lrNodeInfoExists = new Set();
-    const routeCacheExists = new Set();
+    const virtualNodeIds = new Set();
+    const appRouteLock = new Set();
+    const routeSlaveSUC = new Set();
+    const sucPendingUpdate = new Set();
+    const pendingDiscovery = new Set();
+    // Ensure that the route cache exists nodemask is written, even when no routes exist
+    adapter.setFile(new files_1.ProtocolRouteCacheExistsNodeMaskFile({
+        nodeIds: [],
+        fileVersion: target.controller.protocolVersion,
+    }));
     for (const [id, node] of Object.entries(target.nodes)) {
         const nodeId = parseInt(id);
-        if (!nodeHasInfo(node))
+        if (!nodeHasInfo(node)) {
+            virtualNodeIds.add(nodeId);
             continue;
-        nodeInfoExists.add(nodeId);
-        // Create/update node info file
-        const nodeInfoFileIndex = (0, files_1.nodeIdToNodeInfoFileIDV1)(nodeId);
-        if (!nodeInfoFiles.has(nodeInfoFileIndex)) {
-            nodeInfoFiles.set(nodeInfoFileIndex, new files_1.NodeInfoFileV1({
-                nodeInfos: [],
-                fileVersion: target.controller.protocolVersion,
-            }));
         }
-        const nodeInfoFile = nodeInfoFiles.get(nodeInfoFileIndex);
-        nodeInfoFile.nodeInfos.push(nvmJSONNodeToNodeInfo(nodeId, node));
-        // Create/update route cache file (if there is a route)
+        else {
+            nodeInfoExists.add(nodeId);
+            if (node.isVirtual)
+                virtualNodeIds.add(nodeId);
+            if (node.appRouteLock)
+                appRouteLock.add(nodeId);
+            if (node.routeSlaveSUC)
+                routeSlaveSUC.add(nodeId);
+            if (node.sucPendingUpdate)
+                sucPendingUpdate.add(nodeId);
+            if (node.pendingDiscovery)
+                pendingDiscovery.add(nodeId);
+        }
+        await adapter.set({ domain: "node", nodeId, type: "info" }, nvmJSONNodeToNodeInfo(nodeId, node));
         if (node.lwr || node.nlwr) {
-            routeCacheExists.add(nodeId);
-            const routeCacheFileIndex = (0, files_1.nodeIdToRouteCacheFileIDV1)(nodeId);
-            if (!routeCacheFiles.has(routeCacheFileIndex)) {
-                routeCacheFiles.set(routeCacheFileIndex, new files_1.RouteCacheFileV1({
-                    routeCaches: [],
-                    fileVersion: target.controller.protocolVersion,
-                }));
-            }
-            const routeCacheFile = routeCacheFiles.get(routeCacheFileIndex);
-            routeCacheFile.routeCaches.push({
-                nodeId,
-                lwr: node.lwr ?? (0, files_1.getEmptyRoute)(),
-                nlwr: node.nlwr ?? (0, files_1.getEmptyRoute)(),
+            await adapter.set({ domain: "node", nodeId, type: "routes" }, {
+                lwr: node.lwr ?? (0, routeCache_1.getEmptyRoute)(),
+                nlwr: node.nlwr ?? (0, routeCache_1.getEmptyRoute)(),
             });
         }
     }
+    await adapter.set({ domain: "controller", type: "nodeIds" }, [...nodeInfoExists]);
     if (target.lrNodes) {
         for (const [id, node] of Object.entries(target.lrNodes)) {
             const nodeId = parseInt(id);
             lrNodeInfoExists.add(nodeId);
-            // Create/update node info file
-            const nodeInfoFileIndex = (0, files_1.nodeIdToLRNodeInfoFileIDV5)(nodeId);
-            if (!lrNodeInfoFiles.has(nodeInfoFileIndex)) {
-                lrNodeInfoFiles.set(nodeInfoFileIndex, new files_1.LRNodeInfoFileV5({
-                    nodeInfos: [],
-                    fileVersion: target.controller.protocolVersion,
-                }));
-            }
-            const nodeInfoFile = lrNodeInfoFiles.get(nodeInfoFileIndex);
-            nodeInfoFile.nodeInfos.push(nvmJSONLRNodeToLRNodeInfo(nodeId, node));
+            await adapter.set({ domain: "lrnode", nodeId, type: "info" }, nvmJSONLRNodeToLRNodeInfo(nodeId, node));
         }
     }
+    await adapter.set({ domain: "controller", type: "lrNodeIds" }, [...lrNodeInfoExists]);
     // For v3+ targets, the ControllerInfoFile must contain the LongRange properties
     // or the controller will ignore the file and not have a home ID
     if (targetProtocolFormat >= 3) {
@@ -739,90 +993,115 @@ function jsonToNVMObjects_v7_11_0(json, targetSDKVersion) {
         target.controller.primaryLongRangeChannelId ??= 0;
         target.controller.dcdcConfig ??= 255;
     }
-    addProtocolObjects(...serializeCommonProtocolObjects(target));
-    addProtocolObjects(new files_1.ProtocolNodeListFile({
-        nodeIds: [...nodeInfoExists],
-        fileVersion: target.controller.protocolVersion,
-    }).serialize());
-    addProtocolObjects(new files_1.ProtocolRouteCacheExistsNodeMaskFile({
-        nodeIds: [...routeCacheExists],
-        fileVersion: target.controller.protocolVersion,
-    }).serialize());
-    if (nodeInfoFiles.size > 0) {
-        addProtocolObjects(...[...nodeInfoFiles.values()].map((f) => f.serialize()));
-    }
-    if (routeCacheFiles.size > 0) {
-        addProtocolObjects(...[...routeCacheFiles.values()].map((f) => f.serialize()));
-    }
-    if (lrNodeInfoFiles.size > 0) {
-        addProtocolObjects(new files_1.ProtocolLRNodeListFile({
-            nodeIds: [...lrNodeInfoExists],
-            fileVersion: target.controller.protocolVersion,
-        }).serialize());
-        addProtocolObjects(...[...lrNodeInfoFiles.values()].map((f) => f.serialize()));
+    adapter.setFile(new files_1.ControllerInfoFile(nvmJSONControllerToFileOptions(target.controller)));
+    await adapter.set({ domain: "controller", type: "appRouteLock" }, [...appRouteLock]);
+    await adapter.set({ domain: "controller", type: "routeSlaveSUC" }, [...routeSlaveSUC]);
+    await adapter.set({ domain: "controller", type: "sucPendingUpdate" }, [...sucPendingUpdate]);
+    await adapter.set({ domain: "controller", type: "virtualNodeIds" }, [...virtualNodeIds]);
+    await adapter.set({ domain: "controller", type: "pendingDiscovery" }, [...pendingDiscovery]);
+    if (target.controller.preferredRepeaters?.length) {
+        await adapter.set({ domain: "controller", type: "preferredRepeaters" }, target.controller.preferredRepeaters);
     }
-    return {
-        applicationObjects,
-        protocolObjects,
-    };
-}
-/** Reads an NVM buffer and returns its JSON representation */
-function nvmToJSON(buffer, debugLogs = false) {
-    const nvm = (0, nvm_1.parseNVM)(buffer, debugLogs);
-    return parsedNVMToJSON(nvm);
-}
-function parsedNVMToJSON(nvm) {
-    const objects = new Map([
-        ...nvm.applicationObjects,
-        ...nvm.protocolObjects,
-    ]);
-    // 800 series doesn't distinguish between the storage for application and protocol objects
-    const sharedFileSystem = nvm.applicationObjects.size > 0
-        && nvm.protocolObjects.size === 0;
-    const ret = nvmObjectsToJSON(objects);
-    const firstPage = sharedFileSystem
-        ? nvm.applicationPages[0]
-        : nvm.protocolPages[0];
-    ret.meta = (0, nvm_1.getNVMMeta)(firstPage, sharedFileSystem);
+    await adapter.set({ domain: "controller", type: "sucUpdateEntries" }, target.controller.sucUpdateEntries);
+    await adapter.commit();
+    await io.close();
     return ret;
 }
-/** Reads an NVM buffer of a 500-series stick and returns its JSON representation */
-function nvm500ToJSON(buffer) {
-    const parser = (0, NVMParser_1.createParser)(buffer);
-    if (!parser) {
-        throw new safe_1.ZWaveError("Did not find a matching NVM 500 parser implementation! Make sure that the NVM data belongs to a controller with Z-Wave SDK 6.61 or higher.", safe_1.ZWaveErrorCodes.NVM_NotSupported);
-    }
-    return parser.toJSON();
-}
-/** Takes a JSON represented NVM and converts it to binary */
-function jsonToNVM(json, targetSDKVersion) {
-    const parsedVersion = semver_1.default.parse(targetSDKVersion);
-    if (!parsedVersion) {
-        throw new safe_1.ZWaveError(`Invalid SDK version: ${targetSDKVersion}`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-    }
-    let objects;
-    if (semver_1.default.gte(parsedVersion, "7.11.0")) {
-        objects = jsonToNVMObjects_v7_11_0(json, parsedVersion);
-    }
-    else if (semver_1.default.gte(parsedVersion, "7.0.0")) {
-        objects = jsonToNVMObjects_v7_0_0(json, parsedVersion);
-    }
-    else {
-        throw new safe_1.ZWaveError("jsonToNVM cannot convert to a pre-7.0 NVM version. Use jsonToNVM500 instead.", safe_1.ZWaveErrorCodes.Argument_Invalid);
-    }
-    return (0, nvm_1.encodeNVM)(objects.applicationObjects, objects.protocolObjects, json.meta);
-}
 /** Takes a JSON represented 500 series NVM and converts it to binary */
-function jsonToNVM500(json, protocolVersion) {
+async function jsonToNVM500(json, protocolVersion) {
     // Try to find a matching implementation
-    const impl = NVMParser_1.nmvDetails500.find((p) => p.protocolVersions.includes(protocolVersion)
+    const impl = impls_1.nvm500Impls.find((p) => p.protocolVersions.includes(protocolVersion)
         && p.name.toLowerCase().startsWith(json.meta.library));
     if (!impl) {
         throw new safe_1.ZWaveError(`Did not find a matching implementation for protocol version ${protocolVersion} and library ${json.meta.library}. To convert 500-series NVMs, both the source and the target controller must be using Z-Wave SDK 6.61 or higher.`, safe_1.ZWaveErrorCodes.NVM_NotSupported);
     }
-    const serializer = new NVMParser_1.NVMSerializer(impl);
-    serializer.parseJSON(json, protocolVersion);
-    return serializer.serialize();
+    const { layout, nvmSize } = (0, shared_1.resolveLayout)(impl.layout);
+    // Erase the NVM and set some basic information
+    const ret = Buffer.allocUnsafe(nvmSize);
+    const io = new NVMMemoryIO_1.NVMMemoryIO(ret);
+    const nvm = new NVM500_1.NVM500(io);
+    await nvm.erase({
+        layout,
+        nvmSize,
+        library: impl.library,
+        nvmDescriptor: {
+            ...(0, safe_2.pick)(json.meta, [
+                "manufacturerID",
+                "productType",
+                "productID",
+                "firmwareID",
+            ]),
+            // Override the protocol version with the specified one
+            protocolVersion,
+            firmwareVersion: json.controller.applicationVersion,
+        },
+    });
+    const adapter = new adapter_2.NVM500Adapter(nvm);
+    // Set controller infos
+    const c = json.controller;
+    await adapter.set({ domain: "controller", type: "homeId" }, Buffer.from(c.ownHomeId.replace(/^0x/, ""), "hex"));
+    await adapter.set({ domain: "controller", type: "learnedHomeId" }, c.learnedHomeId
+        ? Buffer.from(c.learnedHomeId.replace(/^0x/, ""), "hex")
+        : undefined);
+    await adapter.set({ domain: "controller", type: "nodeId" }, c.nodeId);
+    await adapter.set({ domain: "controller", type: "lastNodeId" }, c.lastNodeId);
+    await adapter.set({ domain: "controller", type: "maxNodeId" }, c.maxNodeId);
+    await adapter.set({ domain: "controller", type: "reservedId" }, c.reservedId);
+    await adapter.set({ domain: "controller", type: "staticControllerNodeId" }, c.staticControllerNodeId);
+    await adapter.set({ domain: "controller", type: "controllerConfiguration" }, c.controllerConfiguration);
+    await adapter.set({ domain: "controller", type: "sucUpdateEntries" }, c.sucUpdateEntries);
+    await adapter.set({ domain: "controller", type: "sucLastIndex" }, c.sucLastIndex);
+    await adapter.set({ domain: "controller", type: "systemState" }, c.systemState);
+    await adapter.set({ domain: "controller", type: "watchdogStarted" }, c.watchdogStarted);
+    await adapter.set({ domain: "controller", type: "powerLevelNormal" }, c.rfConfig.powerLevelNormal);
+    await adapter.set({ domain: "controller", type: "powerLevelLow" }, c.rfConfig.powerLevelLow);
+    await adapter.set({ domain: "controller", type: "powerMode" }, c.rfConfig.powerMode);
+    await adapter.set({ domain: "controller", type: "powerModeExtintEnable" }, c.rfConfig.powerModeExtintEnable);
+    await adapter.set({ domain: "controller", type: "powerModeWutTimeout" }, c.rfConfig.powerModeWutTimeout);
+    await adapter.set({ domain: "controller", type: "preferredRepeaters" }, c.preferredRepeaters);
+    await adapter.set({ domain: "controller", type: "commandClasses" }, c.commandClasses);
+    if (c.applicationData) {
+        await adapter.set({ domain: "controller", type: "applicationData" }, Buffer.from(c.applicationData, "hex"));
+    }
+    // Set node infos
+    const appRouteLock = [];
+    const routeSlaveSUC = [];
+    const pendingDiscovery = [];
+    const sucPendingUpdate = [];
+    const virtualNodeIds = [];
+    for (const [id, node] of Object.entries(json.nodes)) {
+        const nodeId = parseInt(id);
+        if (!nodeHasInfo(node)) {
+            virtualNodeIds.push(nodeId);
+            continue;
+        }
+        if (node.appRouteLock)
+            appRouteLock.push(nodeId);
+        if (node.routeSlaveSUC)
+            routeSlaveSUC.push(nodeId);
+        if (node.pendingDiscovery)
+            pendingDiscovery.push(nodeId);
+        if (node.sucPendingUpdate)
+            sucPendingUpdate.push(nodeId);
+        await adapter.set({ domain: "node", nodeId, type: "info" }, {
+            nodeId,
+            ...node,
+        });
+        if (node.lwr || node.nlwr) {
+            await adapter.set({ domain: "node", nodeId, type: "routes" }, {
+                lwr: node.lwr ?? undefined,
+                nlwr: node.nlwr ?? undefined,
+            });
+        }
+    }
+    await adapter.set({ domain: "controller", type: "appRouteLock" }, [...appRouteLock]);
+    await adapter.set({ domain: "controller", type: "routeSlaveSUC" }, [...routeSlaveSUC]);
+    await adapter.set({ domain: "controller", type: "sucPendingUpdate" }, [...sucPendingUpdate]);
+    await adapter.set({ domain: "controller", type: "virtualNodeIds" }, [...virtualNodeIds]);
+    await adapter.set({ domain: "controller", type: "pendingDiscovery" }, [...pendingDiscovery]);
+    await adapter.commit();
+    await io.close();
+    return ret;
 }
 function json500To700(json, truncateApplicationData) {
     const source = (0, safe_2.cloneDeep)(json);
@@ -990,30 +1269,24 @@ function json700To500(json) {
     return ret;
 }
 /** Converts the given source NVM into a format that is compatible with the given target NVM */
-function migrateNVM(sourceNVM, targetNVM) {
+async function migrateNVM(sourceNVM, targetNVM) {
     let source;
     let target;
-    let sourceObjects;
     let sourceProtocolFileFormat;
     let targetProtocolFileFormat;
     try {
-        const nvm = (0, nvm_1.parseNVM)(sourceNVM);
         source = {
             type: 700,
-            json: parsedNVMToJSON(nvm),
+            json: await nvmToJSON(sourceNVM),
         };
         sourceProtocolFileFormat = source.json.format;
-        sourceObjects = new Map([
-            ...nvm.applicationObjects,
-            ...nvm.protocolObjects,
-        ]);
     }
     catch (e) {
         if ((0, safe_1.isZWaveError)(e) && e.code === safe_1.ZWaveErrorCodes.NVM_InvalidFormat) {
             // This is not a 700 series NVM, maybe it is a 500 series one?
             source = {
                 type: 500,
-                json: nvm500ToJSON(sourceNVM),
+                json: await nvm500ToJSON(sourceNVM),
             };
         }
         else if ((0, safe_1.isZWaveError)(e)
@@ -1031,7 +1304,7 @@ function migrateNVM(sourceNVM, targetNVM) {
     try {
         target = {
             type: 700,
-            json: nvmToJSON(targetNVM),
+            json: await nvmToJSON(targetNVM),
         };
         targetProtocolFileFormat = target.json.format;
     }
@@ -1040,7 +1313,7 @@ function migrateNVM(sourceNVM, targetNVM) {
             // This is not a 700 series NVM, maybe it is a 500 series one?
             target = {
                 type: 500,
-                json: nvm500ToJSON(targetNVM),
+                json: await nvm500ToJSON(targetNVM),
             };
         }
         else if ((0, safe_1.isZWaveError)(e)
@@ -1092,7 +1365,7 @@ function migrateNVM(sourceNVM, targetNVM) {
             && semver_1.default.lt(sourceApplicationVersion, "255.0.0")
             && semver_1.default.lt(targetApplicationVersion, "255.0.0")
             // and avoid restoring a backup with a shifted 800 series application version file
-            && (!sourceObjects || !hasShiftedAppVersion800File(sourceObjects))) {
+            && (!hasShiftedAppVersion800File(source.json))) {
             return sourceNVM;
         }
     }
@@ -1166,39 +1439,24 @@ function migrateNVM(sourceNVM, targetNVM) {
 /**
  * Detects whether the app version file on a 800 series controller is shifted by 1 byte
  */
-function hasShiftedAppVersion800File(objects) {
-    const getObject = (id) => {
-        if (typeof id === "number") {
-            return objects.get(id);
-        }
-        else {
-            for (const [key, obj] of objects) {
-                if (id(key))
-                    return obj;
-            }
-        }
-    };
-    const getFile = (id, fileVersion) => {
-        const obj = getObject(id);
-        if (!obj)
-            return undefined;
-        return files_1.NVMFile.from(obj, fileVersion);
-    };
-    const protocolVersionFile = getFile(files_1.ProtocolVersionFileID, "7.0.0");
-    // File not found, cannot fix anything
-    if (!protocolVersionFile)
+function hasShiftedAppVersion800File(json) {
+    // We can only detect this on 800 series controllers with the shared FS
+    if (!json.meta.sharedFileSystem)
         return false;
-    const protocolVersion = `${protocolVersionFile.major}.${protocolVersionFile.minor}.${protocolVersionFile.patch}`;
-    const applVersionFile800 = getFile(files_1.ApplicationVersionFile800ID, protocolVersion);
-    // File not found, cannot fix anything
-    if (!applVersionFile800)
+    const protocolVersion = semver_1.default.parse(json.controller.protocolVersion);
+    // Invalid protocol version, cannot fix anything
+    if (!protocolVersion)
+        return false;
+    const applicationVersion = semver_1.default.parse(json.controller.applicationVersion);
+    // Invalid application version, cannot fix anything
+    if (!applicationVersion)
         return false;
     // We consider the version shifted if:
     // - the app version format is the major protocol version
     // - the app version major is the minor protocol version +/- 3
-    if (applVersionFile800.format !== protocolVersionFile.major)
+    if (json.applicationFileFormat !== protocolVersion.major)
         return false;
-    if (Math.abs(applVersionFile800.major - protocolVersionFile.minor) > 3) {
+    if (Math.abs(applicationVersion.major - protocolVersion.minor) > 3) {
         return false;
     }
     return true;