@bytebrand/export-cars 1.26.18 → 1.26.19-hotfix.2

package/src/transformers/auto24.transfomer.ts

@@ -41,7 +41,8 @@ export class Auto24Transformer {
       fueltype: this.translateSelector(get(car, 'consumption.fuel', '')),
       consumptionK: toString(get(car, 'consumption.consumptionCombined', '')),
       co2: toString(get(car, 'environmentEmissions.co2', '')),
-      efficiencyclass: this.translateSelector(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
+      // ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
+      efficiencyclass: this.translateSelector(get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', '')),
       image: transformedImages[0],
       registration: this.getRegistrationField(get(car, 'mainData.firstRegistration') as number),
       images: transformedImages,

package/src/transformers/autouncle.transformer.ts

@@ -68,7 +68,8 @@ export class AutouncleTransformer {
       images: transformed_images,
       fuel_economy: toString(get(car, 'consumption.consumptionCombined', '')),
       co2_emission: toString(get(car, 'environmentEmissions.co2', '')),
-      co2_effiency_class: toString(get(car, 'environmentEmissions.energyEfficiencyClass', '')),
+      // ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
+      co2_effiency_class: toString(get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', '')),
       euro_emission_class: toString(get(car, 'environmentEmissions.emissionClass', '')),
       enviromental_sticker: toString(get(car, 'environmentEmissions.emissionSticker', '')),
     };

package/src/transformers/awin.transformer.ts

@@ -171,7 +171,8 @@ export class AwinTransformer {
             selector_energyEfficiencyClass_g: 'G',
             selector_unknown: '',
         };
-        const energyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+        // ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
+        const energyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
         return get(available, energyClass);
     }
 

package/src/transformers/criteo.transformer.ts

@@ -140,7 +140,8 @@ export class CriteoTransformer {
 			selector_energyEfficiencyClass_g: 'G',
 			selector_unknown: 'default',
 		};
-		const energyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+		// ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
+		const energyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
 		return get(available, energyClass);
 	}
 

package/src/transformers/fb.transformer.ts

@@ -413,6 +413,9 @@ export class FbTransformer {
     return get(car, 'state.isOnline', false) ? 'available' : 'not_available';
   }
 
+  // ADV-187: no fabricated class for an unknown value — the field previously
+  // defaulted every unresolved car to 'G' (worst class), which is a
+  // false/misleading statement, not a "no data" state. Empty string here.
   private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
     const available = {
       selector_energyEfficiencyClass_appp: 'A+',
@@ -425,10 +428,10 @@ export class FbTransformer {
       selector_energyEfficiencyClass_e: 'E',
       selector_energyEfficiencyClass_f: 'F',
       selector_energyEfficiencyClass_g: 'G',
-      selector_unknown: 'G',
+      selector_unknown: '',
     };
     const energyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
-    return get(available, energyClass);
+    return get(available, energyClass, '');
   }
 
   private getMileage(car: DataSchemes.Car): number {

package/src/transformers/google-feed-envkv.ts

@@ -0,0 +1,168 @@
+import { get } from 'lodash';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+// Google vehicle ads `engine`: gasoline, diesel, electric, hybrid, lpg, methane, natural_gas,
+// plug-in_hybrid, other (https://support.google.com/merchants/answer/14156068). Any other value
+// is rejected as "Missing attribute [engine]" — CarGas / NaturalGas did that for ~290 items.
+const GOOGLE_ENGINE: Record<string, string> = {
+  selector_fuel_petrol: 'Gasoline',
+  selector_fuel_diesel: 'Diesel',
+  selector_fuel_electrical: 'Electric',
+  selector_fuel_hybridElectricalPetrol: 'Hybrid',
+  selector_fuel_hybridElectricalDiesel: 'Hybrid',
+  selector_fuel_carGas: 'lpg',
+  selector_fuel_naturalGas: 'natural_gas',
+  selector_fuel_ethanol: 'other',
+  selector_fuel_hydrogen: 'other',
+  selector_unknown: 'other',
+};
+
+const HYBRID_FUELS = ['selector_fuel_hybridElectricalPetrol', 'selector_fuel_hybridElectricalDiesel'];
+
+const positive = (value: unknown): number | undefined => {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+};
+
+const isBev = (car: DataSchemes.Car): boolean => get(car, 'consumption.fuel') === 'selector_fuel_electrical';
+const isPlugIn = (car: DataSchemes.Car): boolean =>
+  HYBRID_FUELS.includes(get(car, 'consumption.fuel')) && !!get(car, 'engineData.hybridPlugin');
+
+export function googleEngine(car: DataSchemes.Car): string {
+  const engine = GOOGLE_ENGINE[get(car, 'consumption.fuel', 'selector_unknown')] || 'other';
+  return engine === 'Hybrid' && get(car, 'engineData.hybridPlugin') ? 'plug-in_hybrid' : engine;
+}
+
+// BEV: combined WLTP range (CoC 49.2). Plug-in: the EAER (`wltpTotalRange`, CoC 49.5) when present,
+// else the range the dealer delivered. City ranges are never used; 0 counts as missing.
+const BEV_RANGE_FIELDS = ['battery.wltpRange', 'battery.batteryRangeElectric'];
+const PLUG_IN_RANGE_FIELDS = ['battery.wltpTotalRange', 'battery.wltpRange', 'battery.batteryRangeElectric'];
+
+const pickElectricRange = (car: DataSchemes.Car): { field: string; range: number } | undefined => {
+  const fields = isBev(car) ? BEV_RANGE_FIELDS : isPlugIn(car) ? PLUG_IN_RANGE_FIELDS : [];
+  for (const field of fields) {
+    const range = positive(get(car, field));
+    if (range) return { field, range };
+  }
+  return undefined;
+};
+
+export function googleElectricRange(car: DataSchemes.Car): string | undefined {
+  const picked = pickElectricRange(car);
+  return picked ? `${picked.range}km` : undefined;
+}
+
+// The car field googleElectricRange took its value from (feed audit), null when nothing is sent.
+export function googleElectricRangeSource(car: DataSchemes.Car): string | null {
+  return pickElectricRange(car)?.field ?? null;
+}
+
+// Plug-in hybrids: Google and Pkw-EnVKV (CoC 49.4) want the WEIGHTED combined values for fuel,
+// electricity and CO2, and the fuel consumption with a DISCHARGED battery separately. In CBD those
+// are wltpWeightedCombined, wltpWeightedPowerCombined, wltpCo2 (weighted for a plug-in) and
+// wltpCombined (discharged for a plug-in); the legacy consumptionCombined / co2 are only a fallback.
+//
+// engineData.hybridPlugin alone does not prove a plug-in: since ADV-124 every hybrid carries it, and
+// the weighted fields of hybrids without an electric range are enrichment-sheet templates
+// (prod 07.10: 4,178 of 5,576 flagged cars, e.g. 2.3 l + 21.5 kWh + 195 g). Only a hybrid with an
+// electric range counts as a confirmed plug-in; the others keep the values sent before.
+const isConfirmedPlugIn = (car: DataSchemes.Car): boolean => isPlugIn(car) && !!googleElectricRange(car);
+
+// Missing or 0 is omitted instead of sending "0l/100km". BEVs carry no fuel consumption
+// (CBD mirrors kWh into consumptionCombined for them).
+//
+// Each attribute is picked from the first positive field of a list; the pick keeps the field so the
+// publication gate (EnVKV C8) can tell whether the sent value was estimated by CBD.
+interface Picked {
+  field: string;
+  value: number;
+}
+
+const firstPositive = (car: DataSchemes.Car, fields: string[]): Picked | undefined => {
+  for (const field of fields) {
+    const value = positive(get(car, field));
+    if (value) return { field, value };
+  }
+  return undefined;
+};
+
+const pickFuelConsumption = (car: DataSchemes.Car): Picked | undefined => {
+  if (isBev(car)) return undefined;
+  if (isConfirmedPlugIn(car)) return firstPositive(car, ['consumption.wltpWeightedCombined', 'consumption.consumptionCombined']);
+  if (isPlugIn(car)) return firstPositive(car, ['consumption.consumptionCombined']); // unconfirmed plug-in: as before
+  // ICE / HEV: the WLTP combined value the VDP and EnVKV use (EnVKV stage D3), the legacy field as fallback
+  return firstPositive(car, ['consumption.wltpCombined', 'consumption.consumptionCombined']);
+};
+
+// Confirmed plug-in: wltpCombined, no fallback (the legacy combined value is close to the weighted
+// one, sending it here would repeat the weighted figure). Unconfirmed plug-in: the stored combined
+// value, as before.
+const pickFuelConsumptionDischarged = (car: DataSchemes.Car): Picked | undefined => {
+  if (!isPlugIn(car)) return undefined;
+  return isConfirmedPlugIn(car)
+    ? firstPositive(car, ['consumption.wltpCombined'])
+    : firstPositive(car, ['consumption.consumptionCombined', 'consumption.wltpCombined']);
+};
+
+// BEV: combined consumption. Confirmed plug-in: weighted combined. Unconfirmed plug-in: the stored
+// electric value, as before. Nothing for other cars.
+const pickEnergyConsumption = (car: DataSchemes.Car): Picked | undefined => {
+  if (isConfirmedPlugIn(car)) return firstPositive(car, ['consumption.wltpWeightedPowerCombined']);
+  if (isBev(car) || isPlugIn(car)) return firstPositive(car, ['consumption.wltpPowerCombined', 'consumption.consumptionPowerCombined']);
+  return undefined;
+};
+
+// A BEV emits 0 g/km by definition (no field behind it); a confirmed plug-in and ICE / HEV send the
+// WLTP value (weighted for the plug-in); an unconfirmed plug-in keeps the stored legacy value, as before.
+const pickCo2 = (car: DataSchemes.Car): Picked | undefined => {
+  if (isBev(car)) return undefined;
+  return isPlugIn(car) && !isConfirmedPlugIn(car)
+    ? firstPositive(car, ['environmentEmissions.co2'])
+    : firstPositive(car, ['environmentEmissions.wltpCo2', 'environmentEmissions.co2']);
+};
+
+export function googleFuelConsumption(car: DataSchemes.Car): string | undefined {
+  const picked = pickFuelConsumption(car);
+  return picked ? `${picked.value}l/100km` : undefined;
+}
+
+export function googleFuelConsumptionDischarged(car: DataSchemes.Car): string | undefined {
+  const picked = pickFuelConsumptionDischarged(car);
+  return picked ? `${picked.value}l/100km` : undefined;
+}
+
+export function googleEnergyConsumption(car: DataSchemes.Car): string | undefined {
+  const picked = pickEnergyConsumption(car);
+  return picked ? `${picked.value}kWh/100km` : undefined;
+}
+
+// A missing or 0 value is omitted.
+export function googleCo2(car: DataSchemes.Car): string | undefined {
+  if (isBev(car)) return '0g/km';
+  const picked = pickCo2(car);
+  return picked ? `${picked.value}g/km` : undefined;
+}
+
+// The EnVKV attributes of the Google item (keys of GoogleXmlItem).
+export type GoogleEnvkvAttribute =
+  | 'fuel_consumption'
+  | 'fuel_consumption_discharged_battery'
+  | 'energy_consumption'
+  | 'electric_range'
+  | 'co2_emissions';
+
+// For every EnVKV attribute the item sends: the car field its value came from.
+export function googleEnvkvSourceFields(car: DataSchemes.Car): Partial<Record<GoogleEnvkvAttribute, string>> {
+  const picks: Record<GoogleEnvkvAttribute, { field: string } | undefined> = {
+    fuel_consumption: pickFuelConsumption(car),
+    fuel_consumption_discharged_battery: pickFuelConsumptionDischarged(car),
+    energy_consumption: pickEnergyConsumption(car),
+    electric_range: pickElectricRange(car),
+    co2_emissions: pickCo2(car),
+  };
+  const fields: Partial<Record<GoogleEnvkvAttribute, string>> = {};
+  for (const [attribute, picked] of Object.entries(picks)) {
+    if (picked) fields[attribute as GoogleEnvkvAttribute] = picked.field;
+  }
+  return fields;
+}

package/src/transformers/google-feed-item-row.ts

@@ -0,0 +1,78 @@
+import { get, isBoolean } from 'lodash';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { GoogleXmlItem } from '../interfaces';
+import { googleElectricRangeSource } from './google-feed-envkv';
+
+// One BigQuery row per item the Google feed sent (schema/feed-items.json), so a Merchant Center
+// issue can be traced back to the exact values of a run. The attribute strings are the ones in the
+// XML; null means the attribute was omitted.
+export interface FeedItemRow {
+  partitionDay: string;
+  exportedAt: string;
+  feed: string;
+  runId: string | null;
+  itemId: string;
+  vehicleId: string | null;
+  make: string | null;
+  model: string | null;
+  condition: string | null;
+  fuel: string | null;
+  hybridPlugin: boolean | null;
+  engine: string | null;
+  electricRange: string | null;
+  fuelConsumption: string | null;
+  fuelConsumptionDischarged: string | null;
+  energyConsumption: string | null;
+  co2Emissions: string | null;
+  rangeSourceField: string | null;
+  price: number | null;
+  availability: string | null;
+  // EnVKV C8: gate mode of the run and the attributes whose value CBD estimated (comma-separated);
+  // in enforce mode these attributes were left out of the item.
+  publicationGate: string | null;
+  estimatedAttributes: string | null;
+}
+
+const orNull = (value: unknown): string | null =>
+  value === undefined || value === null || value === '' ? null : String(value);
+
+// "12345.5 EUR" -> 12345.5
+const sentPrice = (price: string | undefined): number | null => {
+  const n = parseFloat(price);
+  return Number.isFinite(n) ? n : null;
+};
+
+// exportedAt is the run's start, shared by all rows of a run; partitionDay is its UTC day.
+export function buildGoogleFeedItemRow(
+  car: DataSchemes.Car,
+  item: GoogleXmlItem,
+  runId: string | null,
+  exportedAt: Date,
+  gate: { mode: string; estimatedAttributes: string[] } | null = null,
+): FeedItemRow {
+  const hybridPlugin = get(car, 'engineData.hybridPlugin');
+  return {
+    partitionDay: exportedAt.toISOString().slice(0, 10),
+    exportedAt: exportedAt.toISOString(),
+    feed: 'google',
+    runId: orNull(runId),
+    itemId: String(item.id),
+    vehicleId: orNull(get(car, 'metaData.vehicleId')),
+    make: orNull(item.brand),
+    model: orNull(item.model),
+    condition: orNull(item.condition),
+    fuel: orNull(get(car, 'consumption.fuel')),
+    hybridPlugin: isBoolean(hybridPlugin) ? hybridPlugin : null,
+    engine: orNull(item.engine),
+    electricRange: orNull(item.electric_range),
+    fuelConsumption: orNull(item.fuel_consumption),
+    fuelConsumptionDischarged: orNull(item.fuel_consumption_discharged_battery),
+    energyConsumption: orNull(item.energy_consumption),
+    co2Emissions: orNull(item.co2_emissions),
+    rangeSourceField: item.electric_range ? googleElectricRangeSource(car) : null,
+    price: sentPrice(item.price),
+    availability: orNull(item.availability),
+    publicationGate: gate ? gate.mode : null,
+    estimatedAttributes: gate && gate.estimatedAttributes.length ? gate.estimatedAttributes.join(',') : null,
+  };
+}

package/src/transformers/google.transformer.ts

@@ -8,6 +8,14 @@ import { Injectable } from '@nestjs/common';
 import { ConfigService, ImagesService, MappingService, TransformerService, UserService } from '../services';
 import { GoogleXmlItem } from '../interfaces';
 import { isValidVin } from '../utils';
+import {
+  googleCo2,
+  googleElectricRange,
+  googleEnergyConsumption,
+  googleEngine,
+  googleFuelConsumption,
+  googleFuelConsumptionDischarged,
+} from './google-feed-envkv';
 import {
   META_PUSH_PRIORITY_ALLOWED_VALUES,
   META_PUSH_PRIORITY_STANDARD,
@@ -85,17 +93,17 @@ export class GoogleTransformer {
       color: this.getColor(car),
       vehicle_option: this.getExtrasField(car),
       body_style: this.mapBodyStyle(car),
-      engine: this.mapFuel(car),
+      engine: googleEngine(car),
       transmission: this.mapTransmission(car),
       drive: this.mapDrive(car),
       doors: this.getDoors(car),
       capacity: this.getCapacity(car),
       date_first_registered: this.getDateFirstRegistered(car),
-      fuel_consumption: `${this.transformService.fuelConsumption(car)}l/100km`,
-      energy_consumption: this.getEnergyConsumption(car),
-      electric_range: this.getElectricRange(car),
-      fuel_consumption_discharged_battery: this.getFuelConsumptionDischargedBattery(car),
-      co2_emissions: `${this.transformService.cO2Emission(car)}g/km`,
+      fuel_consumption: googleFuelConsumption(car),
+      energy_consumption: googleEnergyConsumption(car),
+      electric_range: googleElectricRange(car),
+      fuel_consumption_discharged_battery: googleFuelConsumptionDischarged(car),
+      co2_emissions: googleCo2(car),
       description: this.processText((await this.getDescription(car))),
       identifier_exists: 'yes',
       availability: 'in_stock',
@@ -121,6 +129,8 @@ export class GoogleTransformer {
       'certification',
       'energy_consumption',
       'electric_range',
+      'fuel_consumption',
+      'co2_emissions',
       'fuel_consumption_discharged_battery',
       'installment',
       'body_style',
@@ -288,8 +298,15 @@ export class GoogleTransformer {
     return value ? value.replace(/\+/g, '') : '';
   }
 
+  // ADV-187: the canonical (legally defined, CO2-derived) class lives in
+  // wltpEnergyEfficiencyClass — same field the website, PDF exposé and the
+  // Facebook feed use. The legacy NEFZ `energyEfficiencyClass` is a different
+  // (mass-relative) scale and is NOT validated against CO2, so it must not
+  // feed the BMWK Vehicle_CO2_Class certification. No fallback to the legacy
+  // field on purpose: an unknown WLTP class omits the certification instead of
+  // publishing an unvalidated one.
   private getEnergyClass(car: DataSchemes.Car): string {
-    return this.mapEnergyClass(get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown'));
+    return this.mapEnergyClass(get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown'));
   }
 
   private getDischargedEnergyClass(car: DataSchemes.Car): string {
@@ -322,30 +339,8 @@ export class GoogleTransformer {
     return certifications.length ? certifications : undefined;
   }
 
-  private getEnergyConsumption(car: DataSchemes.Car): string | undefined {
-    const fuel = get(car, 'consumption.fuel');
-    const isElectricOrHybrid =
-      ['selector_fuel_electrical', 'selector_fuel_hybridElectricalPetrol', 'selector_fuel_hybridElectricalDiesel'].includes(fuel) ||
-      !!get(car, 'engineData.hybridPlugin');
-    if (!isElectricOrHybrid) {
-      return undefined;
-    }
-    const power = get(car, 'consumption.wltpPowerCombined') || get(car, 'consumption.consumptionPowerCombined');
-    return power ? `${power}kWh/100km` : undefined;
-  }
 
-  private getElectricRange(car: DataSchemes.Car): string | undefined {
-    const range = get(car, 'battery.batteryRangeElectric') || get(car, 'battery.wltpRange');
-    return range ? `${range}km` : undefined;
-  }
 
-  private getFuelConsumptionDischargedBattery(car: DataSchemes.Car): string | undefined {
-    if (!get(car, 'engineData.hybridPlugin')) {
-      return undefined;
-    }
-    const consumption = get(car, 'consumption.consumptionCombined') || get(car, 'consumption.wltpCombined');
-    return consumption ? `${consumption}l/100km` : undefined;
-  }
 
   private getInstallment(car: DataSchemes.Car) {
     const monthlyInstallment = round(get(car, 'rate.monthlyInstallment', null));
@@ -379,27 +374,6 @@ export class GoogleTransformer {
     }
   }
 
-  private mapFuel(car: DataSchemes.Car): string {
-    const available = {
-      selector_fuel_petrol: 'Gasoline',
-      selector_fuel_diesel: 'Diesel',
-      selector_fuel_electrical: 'Electric',
-      selector_fuel_hybridElectricalPetrol: 'Hybrid',
-      selector_fuel_hybridElectricalDiesel: 'Hybrid',
-      selector_fuel_carGas: 'CarGas',
-      selector_fuel_naturalGas: 'NaturalGas',
-      selector_fuel_ethanol: 'Ethanol',
-      selector_fuel_hydrogen: 'Hydrogen',
-      selector_unknown: 'Other',
-    };
-    const fuel = get(car, 'consumption.fuel', 'selector_unknown');
-    let engine = get(available, fuel, 'Other')
-    const hybridPlugin = car?.engineData?.hybridPlugin;
-    if (engine === 'Hybrid' && hybridPlugin)
-      engine = 'plug-in_hybrid';
-
-    return engine;
-  }
 
   private mapBodyStyle(car: DataSchemes.Car): string {
     const available = {

package/src/transformers/mobile.transformer.ts

@@ -258,8 +258,11 @@ export class MobileTransformer {
     }
   }
 
+  // ADV-187: export the canonical CO2-derived WLTP class (not the unvalidated
+  // legacy NEFZ class) and never invent one — an unknown class is exported
+  // empty instead of the former hard-coded 'C'.
   private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
-    const energyEfficiencyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+    const energyEfficiencyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
     switch (energyEfficiencyClass) {
       case 'selector_energyEfficiencyClass_appp': {
         return 'A+++';
@@ -271,8 +274,9 @@ export class MobileTransformer {
         return 'A+';
       }
       case 'selector_unknown':
+      case undefined:
       case null: {
-        return 'C';
+        return '';
       }
       default: {
         return energyEfficiencyClass.slice(-1).toUpperCase();

package/src/transformers/rubrikk.transformer.ts

@@ -148,7 +148,8 @@ export class RubrikkTransformer {
       selector_energyEfficiencyClass_g: 'G',
       selector_unknown: 'default',
     };
-    const energyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+    // ADV-187: canonical CO2-derived WLTP class, not the unvalidated legacy NEFZ class.
+    const energyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
     return get(available, energyClass);
   }
 

package/src/transformers/santander.transformer.ts

@@ -364,8 +364,11 @@ export class SantanderTransformer {
 		}
 	}
 
+	// ADV-187: export the canonical CO2-derived WLTP class (not the unvalidated
+	// legacy NEFZ class) and never invent one — an unknown class is exported
+	// empty instead of the former hard-coded 'C'.
 	private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
-		const energyEfficiencyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+		const energyEfficiencyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
 		switch (energyEfficiencyClass) {
 			case 'selector_energyEfficiencyClass_appp': {
 				return 'A+++';
@@ -377,8 +380,9 @@ export class SantanderTransformer {
 				return 'A+';
 			}
 			case 'selector_unknown':
+			case undefined:
 			case null: {
-				return 'C';
+				return '';
 			}
 			default: {
 				return energyEfficiencyClass.slice(-1).toUpperCase();

package/test/google-feed-envkv.test.ts

@@ -0,0 +1,132 @@
+// Run: npm test (ts-node, no test framework needed)
+import * as assert from 'node:assert/strict';
+import {
+  googleCo2,
+  googleElectricRange,
+  googleEnergyConsumption,
+  googleEngine,
+  googleFuelConsumption,
+  googleFuelConsumptionDischarged,
+} from '../src/transformers/google-feed-envkv';
+
+const car = (fuel: string, extra: Record<string, unknown> = {}): any => ({
+  consumption: { fuel, ...(extra.consumption as object) },
+  engineData: { hybridPlugin: extra.hybridPlugin },
+  battery: extra.battery || {},
+  environmentEmissions: extra.environmentEmissions || {},
+});
+
+const cases: Array<[string, () => void]> = [
+  ['LPG and CNG get the values Google accepts', () => {
+    assert.equal(googleEngine(car('selector_fuel_carGas')), 'lpg');
+    assert.equal(googleEngine(car('selector_fuel_naturalGas')), 'natural_gas');
+  }],
+  ['ethanol, hydrogen and unknown fuels become other', () => {
+    assert.equal(googleEngine(car('selector_fuel_ethanol')), 'other');
+    assert.equal(googleEngine(car('selector_fuel_hydrogen')), 'other');
+    assert.equal(googleEngine(car('selector_fuel_somethingNew')), 'other');
+  }],
+  ['existing engine values are unchanged', () => {
+    assert.equal(googleEngine(car('selector_fuel_petrol')), 'Gasoline');
+    assert.equal(googleEngine(car('selector_fuel_diesel')), 'Diesel');
+    assert.equal(googleEngine(car('selector_fuel_electrical')), 'Electric');
+    assert.equal(googleEngine(car('selector_fuel_hybridElectricalPetrol')), 'Hybrid');
+    assert.equal(googleEngine(car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true })), 'plug-in_hybrid');
+  }],
+  ['BEV range is the combined WLTP range, never the city range', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRange: 451, wltpRangeCity: 590 } })), '451km');
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRangeCity: 590 } })), undefined);
+  }],
+  ['plug-in range prefers the EAER, then the delivered range', () => {
+    const phev = (battery: object) => car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true, battery });
+    assert.equal(googleElectricRange(phev({ wltpTotalRange: 62, wltpRange: 59 })), '62km');
+    assert.equal(googleElectricRange(phev({ wltpTotalRange: 0, wltpRange: 59 })), '59km');
+    assert.equal(googleElectricRange(phev({ wltpTotalRangeCity: 70 })), undefined);
+  }],
+  ['a range of 0 counts as missing', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRange: 0 } })), undefined);
+  }],
+  ['no range for combustion cars or non-plug-in hybrids', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_petrol', { battery: { wltpRange: 50 } })), undefined);
+    assert.equal(googleElectricRange(car('selector_fuel_hybridElectricalPetrol', { battery: { wltpRange: 50 } })), undefined);
+  }],
+  ['missing or 0 fuel consumption is omitted, never "0l/100km"', () => {
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol', { consumption: { consumptionCombined: 0 } })), undefined);
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol')), undefined);
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol', { consumption: { consumptionCombined: 6.3 } })), '6.3l/100km');
+  }],
+  ['BEVs send no fuel consumption (CBD mirrors kWh into it)', () => {
+    assert.equal(googleFuelConsumption(car('selector_fuel_electrical', { consumption: { consumptionCombined: 18 } })), undefined);
+  }],
+  ['CO2: BEV is 0 g/km, other cars omit a missing or 0 value', () => {
+    assert.equal(googleCo2(car('selector_fuel_electrical')), '0g/km');
+    assert.equal(googleCo2(car('selector_fuel_petrol', { environmentEmissions: { co2: 0 } })), undefined);
+    assert.equal(googleCo2(car('selector_fuel_petrol', { environmentEmissions: { co2: 144 } })), '144g/km');
+  }],
+  ['plug-in: weighted fuel, discharged fuel, weighted electricity and weighted CO2', () => {
+    const phev = car('selector_fuel_hybridElectricalPetrol', {
+      hybridPlugin: true,
+      battery: { wltpTotalRange: 62 },
+      consumption: { consumptionCombined: 1.4, wltpCombined: 6.3, wltpWeightedCombined: 1.2, wltpPowerCombined: 19.3, wltpWeightedPowerCombined: 17.3 },
+      environmentEmissions: { co2: 121, wltpCo2: 28 },
+    });
+    assert.equal(googleFuelConsumption(phev), '1.2l/100km');
+    assert.equal(googleFuelConsumptionDischarged(phev), '6.3l/100km');
+    assert.equal(googleEnergyConsumption(phev), '17.3kWh/100km');
+    assert.equal(googleCo2(phev), '28g/km');
+  }],
+  ['plug-in without weighted values falls back to the legacy combined ones, never the pure-electric value', () => {
+    const phev = car('selector_fuel_hybridElectricalPetrol', {
+      hybridPlugin: true,
+      battery: { wltpRange: 59 },
+      consumption: { consumptionCombined: 1.4, wltpPowerCombined: 19.3 },
+      environmentEmissions: { co2: 32 },
+    });
+    assert.equal(googleFuelConsumption(phev), '1.4l/100km');
+    assert.equal(googleFuelConsumptionDischarged(phev), undefined);
+    assert.equal(googleEnergyConsumption(phev), undefined);
+    assert.equal(googleCo2(phev), '32g/km');
+  }],
+  ['non-plug-in hybrids and combustion cars send the WLTP values (legacy as fallback) and no electricity', () => {
+    const hev = car('selector_fuel_hybridElectricalPetrol', {
+      consumption: { consumptionCombined: 5.1, wltpCombined: 5.3, wltpWeightedCombined: 2.3, wltpWeightedPowerCombined: 21.5 },
+      environmentEmissions: { co2: 116, wltpCo2: 119 },
+    });
+    assert.equal(googleFuelConsumption(hev), '5.3l/100km');
+    assert.equal(googleFuelConsumptionDischarged(hev), undefined);
+    assert.equal(googleEnergyConsumption(hev), undefined);
+    assert.equal(googleCo2(hev), '119g/km');
+    // D3: Mercedes GLC 200 sent 146.7 g (legacy) while CBD / VDP / EnVKV hold the dealer's WLTP 138 g
+    const glc = car('selector_fuel_diesel', { consumption: { consumptionCombined: 5.6, wltpCombined: 5.2 }, environmentEmissions: { co2: 146.7, wltpCo2: 138 } });
+    assert.equal(googleCo2(glc), '138g/km');
+    assert.equal(googleFuelConsumption(glc), '5.2l/100km');
+    assert.equal(googleCo2(car('selector_fuel_diesel', { environmentEmissions: { co2: 150 } })), '150g/km');
+  }],
+  ['a plug-in flag without an electric range keeps the stored values (ADV-124 flags every hybrid)', () => {
+    const flagged = car('selector_fuel_hybridElectricalPetrol', {
+      hybridPlugin: true,
+      consumption: { consumptionCombined: 5.1, wltpCombined: 5.3, wltpWeightedCombined: 2.3, wltpPowerCombined: 21.5, wltpWeightedPowerCombined: 21.5 },
+      environmentEmissions: { co2: 116, wltpCo2: 116, wltpCo2Discharged: 195 },
+    });
+    assert.equal(googleFuelConsumption(flagged), '5.1l/100km');
+    assert.equal(googleFuelConsumptionDischarged(flagged), '5.1l/100km');
+    assert.equal(googleEnergyConsumption(flagged), '21.5kWh/100km');
+    assert.equal(googleCo2(flagged), '116g/km');
+  }],
+  ['BEV energy consumption is the combined value', () => {
+    assert.equal(googleEnergyConsumption(car('selector_fuel_electrical', { consumption: { wltpPowerCombined: 16.5 } })), '16.5kWh/100km');
+    assert.equal(googleEnergyConsumption(car('selector_fuel_electrical', { consumption: { consumptionPowerCombined: 18 } })), '18kWh/100km');
+  }],
+];
+
+let failed = 0;
+for (const [name, fn] of cases) {
+  try {
+    fn();
+    console.log(`ok   ${name}`);
+  } catch (e) {
+    failed++;
+    console.log(`FAIL ${name}\n     ${(e as Error).message}`);
+  }
+}
+if (failed) process.exit(1);