Showing ESC from vPIC Without Inventing Stability-Control Safety Grades

#webdev #cars #beginners #typescript

NHTSA vPIC often returns electronic stability control catalog fields on DecodeVinValues-style payloads -- commonly under keys such as ESC when the pattern includes that token. Those strings are useful on a free VIN decode card. The trap is turning a single sourced field into a stability-control safety grade, "ESC verified working," or skid-prevention claim that the catalog never asserted.

This post is about honest display: show the ESC catalog value when vPIC provides it, refuse stability-safety inventing, and allow a clean "not provided" state when the field is empty. Keep ESC catalog tokens separate from yaw-rate sensor health, brake-pressure tests, and road-course handling scores. A sourced token is still only a token: it does not prove the system is present, calibrated, or undamaged on the listed vehicle. (ABS honesty is a separate topic; here the focus is ESC.)

What ESC is (and is not) in vPIC

ESC (or the equivalent electronic stability control field your decode maps) is a catalog attribute associated with the VIN pattern. It answers a narrow question: which ESC-related token did the decode associate with this pattern?

It does not answer:

Whether the vehicle currently meets a stability or rollover performance standard
Whether ESC modules, yaw sensors, or hydraulic actuators work on this specific vehicle today
Traction control, ABS, or brake-assist packages you did not source as separate keys
Whether a dashboard ESC light is on, off, or silenced after a repair
A composite "stability safety score" built from missing neighboring fields

Empty ESC does not authorize a default "Standard" badge, and a positive token does not mean "skid control verified." Do not fill gaps from Make/Model/Year folklore or a chart keyed only by model year.

Normalize empties, do not invent grades

Treat blank, "Not Applicable", "N/A", and similar tokens as missing. Keep a sourced string when present; do not rewrite it into "ESC Grade A" or a stability-inspection score.

const EMPTY = new Set([
  "",
  "not applicable",
  "n/a",
  "na",
  "null",
  "none",
  "unknown",
]);

export type EscView = {
  value: string | null;
  source: "vpic" | "missing";
};

export function viewEsc(fields: {
  ESC?: string | null;
}): EscView {
  const raw = (fields.ESC ?? "").trim();
  if (!raw || EMPTY.has(raw.toLowerCase())) {
    return { value: null, source: "missing" };
  }
  return { value: raw, source: "vpic" };
}

export function escLines(view: EscView): string[] {
  if (view.source === "missing") {
    return ["ESC: not provided by vPIC for this VIN"];
  }
  return [
    `ESC (vPIC): ${view.value}`,
    "Catalog token only -- not a stability-control safety grade",
  ];
}

The footnote matters. Buyers over-read a single ESC field as verified skid prevention. Show the sourced token; if blank, say "not provided" -- no greyed "Standard" and no invented stability grade.

Forbidden upgrades

Product pressure often asks for:

Mapping any non-empty ESC into "electronic stability control verified"
Inventing IIHS / Euro NCAP / star-equivalent stability-safety language from the catalog field
Bundling ESC with ABS or traction-control keys into "Full Stability Safety Package"
Defaulting blank ESC to "Standard" so mid-trim cars look complete
Renaming catalog tokens into OEM chassis-suite marketing names you did not source

Refuse those. If you show neighboring catalog fields from separate sourced keys, show each on its own row. Never invent skid-prevention or package language inside the ESC mapper.

export function assertNoEscStabilityInvent(moduleSource: string): void {
  const banned = [
    /esc verified/i,
    /stability.?control safety grade/i,
    /skid prevention verified/i,
    /iihs/i,
    /full stability safety/i,
    /euro ncap/i,
  ];
  for (const re of banned) {
    if (re.test(moduleSource)) {
      throw new Error(
        `ESC module must not invent stability grades: ${re}`,
      );
    }
  }
}

export type CardRow = { label: string; value: string };

export function cardRows(fields: {
  ESC?: string | null;
  ABS?: string | null;
  TractionControl?: string | null;
}): CardRow[] {
  const view = viewEsc(fields);
  const out: CardRow[] = [];
  if (view.source === "missing") {
    out.push({ label: "ESC", value: "not provided" });
  } else {
    out.push({ label: "ESC", value: String(view.value) });
  }

  const abs = (fields.ABS ?? "").trim();
  if (abs && !EMPTY.has(abs.toLowerCase())) {
    out.push({ label: "ABS (vPIC)", value: abs });
  }
  const tc = (fields.TractionControl ?? "").trim();
  if (tc && !EMPTY.has(tc.toLowerCase())) {
    out.push({ label: "Traction control (vPIC)", value: tc });
  }
  return out;
}

Keep neighboring catalog fields on their own labeled rows. Never concatenate them into "Full Stability Safety Package," and never treat a separate ABS catalog key as proof that ESC implies a safety grade.

UI copy that stays honest

Prefer:

"ESC (vPIC): Standard"
"ESC: not provided by vPIC for this VIN"
A short footnote: catalog token, not a stability-control safety grade

Avoid:

"IIHS stability Superior -- verified"
"ESC Grade A included"
Grey placeholders that look like real ESC data when the field was empty

Quick checks

import assert from "node:assert/strict";

assert.equal(viewEsc({}).source, "missing");
assert.deepEqual(escLines(viewEsc({})), [
  "ESC: not provided by vPIC for this VIN",
]);

const std = viewEsc({ ESC: "Standard" });
assert.equal(std.value, "Standard");
assert.ok(
  escLines(std).some((l) => /not a stability-control safety grade/i.test(l)),
);
assert.ok(
  !escLines(std).some((l) =>
    /iihs|esc verified|stability safety package/i.test(l),
  ),
);

const rows = cardRows({
  ESC: "",
  ABS: "Standard",
  TractionControl: "Standard",
});
assert.ok(
  rows.some((r) => r.label === "ESC" && r.value === "not provided"),
);
assert.ok(rows.some((r) => r.label.includes("ABS")));
assert.ok(rows.some((r) => r.label.includes("Traction")));
assert.ok(!rows.some((r) => /iihs|esc verified/i.test(r.value)));

Review rule: ESC modules must not contain stability-upgrade or safety-grade phrases except in forbidding tests. Never upgrade a blank into "Standard."

Takeaway

ESC is a catalog token. Display it with clear sourcing, allow "not provided," and never use it as a key into invented stability-control safety grades, skid-prevention claims, or "full stability safety" bundles. Your free VIN UI stays trustworthy when ESC data is either a real vPIC value with a modest footnote -- or absent -- and chassis-performance marketing lives somewhere else, clearly labeled, or not at all.

I maintain VIN Lookup, a free VIN decode based on NHTSA data.

DEV Community