fix(eu-data-act): mileage stuck at lower of two reported values

Real-world dataset (VW_connect.json) showed VW emitting two mileage.value
slots in the same /list payload:

  idx=11  uuid=69d437d3...  value=82  (current odometer)
  idx=60  uuid=30cc36fd...  value=71  (lagging snapshot from older report)

The previous 'smallest UUID wins' tie-break inherited from the original
HA reference picked 30cc36fd → state stayed at 71 even after a fresh
download. Tibber and the in-car display showed 82; the adapter would
not update until the lagging UUID disappeared from the portal (didn't
happen on its own, even across Adapter Stop/Start).

Fix mirrors what mikrohard/HA_VAG-EU-Data-Act does in its fork:
- Generic case: pick the LAST occurrence in the ZIP array. The portal
  bundles minute-level snapshots in array order, so the last duplicate
  is the best proxy for the freshest value.
- Monotonic fields (mileage.value, mileage): pick the LARGEST numeric
  value. Lagging snapshots can never read higher than the true current
  odometer, so the max is correct by construction. Sequence number ties
  break equal values.

Verified against the user's real dataset:
  before fix: mileage.value = 71
  after fix:  mileage.value = 82 (correct)

No timestampUtc per item to read (verified: 0 / 113 items in the sample
carry one), so we don't use the timestamp-based ranking the HA fork
adds — array position is the only signal available.

Author: TA2k

lib/euDataAct.js

@@ -315,31 +315,68 @@ function extractVins(payload) {
 
 // --- raw data points -> structured object (for json2iob) -------------------
 
+// Field names that are monotonic non-decreasing — for these the largest
+// numeric value across duplicates is the freshest reading. Mirrors the
+// HA_VAG-EU-Data-Act fork's `monotonic` curated flag. Lagging report
+// snapshots in the same dataset can otherwise make the odometer read low.
+const MONOTONIC_FIELDS = new Set([
+  "mileage.value",
+  "mileage",
+]);
+
 /**
  * Convert the flat `Data: [{key, dataFieldName, value}]` array into a nested
  * object keyed by the dotted dataFieldName, with values typed via the
- * dictionary. When the same field name appears multiple times (the portal
- * merges several report snapshots into one array), we keep the entry with the
- * smallest UUID — same arbitrary-but-stable choice as the HA reference, so a
- * sensor consistently tracks the same point across refreshes.
+ * dictionary.
+ *
+ * Tie-break across duplicates of the same dataFieldName:
+ *   - monotonic fields (e.g. mileage.value): pick the LARGEST numeric value.
+ *     The portal mixes several report snapshots into one array; older
+ *     snapshots lag the current odometer by a few km, so the max is the
+ *     truest live reading.
+ *   - everything else: pick the LAST occurrence in the ZIP (array order).
+ *     Per the HA_VAG-EU-Data-Act analysis the portal bundles minute-level
+ *     snapshots in array order, so the last duplicate is the best proxy for
+ *     the freshest value. The earlier "smallest UUID" tie-break was stable
+ *     but arbitrary and consistently picked stale values for mileage.
  */
 function normalizeDataset(payload) {
   const dictionary = loadDictionary();
   const points = {};
+  let seq = 0;
   for (const item of payload.Data || []) {
     if (!item || !item.key) continue;
     const meta = dictionary[item.key] || {};
     const fieldName = item.dataFieldName || meta.name || item.key;
     if (!fieldName) continue;
+    const sequence = seq++;
     if (!points[fieldName]) {
-      points[fieldName] = { keys: [item.key], item, meta };
+      points[fieldName] = { keys: [item.key], item, meta, sequence };
       continue;
     }
     const cur = points[fieldName];
     cur.keys.push(item.key);
-    if (item.key < cur.item.key) {
+    if (MONOTONIC_FIELDS.has(fieldName)) {
+      // Largest numeric value wins; sequence is only a tie-breaker for
+      // equal values.
+      const a = parseFloat(item.value);
+      const b = parseFloat(cur.item.value);
+      const aNum = Number.isFinite(a);
+      const bNum = Number.isFinite(b);
+      let take = false;
+      if (aNum && !bNum) take = true;
+      else if (aNum && bNum && a > b) take = true;
+      else if (aNum && bNum && a === b && sequence > cur.sequence) take = true;
+      if (take) {
+        cur.item = item;
+        cur.meta = meta;
+        cur.sequence = sequence;
+      }
+    } else if (sequence > cur.sequence) {
+      // Last-occurrence wins.
       cur.item = item;
       cur.meta = meta;
+      cur.sequence = sequence;
     }
   }