@zwave-js/nvmedit 8.9.0-beta.4-pr-3789-c208add

package/build/convert.js

@@ -0,0 +1,796 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateNVM = exports.json700To500 = exports.json500To700 = exports.jsonToNVM500 = exports.jsonToNVM = exports.nvm500ToJSON = exports.nvmToJSON = exports.jsonToNVMObjects_v1_to_v3 = exports.jsonToNVMObjects_v0 = exports.nvmObjectsToJSON = exports.nodeHasInfo = void 0;
+const core_1 = require("@zwave-js/core");
+const shared_1 = require("@zwave-js/shared");
+const semver_1 = __importDefault(require("semver"));
+const files_1 = require("./files");
+const nvm_1 = require("./nvm3/nvm");
+const utils_1 = require("./nvm3/utils");
+const NVMParser_1 = require("./nvm500/NVMParser");
+function nodeHasInfo(node) {
+    return !node.isVirtual || Object.keys(node).length > 1;
+}
+exports.nodeHasInfo = nodeHasInfo;
+function createEmptyPhysicalNode() {
+    return {
+        isVirtual: false,
+        isListening: false,
+        isFrequentListening: false,
+        isRouting: false,
+        supportedDataRates: [],
+        protocolVersion: 0,
+        optionalFunctionality: false,
+        nodeType: core_1.NodeType["Routing End Node"],
+        supportsSecurity: false,
+        supportsBeaming: false,
+        genericDeviceClass: 0,
+        specificDeviceClass: null,
+        neighbors: [],
+        sucUpdateIndex: 0,
+        appRouteLock: false,
+        routeSlaveSUC: false,
+        sucPendingUpdate: false,
+        pendingDiscovery: false,
+        lwr: null,
+        nlwr: null,
+    };
+}
+/** Converts a compressed set of NVM objects to a JSON representation */
+function nvmObjectsToJSON(applicationObjects, protocolObjects) {
+    var _a, _b, _c, _d;
+    const nodes = new Map();
+    const getNode = (id) => {
+        if (!nodes.has(id))
+            nodes.set(id, createEmptyPhysicalNode());
+        return nodes.get(id);
+    };
+    const getObject = (id) => {
+        var _a;
+        if (typeof id === "number") {
+            return (_a = protocolObjects.get(id)) !== null && _a !== void 0 ? _a : applicationObjects.get(id);
+        }
+        else {
+            for (const [key, obj] of protocolObjects) {
+                if (id(key))
+                    return obj;
+            }
+            for (const [key, obj] of applicationObjects) {
+                if (id(key))
+                    return obj;
+            }
+        }
+    };
+    const getObjectOrThrow = (id) => {
+        const ret = getObject(id);
+        if (ret)
+            return ret;
+        throw new Error(`Object not found`);
+    };
+    const getFileOrThrow = (id) => {
+        const obj = getObjectOrThrow(id);
+        return files_1.NVMFile.from(obj);
+    };
+    const getFile = (id) => {
+        const obj = getObject(id);
+        if (!obj)
+            return undefined;
+        return files_1.NVMFile.from(obj);
+    };
+    // Figure out how to parse the individual files
+    const protocolVersionFile = getFileOrThrow(files_1.ProtocolVersionFileID);
+    const protocolFileFormat = protocolVersionFile.format;
+    // Figure out which nodes exist
+    const nodeIds = getFileOrThrow(files_1.ProtocolNodeListFileID).nodeIds;
+    // Read all flags for all nodes
+    const appRouteLock = new Set(getFileOrThrow(files_1.ProtocolAppRouteLockNodeMaskFileID).nodeIds);
+    const routeSlaveSUC = new Set(getFileOrThrow(files_1.ProtocolRouteSlaveSUCNodeMaskFileID).nodeIds);
+    const sucPendingUpdate = new Set(getFileOrThrow(files_1.ProtocolSUCPendingUpdateNodeMaskFileID).nodeIds);
+    const isVirtual = new Set(getFileOrThrow(files_1.ProtocolVirtualNodeMaskFileID).nodeIds);
+    const pendingDiscovery = new Set(getFileOrThrow(files_1.ProtocolPendingDiscoveryNodeMaskFileID).nodeIds);
+    const routeCacheExists = new Set(getFileOrThrow(files_1.ProtocolRouteCacheExistsNodeMaskFileID).nodeIds);
+    // And create each node entry, including virtual ones
+    for (const id of nodeIds) {
+        const node = getNode(id);
+        const rememberOnlyVirtual = () => {
+            nodes.set(id, {
+                isVirtual: true,
+            });
+        };
+        // Find node info
+        let nodeInfo;
+        try {
+            if (protocolFileFormat === 0) {
+                const fileId = (0, files_1.nodeIdToNodeInfoFileIDV0)(id);
+                const file = getFileOrThrow(fileId);
+                nodeInfo = file.nodeInfo;
+            }
+            else if (protocolFileFormat <= 3) {
+                const fileId = (0, files_1.nodeIdToNodeInfoFileIDV1)(id);
+                const file = getFileOrThrow(fileId);
+                nodeInfo = file.nodeInfos.find((i) => i.nodeId === id);
+            }
+            else {
+                throw new Error(`Unsupported protocol file format: ${protocolFileFormat}`);
+            }
+        }
+        catch (e) {
+            if (e.message.includes("Object not found")) {
+                rememberOnlyVirtual();
+                continue;
+            }
+            throw e;
+        }
+        Object.assign(node, nodeInfo);
+        // Evaluate flags
+        node.isVirtual = isVirtual.has(id);
+        node.appRouteLock = appRouteLock.has(id);
+        node.routeSlaveSUC = routeSlaveSUC.has(id);
+        node.sucPendingUpdate = sucPendingUpdate.has(id);
+        node.pendingDiscovery = pendingDiscovery.has(id);
+        if (routeCacheExists.has(id)) {
+            let routeCache;
+            if (protocolFileFormat === 0) {
+                const fileId = (0, files_1.nodeIdToRouteCacheFileIDV0)(id);
+                const file = getFileOrThrow(fileId);
+                routeCache = file.routeCache;
+            }
+            else if (protocolFileFormat <= 3) {
+                const fileId = (0, files_1.nodeIdToRouteCacheFileIDV1)(id);
+                const file = getFileOrThrow(fileId);
+                routeCache = file.routeCaches.find((i) => i.nodeId === id);
+            }
+            else {
+                throw new Error(`Unsupported protocol file format: ${protocolFileFormat}`);
+            }
+            node.lwr = routeCache.lwr;
+            node.nlwr = routeCache.nlwr;
+        }
+        // @ts-expect-error Some fields include a nodeId, but we don't need it
+        delete node.nodeId;
+    }
+    // Now read info about the controller
+    const controllerInfoFile = getFileOrThrow(files_1.ControllerInfoFileID);
+    const sucUpdateEntries = getFileOrThrow(files_1.SUCUpdateEntriesFileID).updateEntries;
+    const rfConfigFile = getFile(files_1.ApplicationRFConfigFileID);
+    const applicationVersionFile = getFileOrThrow(files_1.ApplicationVersionFileID);
+    const applicationCCsFile = getFileOrThrow(files_1.ApplicationCCsFileID);
+    const applicationDataFile = getFile(files_1.ApplicationDataFileID);
+    const applicationTypeFile = getFileOrThrow(files_1.ApplicationTypeFileID);
+    const preferredRepeaters = (_a = getFile(files_1.ProtocolPreferredRepeatersFileID)) === null || _a === void 0 ? void 0 : _a.nodeIds;
+    const controllerProps = [
+        "nodeId",
+        "lastNodeId",
+        "staticControllerNodeId",
+        "sucLastIndex",
+        "controllerConfiguration",
+        "sucAwarenessPushNeeded",
+        "maxNodeId",
+        "reservedId",
+        "systemState",
+        "lastNodeIdLR",
+        "maxNodeIdLR",
+        "reservedIdLR",
+        "primaryLongRangeChannelId",
+        "dcdcConfig",
+    ];
+    const controller = {
+        protocolVersion: `${protocolVersionFile.major}.${protocolVersionFile.minor}.${protocolVersionFile.patch}`,
+        applicationVersion: `${applicationVersionFile.major}.${applicationVersionFile.minor}.${applicationVersionFile.patch}`,
+        homeId: `0x${controllerInfoFile.homeId.toString("hex")}`,
+        ...(0, shared_1.pick)(controllerInfoFile, controllerProps),
+        ...(0, shared_1.pick)(applicationTypeFile, [
+            "isListening",
+            "optionalFunctionality",
+            "genericDeviceClass",
+            "specificDeviceClass",
+        ]),
+        commandClasses: (0, shared_1.pick)(applicationCCsFile, [
+            "includedInsecurely",
+            "includedSecurelyInsecureCCs",
+            "includedSecurelySecureCCs",
+        ]),
+        preferredRepeaters,
+        ...(rfConfigFile
+            ? {
+                rfConfig: {
+                    rfRegion: rfConfigFile.rfRegion,
+                    txPower: rfConfigFile.txPower,
+                    measured0dBm: rfConfigFile.measured0dBm,
+                    enablePTI: (_b = rfConfigFile.enablePTI) !== null && _b !== void 0 ? _b : null,
+                    maxTXPower: (_c = rfConfigFile.maxTXPower) !== null && _c !== void 0 ? _c : null,
+                },
+            }
+            : {}),
+        sucUpdateEntries,
+        applicationData: (_d = applicationDataFile === null || applicationDataFile === void 0 ? void 0 : applicationDataFile.data.toString("hex")) !== null && _d !== void 0 ? _d : 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;
+    }
+    const ret = {
+        format: protocolFileFormat,
+        controller,
+        nodes: (0, utils_1.mapToObject)(nodes),
+    };
+    return ret;
+}
+exports.nvmObjectsToJSON = nvmObjectsToJSON;
+function nvmJSONNodeToNodeInfo(nodeId, node) {
+    return {
+        nodeId,
+        ...(0, shared_1.pick)(node, [
+            "isListening",
+            "isFrequentListening",
+            "isRouting",
+            "supportedDataRates",
+            "protocolVersion",
+            "optionalFunctionality",
+            "nodeType",
+            "supportsSecurity",
+            "supportsBeaming",
+            "genericDeviceClass",
+            "specificDeviceClass",
+            "neighbors",
+            "sucUpdateIndex",
+        ]),
+    };
+}
+function nvmJSONControllerToFileOptions(ctrlr) {
+    const ret = {
+        homeId: Buffer.from(ctrlr.homeId.replace(/^0x/, ""), "hex"),
+        nodeId: ctrlr.nodeId,
+        lastNodeId: ctrlr.lastNodeId,
+        staticControllerNodeId: ctrlr.staticControllerNodeId,
+        sucLastIndex: ctrlr.sucLastIndex,
+        controllerConfiguration: ctrlr.controllerConfiguration,
+        maxNodeId: ctrlr.maxNodeId,
+        reservedId: ctrlr.reservedId,
+        systemState: ctrlr.systemState,
+    };
+    if (ctrlr.sucAwarenessPushNeeded != undefined) {
+        // @ts-expect-error We're dealing with a conditional object here
+        // TS doesn't like that.
+        ret.sucAwarenessPushNeeded = ctrlr.sucAwarenessPushNeeded;
+    }
+    else {
+        Object.assign(ret, (0, core_1.stripUndefined)((0, shared_1.pick)(ctrlr, [
+            "sucAwarenessPushNeeded",
+            "lastNodeIdLR",
+            "maxNodeIdLR",
+            "reservedIdLR",
+            "primaryLongRangeChannelId",
+            "dcdcConfig",
+        ])));
+    }
+    return ret;
+}
+function serializeCommonApplicationObjects(nvm) {
+    var _a, _b;
+    const ret = [];
+    const applTypeFile = new files_1.ApplicationTypeFile((0, shared_1.pick)(nvm.controller, [
+        "isListening",
+        "optionalFunctionality",
+        "genericDeviceClass",
+        "specificDeviceClass",
+    ]));
+    ret.push(applTypeFile.serialize());
+    const applCCsFile = new files_1.ApplicationCCsFile((0, shared_1.pick)(nvm.controller.commandClasses, [
+        "includedInsecurely",
+        "includedSecurelyInsecureCCs",
+        "includedSecurelySecureCCs",
+    ]));
+    ret.push(applCCsFile.serialize());
+    if (nvm.controller.rfConfig) {
+        const applRFConfigFile = new files_1.ApplicationRFConfigFile({
+            ...(0, shared_1.pick)(nvm.controller.rfConfig, [
+                "rfRegion",
+                "txPower",
+                "measured0dBm",
+            ]),
+            enablePTI: (_a = nvm.controller.rfConfig.enablePTI) !== null && _a !== void 0 ? _a : undefined,
+            maxTXPower: (_b = nvm.controller.rfConfig.maxTXPower) !== null && _b !== void 0 ? _b : undefined,
+        });
+        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"),
+        });
+        ret.push(applDataFile.serialize());
+    }
+    return ret;
+}
+function serializeCommonProtocolObjects(nvm) {
+    var _a;
+    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],
+    }).serialize());
+    ret.push(new files_1.ProtocolRouteSlaveSUCNodeMaskFile({
+        nodeIds: [...routeSlaveSUC],
+    }).serialize());
+    ret.push(new files_1.ProtocolSUCPendingUpdateNodeMaskFile({
+        nodeIds: [...sucPendingUpdate],
+    }).serialize());
+    ret.push(new files_1.ProtocolVirtualNodeMaskFile({
+        nodeIds: [...isVirtual],
+    }).serialize());
+    ret.push(new files_1.ProtocolPendingDiscoveryNodeMaskFile({
+        nodeIds: [...pendingDiscovery],
+    }).serialize());
+    // TODO: format >= 2: { .key = FILE_ID_LRANGE_NODE_EXIST, .size = FILE_SIZE_LRANGE_NODE_EXIST, .name = "LRANGE_NODE_EXIST"},
+    if ((_a = nvm.controller.preferredRepeaters) === null || _a === void 0 ? void 0 : _a.length) {
+        ret.push(new files_1.ProtocolPreferredRepeatersFile({
+            nodeIds: nvm.controller.preferredRepeaters,
+        }).serialize());
+    }
+    ret.push(new files_1.SUCUpdateEntriesFile({
+        updateEntries: nvm.controller.sucUpdateEntries,
+    }).serialize());
+    return ret;
+}
+function jsonToNVMObjects_v0(json, major, minor, patch) {
+    var _a, _b;
+    const target = (0, shared_1.cloneDeep)(json);
+    target.format = 0;
+    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 [applMajor, applMinor, applPatch] = target.controller.applicationVersion.split(".").map((i) => parseInt(i));
+    const applVersionFile = new files_1.ApplicationVersionFile({
+        format: target.format,
+        major: applMajor,
+        minor: applMinor,
+        patch: applPatch,
+    });
+    addApplicationObjects(applVersionFile.serialize());
+    addApplicationObjects(...serializeCommonApplicationObjects(target));
+    // Protocol files
+    const protocolVersionFile = new files_1.ProtocolVersionFile({
+        format: target.format,
+        major,
+        minor,
+        patch,
+    });
+    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))
+            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),
+        }));
+        // 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: (_a = node.lwr) !== null && _a !== void 0 ? _a : (0, files_1.getEmptyRoute)(),
+                    nlwr: (_b = node.nlwr) !== null && _b !== void 0 ? _b : (0, files_1.getEmptyRoute)(),
+                },
+            }));
+        }
+    }
+    addProtocolObjects(...serializeCommonProtocolObjects(target));
+    addProtocolObjects(new files_1.ProtocolNodeListFile({ nodeIds: [...nodeInfoExists] }).serialize());
+    addProtocolObjects(new files_1.ProtocolRouteCacheExistsNodeMaskFile({
+        nodeIds: [...routeCacheExists],
+    }).serialize());
+    if (nodeInfoFiles.size > 0) {
+        addProtocolObjects(...[...nodeInfoFiles.values()].map((f) => f.serialize()));
+    }
+    if (routeCacheFiles.size > 0) {
+        addProtocolObjects(...[...routeCacheFiles.values()].map((f) => f.serialize()));
+    }
+    return {
+        applicationObjects,
+        protocolObjects,
+    };
+}
+exports.jsonToNVMObjects_v0 = jsonToNVMObjects_v0;
+function jsonToNVMObjects_v1_to_v3(format, json, major, minor, patch) {
+    var _a, _b;
+    const target = (0, shared_1.cloneDeep)(json);
+    target.format = 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 [applMajor, applMinor, applPatch] = target.controller.applicationVersion.split(".").map((i) => parseInt(i));
+    const applVersionFile = new files_1.ApplicationVersionFile({
+        format: target.format,
+        major: applMajor,
+        minor: applMinor,
+        patch: applPatch,
+    });
+    addApplicationObjects(applVersionFile.serialize());
+    addApplicationObjects(...serializeCommonApplicationObjects(target));
+    // Protocol files
+    const protocolVersionFile = new files_1.ProtocolVersionFile({
+        format: target.format,
+        major,
+        minor,
+        patch,
+    });
+    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))
+            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: [],
+            }));
+        }
+        const nodeInfoFile = nodeInfoFiles.get(nodeInfoFileIndex);
+        nodeInfoFile.nodeInfos.push(nvmJSONNodeToNodeInfo(nodeId, node));
+        // Create/update route cache file (if there is a route)
+        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: [],
+                }));
+            }
+            const routeCacheFile = routeCacheFiles.get(routeCacheFileIndex);
+            routeCacheFile.routeCaches.push({
+                nodeId,
+                lwr: (_a = node.lwr) !== null && _a !== void 0 ? _a : (0, files_1.getEmptyRoute)(),
+                nlwr: (_b = node.nlwr) !== null && _b !== void 0 ? _b : (0, files_1.getEmptyRoute)(),
+            });
+        }
+    }
+    addProtocolObjects(...serializeCommonProtocolObjects(target));
+    addProtocolObjects(new files_1.ProtocolNodeListFile({ nodeIds: [...nodeInfoExists] }).serialize());
+    addProtocolObjects(new files_1.ProtocolRouteCacheExistsNodeMaskFile({
+        nodeIds: [...routeCacheExists],
+    }).serialize());
+    if (nodeInfoFiles.size > 0) {
+        addProtocolObjects(...[...nodeInfoFiles.values()].map((f) => f.serialize()));
+    }
+    if (routeCacheFiles.size > 0) {
+        addProtocolObjects(...[...routeCacheFiles.values()].map((f) => f.serialize()));
+    }
+    return {
+        applicationObjects,
+        protocolObjects,
+    };
+}
+exports.jsonToNVMObjects_v1_to_v3 = jsonToNVMObjects_v1_to_v3;
+/** Reads an NVM buffer and returns its JSON representation */
+function nvmToJSON(buffer, debugLogs = false) {
+    const nvm = (0, nvm_1.parseNVM)(buffer, debugLogs);
+    const ret = nvmObjectsToJSON(nvm.applicationObjects, nvm.protocolObjects);
+    ret.meta = (0, nvm_1.getNVMMeta)(nvm.protocolPages[0]);
+    return ret;
+}
+exports.nvmToJSON = nvmToJSON;
+/** 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 Error("Unsupported NVM format!");
+    return parser.toJSON();
+}
+exports.nvm500ToJSON = nvm500ToJSON;
+/** Takes a JSON represented NVM and converts it to binary */
+function jsonToNVM(json, protocolVersion) {
+    const parsedVersion = semver_1.default.parse(protocolVersion);
+    if (!parsedVersion) {
+        throw new Error(`Invalid protocol version: ${protocolVersion}`);
+    }
+    let objects;
+    if (semver_1.default.gte(parsedVersion, "7.15.3")) {
+        objects = jsonToNVMObjects_v1_to_v3(3, json, parsedVersion.major, parsedVersion.minor, parsedVersion.patch);
+    }
+    else if (semver_1.default.gte(parsedVersion, "7.12.0")) {
+        objects = jsonToNVMObjects_v1_to_v3(2, json, parsedVersion.major, parsedVersion.minor, parsedVersion.patch);
+    }
+    else if (semver_1.default.gte(parsedVersion, "7.11.0")) {
+        objects = jsonToNVMObjects_v1_to_v3(1, json, parsedVersion.major, parsedVersion.minor, parsedVersion.patch);
+    }
+    else if (semver_1.default.gte(parsedVersion, "7.0.0")) {
+        objects = jsonToNVMObjects_v0(json, parsedVersion.major, parsedVersion.minor, parsedVersion.patch);
+    }
+    else {
+        throw new Error("jsonToNVM cannot convert to a pre-7.0 NVM version");
+    }
+    return (0, nvm_1.encodeNVM)(objects.applicationObjects, objects.protocolObjects, json.meta);
+}
+exports.jsonToNVM = jsonToNVM;
+/** Takes a JSON represented 500 series NVM and converts it to binary */
+function jsonToNVM500(json, protocolVersion) {
+    // Try to find a matching implementation
+    const impl = NVMParser_1.nmvDetails500.find((p) => p.protocolVersions.includes(protocolVersion) &&
+        p.name.toLowerCase().startsWith(json.meta.library));
+    if (!impl) {
+        throw new Error(`Did not find a matching implementation for protocol version ${protocolVersion} and library ${json.meta.library}.`);
+    }
+    const serializer = new NVMParser_1.NVMSerializer(impl);
+    serializer.parseJSON(json, protocolVersion);
+    return serializer.serialize();
+}
+exports.jsonToNVM500 = jsonToNVM500;
+function json500To700(json, truncateApplicationData) {
+    var _a;
+    const source = (0, shared_1.cloneDeep)(json);
+    // On the 500 series, some properties are only defined for the nodes, so we pull it off the
+    // controller's node entry
+    let controllerNode = source.nodes[source.controller.nodeId || 1]; // Little hack because TS doesn't type check the union type properly
+    if (!nodeHasInfo(controllerNode)) {
+        // No information available, use sensible defaults
+        controllerNode = {
+            isListening: true,
+            optionalFunctionality: false,
+            // Static PC Controller
+            genericDeviceClass: 0x02,
+            specificDeviceClass: 0x01,
+        };
+    }
+    let applicationData = null;
+    if (source.controller.applicationData) {
+        let raw = Buffer.from(source.controller.applicationData, "hex");
+        // Find actual start and end of application data, ignoring zeroes
+        let start = 0;
+        while (start < raw.length && raw[start] === 0) {
+            start++;
+        }
+        let end = raw.length - 1;
+        while (end > start && raw[end] === 0) {
+            end--;
+        }
+        raw = raw.slice(start, end + 1);
+        if (raw.length > 512) {
+            if (!truncateApplicationData) {
+                throw new Error("Invalid NVM JSON: Application data would be truncated! Set truncateApplicationData to true to allow this.");
+            }
+            raw = raw.slice(0, 512);
+        }
+        applicationData = raw.toString("hex");
+    }
+    let homeId;
+    if (source.controller.controllerConfiguration &
+        core_1.ControllerCapabilityFlags.OnOtherNetwork) {
+        // The controller did not start the network itself
+        if (!source.controller.learnedHomeId) {
+            throw new Error("Invalid NVM JSON: Controller is part of another network but has no learned Home ID!");
+        }
+        else if (!source.controller.nodeId) {
+            throw new Error("Invalid NVM JSON: Controller is part of another network but node ID is zero!");
+        }
+        homeId = source.controller.learnedHomeId;
+    }
+    else {
+        // The controller did start the network itself
+        homeId = source.controller.ownHomeId;
+        // it is safe to set the node ID to 1
+        source.controller.nodeId = 1;
+    }
+    const ret = {
+        // Start out with format 0 (= protocol version 7.0.0), the jsonToNVM routines will do further conversion
+        format: 0,
+        controller: {
+            // This will contain the original 6.x protocol version, but the jsonToNVM routines will update it
+            protocolVersion: source.controller.protocolVersion,
+            applicationVersion: source.controller.applicationVersion,
+            homeId,
+            nodeId: source.controller.nodeId,
+            lastNodeId: source.controller.lastNodeId,
+            staticControllerNodeId: source.controller.staticControllerNodeId,
+            sucLastIndex: source.controller.sucLastIndex,
+            controllerConfiguration: source.controller.controllerConfiguration,
+            sucUpdateEntries: source.controller.sucUpdateEntries,
+            maxNodeId: source.controller.maxNodeId,
+            reservedId: source.controller.reservedId,
+            systemState: source.controller.systemState,
+            preferredRepeaters: source.controller.preferredRepeaters,
+            // RF config exists on both series but isn't compatible
+            isListening: controllerNode.isListening,
+            optionalFunctionality: controllerNode.optionalFunctionality,
+            genericDeviceClass: controllerNode.genericDeviceClass,
+            specificDeviceClass: (_a = controllerNode.specificDeviceClass) !== null && _a !== void 0 ? _a : 0,
+            commandClasses: {
+                includedInsecurely: source.controller.commandClasses,
+                includedSecurelyInsecureCCs: [],
+                includedSecurelySecureCCs: [],
+            },
+            applicationData,
+        },
+        // The node entries are actually compatible between the two JSON versions
+        // but the types are structured differently
+        nodes: source.nodes,
+    };
+    return ret;
+}
+exports.json500To700 = json500To700;
+function json700To500(json) {
+    var _a;
+    const source = (0, shared_1.cloneDeep)(json);
+    const ret = {
+        format: 500,
+        controller: {
+            // This will contain the original 7.x protocol version, but the jsonToNVM routines will update it
+            protocolVersion: source.controller.protocolVersion,
+            applicationVersion: source.controller.applicationVersion,
+            // The 700 series does not distinguish between own and learned home ID in NVM
+            // We infer it from the controller configuration if we need it
+            ownHomeId: source.controller.homeId,
+            learnedHomeId: source.controller.controllerConfiguration &
+                core_1.ControllerCapabilityFlags.OnOtherNetwork
+                ? source.controller.homeId
+                : null,
+            nodeId: source.controller.nodeId,
+            lastNodeId: source.controller.lastNodeId,
+            staticControllerNodeId: source.controller.staticControllerNodeId,
+            sucLastIndex: source.controller.sucLastIndex,
+            controllerConfiguration: source.controller.controllerConfiguration,
+            sucUpdateEntries: source.controller.sucUpdateEntries,
+            maxNodeId: source.controller.maxNodeId,
+            reservedId: source.controller.reservedId,
+            systemState: source.controller.systemState,
+            watchdogStarted: 0,
+            preferredRepeaters: (_a = json.controller.preferredRepeaters) !== null && _a !== void 0 ? _a : [],
+            // RF config exists on both series but isn't compatible. So set the default
+            rfConfig: {
+                powerLevelNormal: [255, 255, 255],
+                powerLevelLow: [255, 255, 255],
+                powerMode: 255,
+                powerModeExtintEnable: 255,
+                powerModeWutTimeout: 0xffffffff,
+            },
+            commandClasses: source.controller.commandClasses.includedInsecurely,
+            applicationData: source.controller.applicationData,
+        },
+        // The node entries are actually compatible between the two JSON versions
+        // just the types are structured differently
+        nodes: source.nodes,
+    };
+    return ret;
+}
+exports.json700To500 = json700To500;
+/** Converts the given source NVM into a format that is compatible with the given target NVM */
+function migrateNVM(source, target) {
+    let sourceJSON;
+    let targetJSON;
+    let sourceIs500;
+    let targetIs500;
+    try {
+        sourceJSON = nvmToJSON(source);
+        sourceIs500 = false;
+    }
+    catch (e) {
+        try {
+            sourceJSON = nvm500ToJSON(source);
+            sourceIs500 = true;
+        }
+        catch (ee) {
+            throw new Error("Could not parse source NVM - invalid format!");
+        }
+    }
+    try {
+        targetJSON = nvmToJSON(target);
+        targetIs500 = false;
+    }
+    catch (e) {
+        try {
+            targetJSON = nvm500ToJSON(target);
+            targetIs500 = true;
+        }
+        catch (ee) {
+            throw new Error("Could not parse target NVM - invalid format!");
+        }
+    }
+    if (sourceIs500 && targetIs500) {
+        // Both are 500, so we just need to update the metadata to match the target
+        const json = {
+            ...sourceJSON,
+            meta: targetJSON.meta,
+        };
+        return jsonToNVM500(json, targetJSON.controller.protocolVersion);
+    }
+    else if (sourceIs500 && !targetIs500) {
+        // We need to upgrade the source to 700 series
+        const json = {
+            ...json500To700(sourceJSON, true),
+            meta: targetJSON.meta,
+        };
+        return jsonToNVM(json, targetJSON.controller.protocolVersion);
+    }
+    else if (!sourceIs500 && targetIs500) {
+        // We need to downgrade the source to 500 series
+        const json = {
+            ...json700To500(sourceJSON),
+            meta: targetJSON.meta,
+        };
+        return jsonToNVM500(json, targetJSON.controller.protocolVersion);
+    }
+    else {
+        // Both are 700, so we just need to update the metadata to match the target
+        const json = {
+            ...sourceJSON,
+            meta: targetJSON.meta,
+        };
+        return jsonToNVM(json, targetJSON.controller.protocolVersion);
+    }
+}
+exports.migrateNVM = migrateNVM;
+//# sourceMappingURL=convert.js.map