node-red-contrib-my-tools 1.0.0

package/node-red-contrib-s7-plus/lib/s7plus/browse/README.md

@@ -0,0 +1,72 @@
+# Lazy PLC browse
+
+## Protocol
+
+Mirrors the C# `S7CommPlusDriver` reference (`GetTypeInformation`, `GetCommentsXml`):
+
+1. **Roots**: `Explore { exploreId = NativeObjects_thePLCProgram_Rid, exploreRequestId = None, recursive = 1 }`
+   with `addressList = [ObjectVariableTypeName]` (DB number from `relationId`; comment not needed),
+   then read LID=1 on every DB to get `db_block_ti_relid`.
+2. **Children** (on demand for one block/struct):
+   `Explore { exploreId = tiRelId, exploreRequestId = None, recursive = 1 }`.
+   Returned objects are cached by `relationId` so nested structs reuse the same subtree.
+3. **Arrays** are virtual: page nodes (`[0..31]`, `[32..63]`, …) are generated client-side
+   from the array length; struct-array elements lazy-explore via the relation id.
+
+## Editor
+
+- `POST /s7complus/browse/roots` → `{ nodes, browseSessionId? }`
+- `POST /s7complus/browse/children` → `{ nodes }` (body: `nodeId`, session/endpoint context)
+- `POST /s7complus/browse/resolve` → `{ name, address, datatype }`
+- `POST /s7complus/browse` → **410 deprecated**
+
+Ephemeral browse (before deploy) uses `browseSessionId` from roots on subsequent calls.
+
+## Stale-connection recovery
+
+A "live" S7+ TCP connection often dies silently between two browse calls
+(NAT idle expiry, PLC reboot, cable, …). The recovery rules are:
+
+1. `S7CommPlusClient._waitForPdu` fires its read timeout (default 5s).
+   The handler **proactively tears the transport down** and calls
+   `_onTransportClosed({ reason: 'pdu-read-timeout' })`. The client emits
+   `disconnect` once and flips `connected` to `false` — so the very next
+   request does NOT pay another full read-timeout window.
+2. `forceDisconnect(reason)` (new) tears the transport down **without**
+   sending `DeleteObject`. Use this whenever the socket is already known
+   stale; the graceful `disconnect()` is reserved for the live path.
+3. `nodes/s7complus-endpoint.js` uses `forceDisconnect` in its reconnect
+   path (`ensureConnected(true)`) and applies a single retry both at the
+   endpoint level (`withReconnect`) and at the HTTP handler level
+   (`handleBrowseRequest`) for ephemeral browse sessions.
+4. Ephemeral browse sessions listen to the client's `disconnect` event
+   and mark themselves `dead`; the next `getEphemeralSession` lookup
+   discards them and the HTTP handler reconnects automatically.
+
+## Debug logging
+
+Set `S7P_DEBUG=*` (all scopes) or `S7P_DEBUG=client,endpoint,transport`
+(comma list) before starting Node-RED to surface every connect,
+disconnect, PDU send/receive and browse retry on stderr. Output is
+prefixed with `[s7p:<scope>] HH:MM:SS.mmm`.
+
+## Live tests
+
+All scripts require an explicit PLC host (no built-in default). Optional env vars:
+`S7_HOST`, `S7_PORT`, `S7_PASSWORD`, `S7_SYMBOL`, `S7_SYMBOLS` (comma-separated),
+`S7_DB_PREFIX`, `S7_WRITE_MARKER`.
+
+- `node test/scripts/live-browse.js <host> [port] [password]` — full browse chain
+- `node test/scripts/live-reconnect.js <host> [port] [password] [timeoutMs]` —
+  stale-socket / idle reconnect scenario; verifies pass 2 finishes in
+  `~timeout + connect time` (not `2 × timeout`)
+- `node test/scripts/live-crc-verify.js <host> [port] [password] <symbol> [...]` —
+  read symbolic symbols with computed CRC
+- `node test/scripts/live-crc-test.js <host> [port] [password] <arraySymbol>` —
+  compare PLC vte.symbolCrc with locally computed CRC variants
+- `node test/scripts/live-array-crc-diagnose.js <host> [port] [password] <symbol> [...]` —
+  diagnose CRC/address variants for array elements
+- `node test/scripts/live-datatype-rw.js <host> [port] [password]` —
+  read/type-check and write/readback sweep over DB blocks
+
+Example: `node test/scripts/live-browse.js 192.168.0.1 102`

package/node-red-contrib-s7-plus/lib/s7plus/browse/areas.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { Ids } = require('../constants');
+
+const MEMORY_AREAS = [
+    { name: 'IArea', label: 'IArea (Inputs)', accessId: Ids.NativeObjects_theIArea_Rid, tiRelId: 0x90010000 },
+    { name: 'QArea', label: 'QArea (Outputs)', accessId: Ids.NativeObjects_theQArea_Rid, tiRelId: 0x90020000 },
+    { name: 'MArea', label: 'MArea (Merker)', accessId: Ids.NativeObjects_theMArea_Rid, tiRelId: 0x90030000 },
+    { name: 'S7Timers', label: 'S7Timers (Timers)', accessId: Ids.NativeObjects_theS7Timers_Rid, tiRelId: 0x90050000 },
+    { name: 'S7Counters', label: 'S7Counters (Counters)', accessId: Ids.NativeObjects_theS7Counters_Rid, tiRelId: 0x90060000 }
+];
+
+const MEMORY_AREA_NAMES = MEMORY_AREAS.map(a => a.name);
+
+/**
+ * Normalize explore scope: empty partial selection falls back to everything.
+ * @param {object} [scope]
+ * @returns {{ everything: boolean, dbs: string[], areas: string[] }}
+ */
+function normalizeExploreScope(scope) {
+    if (!scope || scope.everything) {
+        return { everything: true, dbs: [], areas: [] };
+    }
+    const dbs = Array.isArray(scope.dbs) ? scope.dbs.filter(Boolean) : [];
+    const areas = Array.isArray(scope.areas) ? scope.areas.filter(Boolean) : [];
+    if (dbs.length === 0 && areas.length === 0) {
+        return { everything: true, dbs: [], areas: [] };
+    }
+    return { everything: false, dbs, areas };
+}
+
+module.exports = {
+    MEMORY_AREAS,
+    MEMORY_AREA_NAMES,
+    normalizeExploreScope
+};

package/node-red-contrib-s7-plus/lib/s7plus/browse/datatypes.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const eNodeType = { Root: 1, Var: 2, Array: 3, StructArray: 4 };
+
+// Primitive + hardware/S7 names (Wireshark tagdescr_softdatatype_names + vendor-specific IDs)
+const SOFTDATATYPE_NAMES = {
+    1: 'Bool', 2: 'Byte', 3: 'Char', 4: 'Word', 5: 'Int', 6: 'DWord', 7: 'DInt', 8: 'Real',
+    9: 'Date', 10: 'TimeOfDay', 11: 'Time', 12: 'S5Time', 14: 'DateAndTime', 17: 'Struct',
+    19: 'String', 20: 'Pointer', 22: 'Any', 23: 'BlockFb', 24: 'BlockFc', 28: 'Counter',
+    29: 'Timer', 40: 'BBool', 48: 'LReal', 49: 'ULInt', 50: 'LInt', 51: 'LWord', 52: 'USInt',
+    53: 'UInt', 54: 'UDInt', 55: 'SInt', 61: 'WChar', 62: 'WString', 64: 'LTime', 65: 'LTod',
+    66: 'Ldt', 67: 'Dtl',
+    96: 'REMOTE',
+    128: 'AOM_IDENT', 129: 'EVENT_ANY', 130: 'EVENT_ATT', 131: 'EVENT_HWINT',
+    132: 'FOLDER', 133: 'AOM_AID', 134: 'AOM_LINK',
+    144: 'HW_ANY', 145: 'HW_IOSYSTEM', 146: 'HW_DPMASTER', 147: 'HW_DEVICE', 148: 'HW_DPSLAVE',
+    149: 'HW_IO', 150: 'HW_MODULE', 151: 'HW_SUBMODULE', 152: 'HW_HSC', 153: 'HW_PWM',
+    154: 'HW_PTO', 155: 'HW_INTERFACE', 156: 'HW_IEPORT',
+    160: 'OB_ANY', 161: 'OB_DELAY', 162: 'OB_TOD', 163: 'OB_CYCLIC', 164: 'OB_ATT',
+    168: 'CONN_ANY', 169: 'CONN_PRG', 170: 'CONN_OUC', 171: 'CONN_R_ID',
+    173: 'PORT', 174: 'RTM', 175: 'PIP',
+    192: 'OB_PCYCLE', 193: 'OB_HWINT', 195: 'OB_DIAG', 196: 'OB_TIMEERROR', 197: 'OB_STARTUP',
+    208: 'DB_ANY', 209: 'DB_WWW', 210: 'DB_DYN'
+};
+
+const SUPPORTED_SOFTDATATYPES = new Set([
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 19, 20, 22, 23, 24, 28, 29, 40,
+    48, 49, 50, 51, 52, 53, 54, 55, 61, 62, 64, 65, 66, 67, 96,
+    128, 129, 130, 131, 132, 133, 134,
+    144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
+    160, 161, 162, 163, 164,
+    168, 169, 170, 171, 173, 174, 175,
+    192, 193, 195, 196, 197,
+    208, 209, 210
+]);
+
+function softdatatypeName(id) {
+    return SOFTDATATYPE_NAMES[id] || `Softdatatype_${id}`;
+}
+
+function isSoftdatatypeSupported(sd) {
+    return SUPPORTED_SOFTDATATYPES.has(sd);
+}
+
+// System datatypes that carry a type relation (and would otherwise look
+// like a nested struct) but are read/written as a single packed leaf
+// value. Currently only DTL (67). Such types must be classified as leaves
+// in the browse tree, not descended into.
+const PACKED_LEAF_SOFTDATATYPES = new Set([67]);
+
+function isPackedLeafDatatype(sd) {
+    return PACKED_LEAF_SOFTDATATYPES.has(sd);
+}
+
+function getSizeOfDatatype(vte) {
+    const oit = vte.offsetInfoType;
+    switch (vte.softdatatype) {
+        case 1: return 1;
+        case 2: case 3: case 40: case 52: case 55: return 1;
+        case 4: case 5: case 53: return 2;
+        case 6: case 7: case 8: case 10: case 11: case 54: return 4;
+        case 9: case 12: case 23: case 24: case 28: case 29: return 2;
+        case 14: case 48: case 49: case 50: case 51: case 64: case 65: case 66: return 8;
+        case 67: return 12; // DTL: packed 12-byte date/time structure
+        case 19: {
+            const isArr = (oit.is1Dim && oit.is1Dim()) || (oit.isMDim && oit.isMDim());
+            return isArr ? (oit.unspecifiedOffsetinfo1 || 0) + 2 : 0;
+        }
+        case 20: return 6;
+        case 22: return 10;
+        // Hardware / system types — 32-bit (AOM_IDENT, EVENT_*, FOLDER, AOM_AID, AOM_LINK, CONN_R_ID)
+        case 128: case 129: case 130: case 131: case 132: case 133: case 134: case 171: return 4;
+        // Hardware / system types — 16-bit (HW_*, OB_*, CONN_ANY/PRG/OUC, PORT, RTM, PIP, DB_*)
+        case 144: case 145: case 146: case 147: case 148: case 149:
+        case 150: case 151: case 152: case 153: case 154: case 155: case 156:
+        case 160: case 161: case 162: case 163: case 164:
+        case 168: case 169: case 170:
+        case 173: case 174: case 175:
+        case 192: case 193: case 195: case 196: case 197:
+        case 208: case 209: case 210: return 2;
+        default: return 0;
+    }
+}
+
+module.exports = {
+    eNodeType,
+    softdatatypeName,
+    isSoftdatatypeSupported,
+    isPackedLeafDatatype,
+    getSizeOfDatatype
+};

package/node-red-contrib-s7-plus/lib/s7plus/browse/flat-browser.js

@@ -0,0 +1,433 @@
+'use strict';
+
+const { Ids } = require('../constants');
+const { MEMORY_AREAS } = require('./areas');
+const { eNodeType, softdatatypeName, isSoftdatatypeSupported, isPackedLeafDatatype, getSizeOfDatatype } = require('./datatypes');
+const { applyBoolBitoffsets } = require('./vte-helpers');
+const { computeCrcFromMeta } = require('../crc');
+
+function oitLowerBound(oit) {
+    if (!oit) return 0;
+    if (typeof oit.getArrayLowerBounds === 'function') return oit.getArrayLowerBounds() | 0;
+    if (typeof oit.arrayLowerBounds === 'number') return oit.arrayLowerBounds | 0;
+    return 0;
+}
+
+function crcMetaFromSegments(segments) {
+    if (segments.length === 0) return null;
+    if (segments.length === 1) return segments[0];
+    return { pathSegments: segments };
+}
+
+const SOFTDATATYPE_BBOOL = 40;
+
+function normalizeMaxSymbols(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) return Infinity;
+    return Math.floor(n);
+}
+
+function createNode(overrides = {}) {
+    return {
+        nodeType: eNodeType.Undefined,
+        name: '',
+        accessId: 0,
+        softdatatype: 0,
+        relationId: 0,
+        vte: null,
+        arrayAdrOffsetOpt: 0,
+        arrayAdrOffsetNonOpt: 0,
+        childs: [],
+        ...overrides
+    };
+}
+
+function findObjectByRelId(objs, relId) {
+    if (!objs || relId === 0) return null;
+    for (const ob of objs) {
+        if (ob.relationId === relId) return ob;
+    }
+    return null;
+}
+
+function getTComSize(ob, objs) {
+    const attr = ob.getAttribute ? ob.getAttribute(Ids.TI_TComSize) : null;
+    if (attr && typeof attr.toJs === 'function') {
+        const v = attr.toJs();
+        return typeof v === 'number' ? v : Number(v);
+    }
+    return 0;
+}
+
+class FlatBrowser {
+    constructor(options = {}) {
+        this.rootNodes = [];
+        this.typeInfoObjects = [];
+        this.varInfoList = [];
+        this.maxSymbols = normalizeMaxSymbols(options.maxSymbols);
+        this._symbolCount = 0;
+        this.limitExceeded = false;
+        this._limitPending = false;
+    }
+
+    _noteOversizedArray(elementCount) {
+        if (elementCount > this.maxSymbols) {
+            this._limitPending = true;
+        }
+    }
+
+    _cappedArrayCount(elementCount) {
+        if (!Number.isFinite(this.maxSymbols)) return elementCount;
+        return Math.min(elementCount, this.maxSymbols);
+    }
+
+    _emitFlatSymbol(info) {
+        if (this._symbolCount >= this.maxSymbols) {
+            this.limitExceeded = true;
+            return false;
+        }
+        this.varInfoList.push(info);
+        this._symbolCount++;
+        return true;
+    }
+
+    setTypeInfoContainerObjects(objs) {
+        this.typeInfoObjects = objs || [];
+    }
+
+    addBlockNode(nodeType, name, accessId, tiRelId) {
+        this.rootNodes.push(createNode({
+            nodeType: nodeType || eNodeType.Root,
+            name,
+            accessId,
+            relationId: tiRelId
+        }));
+    }
+
+    buildTree() {
+        for (let i = 0; i < this.rootNodes.length; i++) {
+            const root = this.rootNodes[i];
+            const ob = findObjectByRelId(this.typeInfoObjects, root.relationId);
+            if (ob) {
+                this.addSubNodes(root, ob);
+            }
+        }
+    }
+
+    buildFlatList() {
+        this.varInfoList = [];
+        this._symbolCount = 0;
+        for (const node of this.rootNodes) {
+            if (this.limitExceeded) break;
+            if (node.childs.length > 0) {
+                this.addFlatSubnodes(node, '', '', 0, 0, []);
+            }
+        }
+        if (this._limitPending || this.limitExceeded) {
+            this.limitExceeded = true;
+        }
+        return this.varInfoList;
+    }
+
+    addFlatSubnodes(node, names, accessIds, optOffset, nonOptOffset, crcPath) {
+        if (this.limitExceeded) return;
+        let nextCrcPath = crcPath;
+
+        switch (node.nodeType) {
+            case eNodeType.Root:
+                names += node.name;
+                accessIds += node.accessId.toString(16).toUpperCase();
+                break;
+            case eNodeType.Array: {
+                names += node.name;
+                accessIds += '.' + node.accessId.toString(16).toUpperCase();
+                const oit = node.vte ? node.vte.offsetInfoType : null;
+                const prev = crcPath[crcPath.length - 1];
+                nextCrcPath = crcPath.slice(0, -1);
+                nextCrcPath.push({
+                    memberName: prev ? prev.memberName : '',
+                    softdatatype: prev ? prev.softdatatype : node.softdatatype,
+                    isArray: true,
+                    elementSoftdatatype: node.softdatatype,
+                    lowerBound: oitLowerBound(oit)
+                });
+                break;
+            }
+            case eNodeType.StructArray: {
+                names += node.name;
+                accessIds += '.' + node.accessId.toString(16).toUpperCase() + '.1';
+                const oit = node.vte ? node.vte.offsetInfoType : null;
+                const prev = crcPath[crcPath.length - 1];
+                nextCrcPath = crcPath.slice(0, -1);
+                nextCrcPath.push({
+                    memberName: prev ? prev.memberName : '',
+                    softdatatype: prev ? prev.softdatatype : node.softdatatype,
+                    isArray: true,
+                    elementSoftdatatype: node.softdatatype,
+                    lowerBound: oitLowerBound(oit)
+                });
+                break;
+            }
+            default:
+                names += '.' + node.name;
+                accessIds += '.' + node.accessId.toString(16).toUpperCase();
+                nextCrcPath = crcPath.concat([{
+                    memberName: node.name,
+                    softdatatype: node.softdatatype,
+                    isArray: false,
+                    elementSoftdatatype: 0,
+                    lowerBound: 0
+                }]);
+                break;
+        }
+
+        if (node.childs.length === 0) {
+            if (!isSoftdatatypeSupported(node.softdatatype)) return;
+            const info = {
+                name: names,
+                accessSequence: accessIds,
+                softdatatype: node.softdatatype,
+                softdatatypeName: softdatatypeName(node.softdatatype),
+                optAddress: 0,
+                nonOptAddress: 0,
+                optBitoffset: 0,
+                nonOptBitoffset: 0
+            };
+            if (node.vte) info.symbolCrc = node.vte.symbolCrc;
+            const meta = crcMetaFromSegments(nextCrcPath);
+            if (meta) info.computedCrc = computeCrcFromMeta(meta);
+            if (node.nodeType === eNodeType.Array) {
+                info.optAddress = optOffset;
+                info.nonOptAddress = nonOptOffset;
+            } else if (node.vte && node.vte.offsetInfoType) {
+                const oit = node.vte.offsetInfoType;
+                info.optAddress = optOffset + (oit.optimizedAddress || 0);
+                info.nonOptAddress = nonOptOffset + (oit.nonoptimizedAddress || 0);
+            }
+            if (node.vte) applyBoolBitoffsets(info, node.vte);
+            this._emitFlatSymbol(info);
+            return;
+        }
+
+        let nextOpt = optOffset;
+        let nextNon = nonOptOffset;
+        if (node.vte) {
+            const oit = node.vte.offsetInfoType;
+            if (node.nodeType === eNodeType.Array && oit) {
+                nextOpt = oit.optimizedAddress || 0;
+                nextNon = oit.nonoptimizedAddress || 0;
+            } else if (node.nodeType === eNodeType.StructArray) {
+                nextOpt += node.arrayAdrOffsetOpt;
+                nextNon += node.arrayAdrOffsetNonOpt;
+            } else if (oit) {
+                nextOpt += oit.optimizedAddress || 0;
+                nextNon += oit.nonoptimizedAddress || 0;
+            }
+        }
+
+        for (const sub of node.childs) {
+            if (this.limitExceeded) return;
+            if (sub.nodeType === eNodeType.Array) {
+                this.addFlatSubnodes(
+                    sub, names, accessIds,
+                    nextOpt + sub.arrayAdrOffsetOpt,
+                    nextNon + sub.arrayAdrOffsetNonOpt,
+                    nextCrcPath
+                );
+            } else {
+                this.addFlatSubnodes(sub, names, accessIds, nextOpt, nextNon, nextCrcPath);
+            }
+        }
+    }
+
+    addSubNodes(node, o) {
+        if (!o.vartypeList || !o.varnameList) return;
+        let elementIndex = 0;
+        for (const vte of o.vartypeList.elements) {
+            const subnode = createNode({
+                name: o.varnameList.names[elementIndex],
+                softdatatype: vte.softdatatype,
+                accessId: vte.lid,
+                vte
+            });
+            node.childs.push(subnode);
+            const oit = vte.offsetInfoType;
+
+            if (oit && oit.is1Dim && oit.is1Dim()) {
+                const count = oit.getArrayElementCount();
+                this._noteOversizedArray(count);
+                const expandCount = this._cappedArrayCount(count);
+                const lower = oit.getArrayLowerBounds();
+                for (let i = 0; i < expandCount; i++) {
+                    if (oit.hasRelation && oit.hasRelation()) {
+                        const relId = oit.getRelationId();
+                        const arraynode = createNode({
+                            nodeType: eNodeType.StructArray,
+                            name: `[${i + lower}]`,
+                            softdatatype: vte.softdatatype,
+                            accessId: i,
+                            vte
+                        });
+                        subnode.childs.push(arraynode);
+                        const relOb = findObjectByRelId(this.typeInfoObjects, relId);
+                        if (relOb) {
+                            const tcom = getTComSize(relOb, this.typeInfoObjects);
+                            arraynode.arrayAdrOffsetOpt = i * tcom;
+                            arraynode.arrayAdrOffsetNonOpt = i * tcom;
+                            this.addSubNodes(arraynode, relOb);
+                        }
+                    } else {
+                        const tcom = getSizeOfDatatype(vte);
+                        subnode.childs.push(createNode({
+                            nodeType: eNodeType.Array,
+                            name: `[${i + lower}]`,
+                            softdatatype: vte.softdatatype,
+                            accessId: i,
+                            vte,
+                            arrayAdrOffsetOpt: i * tcom,
+                            arrayAdrOffsetNonOpt: i * tcom
+                        }));
+                    }
+                }
+            } else if (oit && oit.isMDim && oit.isMDim()) {
+                this.addMdimArrayChildren(subnode, vte, oit);
+            } else if (oit && oit.hasRelation && oit.hasRelation() && !isPackedLeafDatatype(vte.softdatatype)) {
+                const relOb = findObjectByRelId(this.typeInfoObjects, oit.getRelationId());
+                if (relOb) this.addSubNodes(subnode, relOb);
+            }
+            // A packed leaf system type (e.g. DTL) keeps no children and is
+            // emitted as a single leaf symbol by buildFlatList.
+            elementIndex++;
+        }
+    }
+
+    addMdimArrayChildren(subnode, vte, oit) {
+        const arrayElementCount = oit.getArrayElementCount();
+        this._noteOversizedArray(arrayElementCount);
+        const cappedCount = this._cappedArrayCount(arrayElementCount);
+        const mdimCounts = oit.getMdimArrayElementCount();
+        const mdimLowers = oit.getMdimArrayLowerBounds();
+        let actdimensions = 0;
+        for (let d = 0; d < 6; d++) {
+            if (mdimCounts[d] > 0) actdimensions++;
+        }
+        const xx = [0, 0, 0, 0, 0, 0];
+        let n = 1;
+        let id = 0;
+        do {
+            let aname = '[';
+            for (let j = actdimensions - 1; j >= 0; j--) {
+                aname += (xx[j] + mdimLowers[j]).toString();
+                if (j > 0) aname += ',';
+                else aname += ']';
+            }
+            if (oit.hasRelation()) {
+                const relId = oit.getRelationId();
+                const arraynode = createNode({
+                    nodeType: eNodeType.StructArray,
+                    name: aname,
+                    softdatatype: vte.softdatatype,
+                    accessId: id,
+                    vte
+                });
+                subnode.childs.push(arraynode);
+                const relOb = findObjectByRelId(this.typeInfoObjects, relId);
+                if (relOb) {
+                    const tcom = getTComSize(relOb, this.typeInfoObjects);
+                    arraynode.arrayAdrOffsetOpt = (n - 1) * tcom;
+                    arraynode.arrayAdrOffsetNonOpt = (n - 1) * tcom;
+                    this.addSubNodes(arraynode, relOb);
+                }
+            } else {
+                const tcom = getSizeOfDatatype(vte);
+                subnode.childs.push(createNode({
+                    nodeType: eNodeType.Array,
+                    name: aname,
+                    softdatatype: vte.softdatatype,
+                    accessId: id,
+                    vte,
+                    arrayAdrOffsetOpt: (n - 1) * tcom,
+                    arrayAdrOffsetNonOpt: (n - 1) * tcom
+                }));
+            }
+            xx[0]++;
+            if (subnode.softdatatype === SOFTDATATYPE_BBOOL && xx[0] >= mdimCounts[0]) {
+                if (mdimCounts[0] % 8 !== 0) {
+                    id += 8 - (xx[0] % 8);
+                }
+            }
+            for (let dim = 0; dim < 5; dim++) {
+                if (xx[dim] >= mdimCounts[dim]) {
+                    xx[dim] = 0;
+                    xx[dim + 1]++;
+                }
+            }
+            id++;
+            n++;
+        } while (n <= cappedCount);
+    }
+}
+
+/**
+ * Enumerate the type relation ids a single type object references through
+ * its members. Mirrors the exact relation conditions FlatBrowser.addSubNodes
+ * uses to descend into nested types, so a transitive fetch of these ids
+ * yields every type object findObjectByRelId will later look up:
+ *   - 1-dim array member with a relation  -> element type relId
+ *   - m-dim array member with a relation  -> element type relId
+ *   - scalar member with a relation that is NOT a packed leaf (DTL) -> relId
+ * @param {object} typeOb - a type object carrying a vartypeList
+ * @returns {number[]} referenced relation ids (may contain duplicates/zeros)
+ */
+function collectReferencedRelIds(typeOb) {
+    const ids = [];
+    if (!typeOb || !typeOb.vartypeList || !typeOb.vartypeList.elements) return ids;
+    for (const vte of typeOb.vartypeList.elements) {
+        const oit = vte.offsetInfoType;
+        if (!oit) continue;
+        if (oit.is1Dim && oit.is1Dim()) {
+            if (oit.hasRelation && oit.hasRelation()) ids.push(oit.getRelationId());
+        } else if (oit.isMDim && oit.isMDim()) {
+            if (oit.hasRelation && oit.hasRelation()) ids.push(oit.getRelationId());
+        } else if (oit.hasRelation && oit.hasRelation() && !isPackedLeafDatatype(vte.softdatatype)) {
+            ids.push(oit.getRelationId());
+        }
+    }
+    return ids;
+}
+
+/**
+ * Build flat symbol list from DB roots + type-info container objects (C# Browse).
+ * @param {Array} dbList - from _fetchDbListFromPlc
+ * @param {object[]} typeInfoObjects - children of OMSTypeInfoContainer
+ * @param {object} [options]
+ * @param {number} [options.maxSymbols]
+ * @returns {{ symbols: object[], limitExceeded: boolean, maxSymbols: number|null }}
+ */
+function buildFlatSymbolList(dbList, typeInfoObjects, options = {}) {
+    const browser = new FlatBrowser(options);
+    browser.setTypeInfoContainerObjects(typeInfoObjects);
+    const scope = options.scope;
+    const scoped = scope && scope.everything === false;
+
+    for (const ed of dbList) {
+        browser.addBlockNode(eNodeType.Root, ed.db_name, ed.db_block_relid, ed.db_block_ti_relid);
+    }
+    for (const area of MEMORY_AREAS) {
+        if (scoped && !scope.areas.includes(area.name)) continue;
+        browser.addBlockNode(eNodeType.Root, area.name, area.accessId, area.tiRelId);
+    }
+    browser.buildTree();
+    return {
+        symbols: browser.buildFlatList(),
+        limitExceeded: browser.limitExceeded,
+        maxSymbols: browser.maxSymbols === Infinity ? null : browser.maxSymbols
+    };
+}
+
+module.exports = {
+    FlatBrowser,
+    buildFlatSymbolList,
+    findObjectByRelId,
+    collectReferencedRelIds
+};

package/node-red-contrib-s7-plus/lib/s7plus/browse/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { encodeNodeId, decodeNodeId } = require('./node-id');
+const { eNodeType, softdatatypeName, isSoftdatatypeSupported, getSizeOfDatatype } = require('./datatypes');
+const { ARRAY_PAGE_SIZE, listBlockRoots, listChildren, resolveLeaf, resolveTypeName } = require('./lazy');
+const { resolveSymbolicPath, parseSymbolSegments } = require('./resolve-symbolic');
+
+module.exports = {
+    encodeNodeId,
+    decodeNodeId,
+    eNodeType,
+    softdatatypeName,
+    isSoftdatatypeSupported,
+    getSizeOfDatatype,
+    ARRAY_PAGE_SIZE,
+    listBlockRoots,
+    listChildren,
+    resolveLeaf,
+    resolveTypeName,
+    resolveSymbolicPath,
+    parseSymbolSegments
+};