iobroker.openknx 1.1.5 → 1.1.6

package/README.md

@@ -52,7 +52,7 @@ ioBroker adapter for KNX IP communication, powered by [KNXUltimate](https://gith
   Placeholder for the next version (at the beginning of the line):
     ### **WORK IN PROGRESS**
 -->
-### 1.1.5 (2026-03-31)
+### 1.1.6 (2026-04-12)
 
 - (TA2k) **breaking:** KNX communication switched to KNXUltimate
 - (TA2k) **breaking:** DPT21 property names changed (outofservice → outOfService, inalarm → inAlarm, alarmeunack → alarmUnAck), values must be boolean

package/admin/index_m.html

@@ -310,48 +310,71 @@
                     reader.addEventListener("load", function readFile(event) {
                         $("#etsFile").replaceWith($(etsFile));
                         $("#etsFile").change(processXmlFile);
-                        var base64 = btoa(
-                            new Uint8Array(event.target.result).reduce(function (data, byte) {
-                                return data + String.fromCharCode(byte);
-                            }, ""),
-                        );
-                        var sizeMB = (event.target.result.byteLength / 1024 / 1024).toFixed(1);
-                        var estSec = Math.max(1, Math.round(sizeMB * 1));
+                        // readAsDataURL returns "data:application/...;base64,XXXX"
+                        var dataUrl = event.target.result;
+                        var base64 = dataUrl.substring(dataUrl.indexOf(",") + 1);
+                        var sizeMB = (base64.length * 3 / 4 / 1024 / 1024).toFixed(1);
+                        console.log("[openknx] knxproj file read: " + sizeMB + " MB");
+                        var estSec = Math.max(1, Math.round(sizeMB * 0.75));
                         showToast(null, _("Import started") + " (" + sizeMB + " MB, ~" + estSec + "s) ...", null, estSec * 1000 + 3000);
                         $("#progress").show();
-                        sendTo(
-                            null,
-                            "importKnxproj",
-                            {
-                                knxprojBase64: base64,
-                                password: $("#knxprojPassword").val() || undefined,
-                                language: undefined,
-                                onlyAddNewObjects: $("#onlyAddNewObjects").prop("checked"),
-                                removeUnusedObjects: $("#removeUnusedObjects").prop("checked"),
-                                cleanImport: $("#cleanImport").prop("checked"),
-                            },
-                            function (result) {
-                                $("#progress").hide();
-                                if (!result || result.error) {
-                                    var message = "Unknown error";
-                                    if (result && result.error) {
-                                        message = "Imported " + result.count + " states successfully<p>" + result.error + "</p><p>See log for more information</p>";
-                                    }
-                                    showMessage(_(message));
-                                } else {
-                                    showMessage(
-                                        _("Imported %s states successfully", result.count) +
-                                            "<br/><br/>" +
-                                            _("knxproj import hint"),
-                                    );
-                                    sendTo(null, "restart", null);
-                                    showToast(null, _("Restarting adapter" + "..."), null, 10000);
-                                }
-                                window.isProcessingRequest = false;
-                            },
-                        );
+
+                        // Split base64 into 500KB chunks to avoid socket.io message size limits
+                        var CHUNK_SIZE = 500000;
+                        var totalChunks = Math.ceil(base64.length / CHUNK_SIZE);
+                        console.log("[openknx] sending " + totalChunks + " chunks...");
+
+                        var sendChunk = function (index) {
+                            if (index >= totalChunks) {
+                                // All chunks sent, trigger import
+                                console.log("[openknx] all chunks sent, triggering import...");
+                                sendTo(
+                                    null,
+                                    "importKnxprojEnd",
+                                    {
+                                        password: $("#knxprojPassword").val() || undefined,
+                                        language: undefined,
+                                        onlyAddNewObjects: $("#onlyAddNewObjects").prop("checked"),
+                                        removeUnusedObjects: $("#removeUnusedObjects").prop("checked"),
+                                        cleanImport: $("#cleanImport").prop("checked"),
+                                    },
+                                    function (result) {
+                                        console.log("[openknx] importKnxproj callback:", JSON.stringify(result));
+                                        $("#progress").hide();
+                                        if (!result || result.error) {
+                                            var message = "Unknown error";
+                                            if (result && result.error) {
+                                                message = "Imported " + result.count + " states successfully<p>" + result.error + "</p><p>See log for more information</p>";
+                                            }
+                                            showMessage(_(message));
+                                        } else {
+                                            showMessage(
+                                                _("Imported %s states successfully", result.count) +
+                                                    "<br/><br/>" +
+                                                    _("knxproj import hint"),
+                                            );
+                                            sendTo(null, "restart", null);
+                                            showToast(null, _("Restarting adapter" + "..."), null, 10000);
+                                        }
+                                        window.isProcessingRequest = false;
+                                    },
+                                );
+                                return;
+                            }
+                            var chunk = base64.substring(index * CHUNK_SIZE, (index + 1) * CHUNK_SIZE);
+                            sendTo(null, "importKnxprojChunk", { index: index, data: chunk }, function () {
+                                console.log("[openknx] chunk " + (index + 1) + "/" + totalChunks + " sent");
+                                sendChunk(index + 1);
+                            });
+                        };
+
+                        // Start: tell adapter how many chunks to expect
+                        sendTo(null, "importKnxprojStart", { totalChunks: totalChunks, sizeMB: sizeMB }, function () {
+                            console.log("[openknx] import started, sending chunks...");
+                            sendChunk(0);
+                        });
                     });
-                    reader.readAsArrayBuffer(file);
+                    reader.readAsDataURL(file);
                 } else {
                     showMessage(_("Unsupported file format"));
                 }

package/io-package.json

@@ -1,9 +1,9 @@
 {
   "common": {
     "name": "openknx",
-    "version": "1.1.5",
+    "version": "1.1.6",
     "news": {
-      "1.1.5": {
+      "1.1.6": {
         "en": "**breaking:** KNX communication switched to KNXUltimate\n**breaking:** DPT21 property names changed (outofservice → outOfService, inalarm → inAlarm, alarmeunack → alarmUnAck), values must be boolean\n**breaking:** DPT237 property names changed to camelCase\nfeature: KNX Secure support\nfeature: Native .knxproj import (ETS4/5/6, password-protected) with flags, DPT inference, room assignment\nfeature: Extended DPT coverage (9 additional DPTs, including DPT-22, 213, 222, 235, 242, 249, 251)\nfeature: Improved connection stability\nfeature: Improved role detection (switch, level, value, text, date) based on DPT type\nfeature: Direct Link all iobroker states to a KNX state\nfeature: GA-Tools: all GA properties editable (DPT, type, role, flags) with compact layout",
         "de": "**breaking:** KNX-Kommunikation auf KNXUltimate umgestellt\n**breaking:** DPT21 Eigenschaftsnamen geändert (outofservice → outOfService, inalarm → inAlarm, alarmeunack → alarmUnAck), Werte müssen boolean sein\n**breaking:** DPT237 Eigenschaftsnamen auf camelCase geändert\nFeature: KNX Secure Unterstützung\nFeature: Nativer .knxproj Import (ETS4/5/6, passwortgeschützt) mit Flags, DPT-Erkennung, Raumzuordnung\nFeature: Erweiterte DPT-Abdeckung (9 zusätzliche DPTs, u.a. DPT-22, 213, 222, 235, 242, 249, 251)\nFeature: Verbesserte Verbindungsstabilität\nFeature: Verbesserte Rollenerkennung (switch, level, value, text, date) basierend auf DPT-Typ\nFeature: Direct Link – beliebige ioBroker-States mit KNX-Gruppenadressen verknüpfen\nFeature: GA-Tools: alle GA-Eigenschaften editierbar (DPT, Typ, Rolle, Flags) mit kompaktem Layout",
         "ru": "**breaking:** KNX-коммуникация переключена на KNXUltimate\n**breaking:** Имена свойств DPT21 изменены (outofservice → outOfService, inalarm → inAlarm, alarmeunack → alarmUnAck), значения должны быть boolean\n**breaking:** Имена свойств DPT237 изменены на camelCase\nFeature: Поддержка KNX Secure\nFeature: Нативный импорт .knxproj (ETS4/5/6, с паролем) с флагами, определением DPT, назначением комнат\nFeature: Расширенное покрытие DPT (9 дополнительных DPT, включая DPT-22, 213, 222, 235, 242, 249, 251)\nFeature: Улучшенная стабильность соединения\nFeature: Улучшенное определение ролей (switch, level, value, text, date) на основе типа DPT\nFeature: Direct Link – привязка любых состояний ioBroker к групповым адресам KNX\nFeature: GA-Tools: все свойства GA редактируемы (DPT, тип, роль, флаги) с компактным макетом",

package/lib/knxproj/applicationLoader.js

@@ -5,104 +5,26 @@
  * Port of xknxproject/loader/application_program_loader.py
  * Parses M-xxxx/<application_program>.xml files to extract ComObjects,
  * ComObjectRefs, Allocators, ModuleDef Arguments, Channels, and Translations.
+ *
+ * Uses SAX streaming parser instead of DOM to handle very large XMLs (100+ MB)
+ * without excessive memory consumption.
  */
 
 "use strict";
 
-const { DOMParser } = require("@xmldom/xmldom");
+const sax = require("sax");
 const { parseDptTypes, parseXmlFlag } = require("./util");
 
 /**
- * Get all descendant elements with a given local name (namespace-agnostic).
- *
- * @param {Node} node
- * @param {string} localName
- * @returns {Element[]}
- */
-function byTagNS(node, localName) {
-    return Array.from(node.getElementsByTagNameNS("*", localName));
-}
-
-/**
- * Get direct child elements with a given local name.
- *
- * @param {Node} node
- * @param {string} localName
- * @returns {Element[]}
- */
-function childrenByTag(node, localName) {
-    const result = [];
-    const children = node.childNodes;
-    for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        if (child.nodeType === 1) {
-            const ln = child.localName || child.nodeName.replace(/^.*:/, "");
-            if (ln === localName) {
-                result.push(child);
-            }
-        }
-    }
-    return result;
-}
-
-/**
- * Parse a ComObject element.
- *
- * @param {Element} elem
- * @returns {object} ComObject
- */
-function parseComObject(elem) {
-    const identifier = elem.getAttribute("Id");
-    return {
-        identifier,
-        name: elem.getAttribute("Name") || "",
-        text: elem.getAttribute("Text") || "",
-        number: parseInt(elem.getAttribute("Number") || "0", 10),
-        functionText: elem.getAttribute("FunctionText") || "",
-        objectSize: elem.getAttribute("ObjectSize") || "",
-        readFlag: parseXmlFlag(elem.getAttribute("ReadFlag"), false),
-        writeFlag: parseXmlFlag(elem.getAttribute("WriteFlag"), false),
-        communicationFlag: parseXmlFlag(elem.getAttribute("CommunicationFlag"), false),
-        transmitFlag: parseXmlFlag(elem.getAttribute("TransmitFlag"), false),
-        updateFlag: parseXmlFlag(elem.getAttribute("UpdateFlag"), false),
-        readOnInitFlag: parseXmlFlag(elem.getAttribute("ReadOnInitFlag"), false),
-        datapointTypes: parseDptTypes(elem.getAttribute("DatapointType")),
-        baseNumberArgumentRef: elem.getAttribute("BaseNumber") || null,
-    };
-}
-
-/**
- * Parse a ComObjectRef element.
- *
- * @param {Element} elem
- * @returns {object} ComObjectRef
+ * Strip namespace prefix from a tag name: "knx:ComObject" -> "ComObject"
  */
-function parseComObjectRef(elem) {
-    const identifier = elem.getAttribute("Id");
-    return {
-        identifier,
-        refId: elem.getAttribute("RefId") || "",
-        name: elem.getAttribute("Name") || null,
-        text: elem.getAttribute("Text") || null,
-        functionText: elem.getAttribute("FunctionText") || null,
-        objectSize: elem.getAttribute("ObjectSize") || null,
-        readFlag: parseXmlFlag(elem.getAttribute("ReadFlag"), null),
-        writeFlag: parseXmlFlag(elem.getAttribute("WriteFlag"), null),
-        communicationFlag: parseXmlFlag(elem.getAttribute("CommunicationFlag"), null),
-        transmitFlag: parseXmlFlag(elem.getAttribute("TransmitFlag"), null),
-        updateFlag: parseXmlFlag(elem.getAttribute("UpdateFlag"), null),
-        readOnInitFlag: parseXmlFlag(elem.getAttribute("ReadOnInitFlag"), null),
-        datapointTypes: parseDptTypes(elem.getAttribute("DatapointType")),
-        textParameterRefId: elem.getAttribute("TextParameterRefId") || null,
-    };
+function localName(name) {
+    const i = name.indexOf(":");
+    return i >= 0 ? name.substring(i + 1) : name;
 }
 
 /**
  * Apply translations to translatable objects (ComObjects, ComObjectRefs, Channels).
- * Modifies objects in place.
- *
- * @param {object} objectMap - { [id]: object }
- * @param {object} translationMap - { [refId]: { [attributeName]: text } }
  */
 function applyTranslations(objectMap, translationMap) {
     for (const identifier of Object.keys(objectMap)) {
@@ -121,182 +43,208 @@ function applyTranslations(objectMap, translationMap) {
 }
 
 /**
- * Parse translations from the Languages section of the XML document.
- *
- * @param {Document} doc - Parsed XML document
- * @param {object} comObjects
- * @param {object} comObjectRefs
- * @param {Set<string>} usedComObjectRefIds
- * @param {object} channels
- * @param {string} languageCode
- */
-function parseTranslations(doc, comObjects, comObjectRefs, usedComObjectRefIds, channels, languageCode) {
-    // Build set of IDs we need translations for
-    const usedComObjectIds = new Set();
-    for (const ref of Object.values(comObjectRefs)) {
-        usedComObjectIds.add(ref.refId);
-    }
-    const usedTranslationIds = new Set([...usedComObjectIds, ...usedComObjectRefIds, ...Object.keys(channels)]);
-
-    // translationMap: { refId: { attributeName: text } }
-    const translationMap = {};
-
-    // Find the Language element matching our languageCode
-    const languageNodes = byTagNS(doc, "Language");
-    let targetLanguageNode = null;
-    for (const langNode of languageNodes) {
-        if (langNode.getAttribute && langNode.getAttribute("Identifier") === languageCode) {
-            targetLanguageNode = langNode;
-            break;
-        }
-    }
-
-    if (!targetLanguageNode) {
-        return;
-    }
-
-    // Find TranslationElement descendants within this Language node
-    const translationElements = byTagNS(targetLanguageNode, "TranslationElement");
-
-    for (const transElem of translationElements) {
-        const refId = transElem.getAttribute("RefId");
-        if (!refId || !usedTranslationIds.has(refId)) {
-            continue;
-        }
-
-        // Find Translation direct children
-        const translations = childrenByTag(transElem, "Translation");
-
-        for (const trans of translations) {
-            const attributeName = trans.getAttribute("AttributeName");
-            const text = trans.getAttribute("Text");
-            if (attributeName && text) {
-                if (!translationMap[refId]) {
-                    translationMap[refId] = {};
-                }
-                translationMap[refId][attributeName] = text;
-            }
-        }
-    }
-
-    applyTranslations(comObjectRefs, translationMap);
-    applyTranslations(comObjects, translationMap);
-    applyTranslations(channels, translationMap);
-}
-
-/**
- * Load application program data from an XML file inside the KNX project archive.
+ * Load application program data from an XML file using SAX streaming.
  *
  * @param {import('./extractor').KNXProjContents} knxProjContents
  * @param {Set<string>} usedComObjectRefIds - Only load ComObjectRefs with these IDs
- * @param {string} applicationProgramXmlPath - Path like "M-0083/M-0083_A-00B0-32-0DFC.xml"
+ * @param {string} applicationProgramXmlPath
  * @param {string} languageCode
  * @returns {Promise<object>} ApplicationProgram
  */
 async function load(knxProjContents, usedComObjectRefIds, applicationProgramXmlPath, languageCode) {
     let xmlContent = await knxProjContents.readFile(applicationProgramXmlPath);
 
-    const comObjects = {}; // { Id: ComObject }
-    const comObjectRefs = {}; // { Id: ComObjectRef }
-    const allocators = {}; // { Id: Allocator }
-    const moduleDefArguments = {}; // { Id: { name, allocates } }
-    const numericArgs = {}; // { RefId: { allocatorRefId, value, baseValue } }
-    const channels = {}; // { Id: ApplicationProgramChannel }
-
-    // Strip BOM if present - @xmldom/xmldom fails if BOM precedes <?xml declaration
+    // Strip BOM if present
     if (xmlContent.charCodeAt(0) === 0xfeff) {
         xmlContent = xmlContent.slice(1);
     }
 
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(xmlContent, "text/xml");
+    const comObjects = {};
+    const comObjectRefs = {};
+    const allocators = {};
+    const moduleDefArguments = {};
+    const numericArgs = {};
+    const channels = {};
 
-    // --- ComObject elements ---
-    const comObjectNodes = byTagNS(doc, "ComObject");
-    for (const elem of comObjectNodes) {
-        const co = parseComObject(elem);
-        comObjects[co.identifier] = co;
-    }
+    // Translation state
+    const usedTranslationIds = new Set();
+    const translationMap = {};
+    let inTargetLanguage = false;
+    let currentTranslationRefId = null;
 
-    // --- ComObjectRef elements (filtered to usedComObjectRefIds) ---
-    const comObjectRefNodes = byTagNS(doc, "ComObjectRef");
-    for (const elem of comObjectRefNodes) {
-        const id = elem.getAttribute("Id");
-        if (usedComObjectRefIds.has(id)) {
-            const cor = parseComObjectRef(elem);
-            comObjectRefs[id] = cor;
-        }
-    }
+    // Track parent context for ModuleDef > Argument
+    let inModuleDef = false;
 
-    // --- Allocator elements ---
-    const allocatorNodes = byTagNS(doc, "Allocator");
-    for (const elem of allocatorNodes) {
-        const id = elem.getAttribute("Id");
-        allocators[id] = {
-            identifier: id,
-            name: elem.getAttribute("Name") || "",
-            start: parseInt(elem.getAttribute("Start") || "0", 10),
-            end: parseInt(elem.getAttribute("maxInclusive") || "0", 10),
+    return new Promise((resolve, reject) => {
+        const parser = sax.parser(true, { trim: false, xmlns: false });
+
+        parser.onerror = (err) => {
+            // sax recovers from most errors, just log
+            parser.resume();
         };
-    }
 
-    // --- ModuleDef Arguments ---
-    // Find all Argument elements that are descendants of ModuleDef elements
-    const moduleDefNodes = byTagNS(doc, "ModuleDef");
-    for (const modDef of moduleDefNodes) {
-        const argumentNodes = byTagNS(modDef, "Argument");
-        for (const elem of argumentNodes) {
-            const id = elem.getAttribute("Id");
-            const allocatesAttr = elem.getAttribute("Allocates");
-            moduleDefArguments[id] = {
-                name: elem.getAttribute("Name") || "",
-                allocates: allocatesAttr != null ? parseInt(allocatesAttr, 10) : null,
-            };
-        }
-    }
+        parser.onopentag = (node) => {
+            const tag = localName(node.name);
+            const a = node.attributes;
+
+            switch (tag) {
+                case "ComObject": {
+                    const id = a.Id;
+                    if (id) {
+                        comObjects[id] = {
+                            identifier: id,
+                            name: a.Name || "",
+                            text: a.Text || "",
+                            number: parseInt(a.Number || "0", 10),
+                            functionText: a.FunctionText || "",
+                            objectSize: a.ObjectSize || "",
+                            readFlag: parseXmlFlag(a.ReadFlag, false),
+                            writeFlag: parseXmlFlag(a.WriteFlag, false),
+                            communicationFlag: parseXmlFlag(a.CommunicationFlag, false),
+                            transmitFlag: parseXmlFlag(a.TransmitFlag, false),
+                            updateFlag: parseXmlFlag(a.UpdateFlag, false),
+                            readOnInitFlag: parseXmlFlag(a.ReadOnInitFlag, false),
+                            datapointTypes: parseDptTypes(a.DatapointType),
+                            baseNumberArgumentRef: a.BaseNumber || null,
+                        };
+                    }
+                    break;
+                }
+                case "ComObjectRef": {
+                    const id = a.Id;
+                    if (id && usedComObjectRefIds.has(id)) {
+                        comObjectRefs[id] = {
+                            identifier: id,
+                            refId: a.RefId || "",
+                            name: a.Name || null,
+                            text: a.Text || null,
+                            functionText: a.FunctionText || null,
+                            objectSize: a.ObjectSize || null,
+                            readFlag: parseXmlFlag(a.ReadFlag, null),
+                            writeFlag: parseXmlFlag(a.WriteFlag, null),
+                            communicationFlag: parseXmlFlag(a.CommunicationFlag, null),
+                            transmitFlag: parseXmlFlag(a.TransmitFlag, null),
+                            updateFlag: parseXmlFlag(a.UpdateFlag, null),
+                            readOnInitFlag: parseXmlFlag(a.ReadOnInitFlag, null),
+                            datapointTypes: parseDptTypes(a.DatapointType),
+                            textParameterRefId: a.TextParameterRefId || null,
+                        };
+                    }
+                    break;
+                }
+                case "Allocator": {
+                    const id = a.Id;
+                    if (id) {
+                        allocators[id] = {
+                            identifier: id,
+                            name: a.Name || "",
+                            start: parseInt(a.Start || "0", 10),
+                            end: parseInt(a.maxInclusive || "0", 10),
+                        };
+                    }
+                    break;
+                }
+                case "ModuleDef":
+                    inModuleDef = true;
+                    break;
+                case "Argument": {
+                    if (inModuleDef) {
+                        const id = a.Id;
+                        if (id) {
+                            moduleDefArguments[id] = {
+                                name: a.Name || "",
+                                allocates: a.Allocates != null ? parseInt(a.Allocates, 10) : null,
+                            };
+                        }
+                    }
+                    break;
+                }
+                case "NumericArg": {
+                    const refId = a.RefId;
+                    if (refId) {
+                        numericArgs[refId] = {
+                            allocatorRefId: a.AllocatorRefId || null,
+                            value: a.Value != null ? parseInt(a.Value, 10) : null,
+                            baseValue: a.BaseValue || null,
+                        };
+                    }
+                    break;
+                }
+                case "Channel": {
+                    const id = a.Id;
+                    if (id) {
+                        channels[id] = {
+                            identifier: id,
+                            name: a.Name || "",
+                            number: a.Number || "",
+                            text: a.Text || null,
+                            textParameterRefId: a.TextParameterRefId || null,
+                        };
+                    }
+                    break;
+                }
+                // Translation handling
+                case "Language":
+                    if (languageCode && a.Identifier === languageCode) {
+                        inTargetLanguage = true;
+                    }
+                    break;
+                case "TranslationElement":
+                    if (inTargetLanguage && a.RefId) {
+                        currentTranslationRefId = a.RefId;
+                    }
+                    break;
+                case "Translation":
+                    if (currentTranslationRefId && a.AttributeName && a.Text) {
+                        if (!translationMap[currentTranslationRefId]) {
+                            translationMap[currentTranslationRefId] = {};
+                        }
+                        translationMap[currentTranslationRefId][a.AttributeName] = a.Text;
+                    }
+                    break;
+            }
+        };
 
-    // --- NumericArg elements (from ModuleDef choose/dynamic blocks) ---
-    const numericArgNodes = byTagNS(doc, "NumericArg");
-    for (const elem of numericArgNodes) {
-        const refId = elem.getAttribute("RefId");
-        if (refId) {
-            const valueAttr = elem.getAttribute("Value");
-            numericArgs[refId] = {
-                allocatorRefId: elem.getAttribute("AllocatorRefId") || null,
-                value: valueAttr != null ? parseInt(valueAttr, 10) : null,
-                baseValue: elem.getAttribute("BaseValue") || null,
-            };
-        }
-    }
+        parser.onclosetag = (name) => {
+            const tag = localName(name);
+            if (tag === "ModuleDef") {
+                inModuleDef = false;
+            } else if (tag === "Language") {
+                inTargetLanguage = false;
+            } else if (tag === "TranslationElement") {
+                currentTranslationRefId = null;
+            }
+        };
 
-    // --- Channel elements ---
-    const channelNodes = byTagNS(doc, "Channel");
-    for (const elem of channelNodes) {
-        const id = elem.getAttribute("Id");
-        if (id) {
-            channels[id] = {
-                identifier: id,
-                name: elem.getAttribute("Name") || "",
-                number: elem.getAttribute("Number") || "",
-                text: elem.getAttribute("Text") || null,
-                textParameterRefId: elem.getAttribute("TextParameterRefId") || null,
-            };
-        }
-    }
+        parser.onend = () => {
+            // Build translation IDs from parsed data and apply
+            if (languageCode) {
+                for (const ref of Object.values(comObjectRefs)) {
+                    usedTranslationIds.add(ref.refId);
+                }
+                for (const id of usedComObjectRefIds) {
+                    usedTranslationIds.add(id);
+                }
+                for (const id of Object.keys(channels)) {
+                    usedTranslationIds.add(id);
+                }
+                applyTranslations(comObjectRefs, translationMap);
+                applyTranslations(comObjects, translationMap);
+                applyTranslations(channels, translationMap);
+            }
 
-    // --- Translations ---
-    if (languageCode) {
-        parseTranslations(doc, comObjects, comObjectRefs, usedComObjectRefIds, channels, languageCode);
-    }
+            resolve({
+                comObjects,
+                comObjectRefs,
+                allocators,
+                moduleDefArguments,
+                numericArgs,
+                channels,
+            });
+        };
 
-    return {
-        comObjects,
-        comObjectRefs,
-        allocators,
-        moduleDefArguments,
-        numericArgs,
-        channels,
-    };
+        parser.write(xmlContent).close();
+    });
 }
 
 module.exports = {

package/lib/knxproj/extractor.js

@@ -47,33 +47,34 @@ async function openZipBuffer(buffer, password) {
         throw err;
     }
 
-    // Pre-read all entries into memory
+    // Lazy extraction: only decompress entries when buffer() is called.
+    // Buffers are NOT cached — each call re-decompresses from the ZIP entry.
+    // This frees memory immediately after each file is processed, avoiding
+    // hundreds of MB of simultaneous buffer allocations on large projects.
     const files = [];
     for (const entry of entries) {
         if (entry.directory) {
             continue;
         }
-        const filename = entry.filename;
-        let buf;
-        try {
-            const data = await entry.getData(new Uint8ArrayWriter());
-            buf = Buffer.from(data);
-        } catch (err) {
-            if (err.message && (err.message.includes("password") || err.message.includes("Password"))) {
-                await reader.close().catch(() => {});
-                throw new InvalidPasswordException(`Failed to decrypt entry "${filename}" - wrong password? (${err.message})`);
-            }
-            await reader.close().catch(() => {});
-            throw err;
-        }
         files.push({
-            path: filename,
+            path: entry.filename,
             type: "File",
-            uncompressedSize: buf.length,
-            buffer: async () => buf,
+            uncompressedSize: entry.uncompressedSize,
+            _entry: entry,
+            buffer: async function () {
+                try {
+                    const data = await this._entry.getData(new Uint8ArrayWriter());
+                    return Buffer.from(data);
+                } catch (err) {
+                    if (err.message && (err.message.includes("password") || err.message.includes("Password"))) {
+                        throw new InvalidPasswordException(`Failed to decrypt entry "${this.path}" - wrong password? (${err.message})`);
+                    }
+                    throw err;
+                }
+            },
         });
     }
-    await reader.close();
+    // Keep reader open — entries are decompressed lazily in buffer()
 
     return { files };
 }

package/lib/knxproj/parser.js

@@ -677,9 +677,10 @@ class Parser {
             }
         }
 
-        // 5. Group devices by application program, parse each once
+        // 5+6. Load each application program, merge into devices immediately,
+        // then discard to free memory. Processing one at a time avoids holding
+        // multiple large DOM trees simultaneously.
         const applicationProgramFiles = getApplicationProgramFilesForDevices(this.devices);
-        const applications = new Map();
 
         for (const [xmlFile, devicesForApp] of applicationProgramFiles) {
             const usedRefIds = collectUsedComObjectRefIds(devicesForApp);
@@ -689,20 +690,12 @@ class Parser {
                 xmlFile,
                 this.languageCode,
             );
-            applications.set(xmlFile, appProgram);
-        }
 
-        // 6. Merge application program info into devices
-        for (const device of this.devices) {
-            if (!device.applicationProgramRef) {
-                continue;
-            }
-            const xmlFile = applicationProgramXml(device);
-            const application = applications.get(xmlFile);
-            if (!application) {
-                continue;
+            // Merge into devices that use this application program
+            for (const device of devicesForApp) {
+                mergeDeviceApplicationProgramInfo(device, appProgram);
             }
-            mergeDeviceApplicationProgramInfo(device, application);
+            // appProgram goes out of scope here — DOM tree and parsed data freed
         }
     }
 

package/main.js

@@ -200,22 +200,58 @@ class openknx extends utils.Adapter {
                     };
                     if (obj.message.cleanImport) {
                         this.log.info("Clean import: deleting all existing KNX objects before import...");
-                        this.cleanImport().then(doXmlImport);
+                        this.cleanImport().then(doXmlImport).catch(e => {
+                            this.log.error(`Clean import failed: ${e.message}`);
+                            if (obj.callback) {
+                                this.sendTo(obj.from, obj.command, { error: `Clean import failed: ${e.message}`, count: 0 }, obj.callback);
+                            }
+                        });
                     } else {
                         doXmlImport();
                     }
                     break;
                 }
-                case "importKnxproj": {
-                    this.log.info("ETS .knxproj import...");
+                case "importKnxprojStart": {
+                    this.knxprojChunks = [];
+                    this.log.info(`ETS .knxproj chunked import started (${obj.message.totalChunks} chunks, ${obj.message.sizeMB} MB)`);
+                    if (obj.callback) {
+                        this.sendTo(obj.from, obj.command, {}, obj.callback);
+                    }
+                    break;
+                }
+                case "importKnxprojChunk": {
+                    // Decode each chunk to Buffer immediately to avoid keeping full base64 string in memory
+                    this.knxprojChunks[obj.message.index] = Buffer.from(obj.message.data, "base64");
+                    if (obj.callback) {
+                        this.sendTo(obj.from, obj.command, {}, obj.callback);
+                    }
+                    break;
+                }
+                case "importKnxprojEnd": {
+                    this.log.info("ETS .knxproj all chunks received, assembling...");
+                    const buffer = Buffer.concat(this.knxprojChunks);
+                    this.knxprojChunks = null;
                     const doKnxprojImport = async () => {
                         try {
-                            const buffer = Buffer.from(obj.message.knxprojBase64, "base64");
+                            this.log.info(`knxproj file size: ${(buffer.length / 1024 / 1024).toFixed(1)} MB`);
+                            // Warn if heap limit might be too low for large projects
+                            const v8 = require("v8");
+                            const heapStats = v8.getHeapStatistics();
+                            const heapLimitMB = Math.round(heapStats.heap_size_limit / 1024 / 1024);
+                            const fileSizeMB = buffer.length / 1024 / 1024;
+                            if (fileSizeMB > 10 && heapLimitMB < 1024) {
+                                this.log.warn(`Large knxproj (${fileSizeMB.toFixed(0)} MB) with ${heapLimitMB} MB heap limit. If the adapter crashes with "heap out of memory", increase Node.js memory: Instances > openknx > wrench icon > Node.js Options: --max-old-space-size=2048`);
+                            }
                             const password = obj.message.password || undefined;
                             const language = obj.message.language || undefined;
+                            this.log.debug("knxproj: extracting ZIP and parsing XML...");
                             const knxProject = await parseKnxproj(buffer, password, language);
+                            const gaCount = knxProject.groupAddresses ? Object.keys(knxProject.groupAddresses).length : 0;
+                            this.log.info(`knxproj: parsed ${gaCount} group addresses`);
                             const res = projectImport.convertKnxProject(this, knxProject);
+                            this.log.info(`knxproj: converted to ${res.objects.length} ioBroker objects`);
                             await this._createRoomEnums(res.rooms);
+                            this.log.debug(`knxproj: created ${Object.keys(res.rooms || {}).length} room enums`);
                             this._finishImport(res.objects, res.error, obj);
                         } catch (e) {
                             this.log.error(`knxproj import failed: ${e.message}`);
@@ -235,7 +271,12 @@ class openknx extends utils.Adapter {
                     };
                     if (obj.message.cleanImport) {
                         this.log.info("Clean import: deleting all existing KNX objects before import...");
-                        this.cleanImport().then(doKnxprojImport);
+                        this.cleanImport().then(doKnxprojImport).catch(e => {
+                            this.log.error(`Clean import failed: ${e.message}`);
+                            if (obj.callback) {
+                                this.sendTo(obj.from, obj.command, { error: `Clean import failed: ${e.message}`, count: 0 }, obj.callback);
+                            }
+                        });
                     } else {
                         doKnxprojImport();
                     }
@@ -371,6 +412,7 @@ class openknx extends utils.Adapter {
      * Common import finish logic shared between XML and knxproj import.
      */
     _finishImport(res, parseError, obj) {
+        this.log.info(`Importing ${res.length} objects into ioBroker...`);
         this.updateObjects(res, 0, obj.message.onlyAddNewObjects, (updateError, length) => {
             const msg = {
                 error:
@@ -426,12 +468,26 @@ class openknx extends utils.Adapter {
      * delete all existing KNX objects before a clean re-import
      */
     async cleanImport() {
-        await this.delObjectAsync("", { recursive: true });
+        try {
+            await this.delObjectAsync("", { recursive: true });
+        } catch (e) {
+            this.log.warn(`delObjectAsync("") failed (${e.message}), falling back to manual deletion`);
+            const objects = await this.getAdapterObjectsAsync();
+            for (const id of Object.keys(objects)) {
+                await this.delObjectAsync(id).catch(() => {});
+            }
+        }
         this.log.info("cleanImport: deleted all existing KNX objects");
+        // Re-create info objects that are needed during runtime
+        await this.setObjectNotExistsAsync("info.busload", { type: "state", common: { role: "info", name: "Busload", type: "number", read: true, write: false, def: 0, unit: "%" }, native: {} });
+        await this.setObjectNotExistsAsync("info.messagecount", { type: "state", common: { role: "info", name: "Message count", type: "number", read: true, write: false, def: 0 }, native: {} });
     }
 
     // write found communication objects to adapter object tree
     updateObjects(objects, i, onlyAddNewObjects, callback) {
+        if (i > 0 && i % 100 === 0) {
+            this.log.debug(`updateObjects: ${i}/${objects.length} objects written`);
+        }
         if (i >= objects.length) {
             // end of recursion reached
             let err = this.warnDuplicates(objects);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.openknx",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "ioBroker knx Adapter",
   "author": "boellner",
   "contributors": [
@@ -35,8 +35,8 @@
   },
   "dependencies": {
     "@iobroker/adapter-core": "^3.3.2",
-    "@xmldom/xmldom": "^0.9.8",
-    "@zip.js/zip.js": "^2.8.23",
+    "@xmldom/xmldom": "^0.9.9",
+    "@zip.js/zip.js": "^2.8.26",
     "ipaddr.js": "^2.3.0",
     "knxultimate": "^5.4.0",
     "xpath": "^0.0.34"
@@ -50,7 +50,7 @@
     "@iobroker/eslint-config": "^2.2.0",
     "@iobroker/testing": "^5.2.2",
     "@tsconfig/node20": "^20.1.9",
-    "@types/node": "^24.12.0",
+    "@types/node": "^25.6.0",
     "typescript": "~5.9.3"
   },
   "main": "main.js",