feat(eu-data-act): adopt 4 fixes from HA_VAG fork (sentinel filter, aliases, sum-fallback)

Cherry-picked from mikrohard/HA_VAG-EU-Data-Act (the active Cupra-specific
fork with substantially more curation than the original mikrohard repo).

#1 Sentinel value filtering (lib/euDataAct.js isSentinelReading)
   Portal emits 65535 / 2147483647 / 4294967295 when a sensor has no
   current reading, plus field-specific sentinels: -1 for
   remaining_charging_time, 0/1 for tyre_pressure_*. Without this an
   odometer can read 4 billion km and tyre pressure 0 bar. Filtered
   values are skipped entirely — better an absent state than garbage.

#4 Usability filter in the duplicate tie-break
   When the same dataFieldName arrives multiple times in one dataset, a
   usable reading now always beats a sentinel regardless of monotonic
   or last-occurrence semantics. Builds on #1.

#5 sum_fallback for cruising_range_combined
   PHEVs (Passat GTE, Golf GTE, Cupra Terramar) often leave the combined
   range empty while reporting cruising_range_primary_engine and
   cruising_range_secondary_engine individually. Fill the combined
   total from the two components, but only when the portal omits it.

#6 Field-name aliases
   remaining_climatisation_time -> remaining_climate_time
   charging_plug1_connectionstate -> plug_state
   Cupra Terramar PHEV uses non-standard names for these; aliasing keeps
   the state path consistent with ID.x cars so vis scripts work cross-
   model.

Verified with 9 test cases including the real VW_connect.json dataset:
mileage still resolves to 82 (the prior monotonic fix), sentinels are
filtered, aliases land at the canonical path, sum_fallback only fires
when the primary field is missing.

Explicitly NOT adopted from the fork:
- unit conversions (deci-kWh, hectometers) — risk of double-halving when
  a vehicle reports in normal units and our heuristic gets it wrong.
- value/state field renames — would break user scripts referencing
  existing state paths without migration.
- local dataset cache — ioBroker's history recorder already retains the
  last value across restarts.
- freshness-aware merge / escalating backoff — pure polish, no end-user
  data-correctness impact.

Author: TA2k

lib/euDataAct.js

@@ -324,12 +324,59 @@ const MONOTONIC_FIELDS = new Set([
   "mileage",
 ]);
 
+// Field-name aliases — some car models (Cupra Terramar PHEV, older Passat
+// GTE) ship semantically-equal data under different dataFieldNames. Map
+// them to the canonical name so a state path stays the same across models.
+// Ported from HA_VAG fork's _FIELD_ALIASES.
+const FIELD_ALIASES = {
+  remaining_climatisation_time: "remaining_climate_time",
+  charging_plug1_connectionstate: "plug_state",
+};
+
+// Sentinel integer values the portal emits when a sensor has no current
+// reading. Without filtering these reach the user-facing state as
+// "Odometer: 4,294,967,295 km" or "remaining charging time: 65,535 min".
+// Ported from HA_VAG fork's is_usable_reading (data.py:730-793).
+const GENERIC_INT_SENTINELS = new Set([65535, 2147483647, 4294967295]);
+// Field-specific sentinels: -1 from remaining_charging_time means
+// "unknown"; tyre_pressure_* uses 0/1 as protocol status codes instead of
+// real bar values (0 = invalid, 1 = warning, real pressures are >1.5).
+function isSentinelReading(value, fieldName) {
+  if (value === null || value === undefined || value === "") return true;
+  const num = typeof value === "number" ? value : parseFloat(value);
+  if (!Number.isFinite(num)) return false;
+  if (GENERIC_INT_SENTINELS.has(num)) return true;
+  if (
+    (fieldName === "remaining_charging_time" ||
+      fieldName === "remaining_charging_time_to_complete") &&
+    num === -1
+  ) {
+    return true;
+  }
+  if (typeof fieldName === "string" && fieldName.includes("tyre_pressure") && (num === 0 || num === 1)) {
+    return true;
+  }
+  return false;
+}
+
+// Field pairs to reconstruct when the primary is missing: a PHEV's
+// combined cruising range often arrives empty while both per-engine
+// components are populated. Sum them as a fallback. Portal value wins
+// when present. Ported from HA_VAG sum_fallback_fields.
+const SUM_FALLBACKS = [
+  {
+    target: "cruising_range_combined",
+    components: ["cruising_range_primary_engine", "cruising_range_secondary_engine"],
+  },
+];
+
 /**
  * Convert the flat `Data: [{key, dataFieldName, value}]` array into a nested
  * object keyed by the dotted dataFieldName, with values typed via the
  * dictionary.
  *
  * Tie-break across duplicates of the same dataFieldName:
+ *   - sentinel readings (65535, etc.) are skipped if any usable value exists.
  *   - 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
@@ -347,15 +394,28 @@ function normalizeDataset(payload) {
   for (const item of payload.Data || []) {
     if (!item || !item.key) continue;
     const meta = dictionary[item.key] || {};
-    const fieldName = item.dataFieldName || meta.name || item.key;
+    let fieldName = item.dataFieldName || meta.name || item.key;
     if (!fieldName) continue;
+    if (FIELD_ALIASES[fieldName]) fieldName = FIELD_ALIASES[fieldName];
     const sequence = seq++;
+    const itemIsSentinel = isSentinelReading(item.value, fieldName);
     if (!points[fieldName]) {
-      points[fieldName] = { keys: [item.key], item, meta, sequence };
+      points[fieldName] = { keys: [item.key], item, meta, sequence, sentinel: itemIsSentinel };
       continue;
     }
     const cur = points[fieldName];
     cur.keys.push(item.key);
+    // Usability filter: a usable reading always beats a sentinel, regardless
+    // of monotonic/last-occurrence semantics. A sentinel never overwrites a
+    // good reading. Two-sentinel or two-good fall through to normal tie-break.
+    if (cur.sentinel && !itemIsSentinel) {
+      cur.item = item;
+      cur.meta = meta;
+      cur.sequence = sequence;
+      cur.sentinel = false;
+      continue;
+    }
+    if (!cur.sentinel && itemIsSentinel) continue;
     if (MONOTONIC_FIELDS.has(fieldName)) {
       // Largest numeric value wins; sequence is only a tie-breaker for
       // equal values.
@@ -371,18 +431,25 @@ function normalizeDataset(payload) {
         cur.item = item;
         cur.meta = meta;
         cur.sequence = sequence;
+        cur.sentinel = itemIsSentinel;
       }
     } else if (sequence > cur.sequence) {
       // Last-occurrence wins.
       cur.item = item;
       cur.meta = meta;
       cur.sequence = sequence;
+      cur.sentinel = itemIsSentinel;
     }
   }
 
   const out = {};
   for (const fieldName of Object.keys(points)) {
-    const { item, meta } = points[fieldName];
+    const { item, meta, sentinel } = points[fieldName];
+    if (sentinel) {
+      // Skip writing — the only occurrences in the dataset were sentinels.
+      // Better an absent state than a 4-billion km odometer.
+      continue;
+    }
     let value = parseValue(item.value, meta.type);
     if ((meta.type || "").toLowerCase() === "enum" && typeof value === "number" && meta.description) {
       // Enum fields occasionally deliver the protobuf integer index instead
@@ -397,6 +464,27 @@ function normalizeDataset(payload) {
     }
     setNested(out, fieldName, value);
   }
+
+  // sum_fallback: PHEV combined range frequently arrives empty while both
+  // per-engine components are present. Reconstruct so users don't see
+  // "unknown" for total range. Portal value wins when present (we only
+  // fill if the target is still missing after the normal pass).
+  for (const fallback of SUM_FALLBACKS) {
+    if (points[fallback.target]) continue;
+    let sum = 0;
+    let any = false;
+    for (const c of fallback.components) {
+      const p = points[c];
+      if (!p || p.sentinel) continue;
+      const n = parseFloat(p.item.value);
+      if (Number.isFinite(n)) {
+        sum += n;
+        any = true;
+      }
+    }
+    if (any) setNested(out, fallback.target, sum);
+  }
+
   out._meta = {
     vin: payload.vin || null,
     user_id: payload.user_id || null,