Displaying AdaptiveCruiseControl from vPIC Without Inventing Autonomy Claims

NHTSA vPIC often returns adaptive-cruise catalog fields on DecodeVinValues-style payloads -- including AdaptiveCruiseControl 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 Level-2 autonomy claim, "self-driving capable," or hands-free highway package that the catalog never asserted.

This post is about honest display: show AdaptiveCruiseControl when vPIC provides it, refuse autonomy inventing, and allow a clean "not provided" state when the field is empty. Keep adaptive-cruise catalog values separate from SAE automation levels, OEM suite marketing, and highway-pilot branding. A sourced token is still only a token: it does not prove the feature is present, calibrated, or undamaged on the listed vehicle. Do not upgrade a cruise catalog string into a driverless narrative. (Forward-collision honesty is a separate topic; here the focus is AdaptiveCruiseControl.)

What AdaptiveCruiseControl is (and is not)

AdaptiveCruiseControl is a catalog attribute associated with the VIN decode. It answers a narrow question: which adaptive-cruise token did the decode associate with this pattern?

It does not answer:

• Whether the vehicle is SAE Level 2, Level 3, or "autonomous"
• Whether lane-centering, hands-free, or traffic-jam assist is included
• Radar vs camera hardware, following-distance modes, or stop-and-go behavior you did not source
• Whether the feature works today, was optioned, or was deleted after manufacture
• A composite "autonomy score" built from missing neighboring fields

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

Normalize empties, do not invent autonomy

Treat blank, "Not Applicable", "N/A", and similar tokens as missing. Keep a sourced string when present; do not rewrite it into "Level 2 Standard" or an autonomy marketing grade.

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

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

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

export function adaptiveCruiseLines(view: AccView): string[] {
  if (view.source === "missing") {
    return [
      "Adaptive cruise control: not provided by vPIC for this VIN",
    ];
  }
  return [
    `Adaptive cruise control (vPIC): ${view.value}`,
    "Catalog token only -- not an autonomy or SAE level claim",
  ];
}

The footnote matters. Buyers over-read a single adaptive-cruise field as verified hands-free driving. Show the sourced token; if blank, say "not provided" -- no greyed "Standard" and no invented autonomy claim.

Forbidden upgrades

Product pressure often asks for:

1. Mapping any non-empty AdaptiveCruiseControl into "Level 2 included"
2. Inventing SAE / NHTSA automation-level language from the catalog field
3. Bundling AdaptiveCruiseControl with lane-keep keys into "Full Autonomy Package"
4. Defaulting blank AdaptiveCruiseControl to "Standard" so mid-trim cars look complete
5. Renaming catalog tokens into OEM highway-pilot marketing names you did not source

Refuse those. If you show other ADAS catalog fields from separate sourced keys, show each on its own row. Never invent SAE levels or package language inside the AdaptiveCruiseControl mapper.

export function assertNoAccAutonomyInvent(moduleSource: string): void {
  const banned = [
    /level\s*[123]/i,
    /self-?driving/i,
    /autonom(y|ous)/i,
    /hands-?free/i,
    /full autonomy package/i,
    /sae\s*level/i,
  ];
  for (const re of banned) {
    if (re.test(moduleSource)) {
      throw new Error(
        `AdaptiveCruiseControl module must not invent autonomy: ${re}`,
      );
    }
  }
}

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

export function cardRows(fields: {
  AdaptiveCruiseControl?: string | null;
  ForwardCollisionWarning?: string | null;
  LaneKeepingSystem?: string | null;
}): CardRow[] {
  const view = viewAdaptiveCruiseControl(fields);
  const out: CardRow[] = [];
  if (view.source === "missing") {
    out.push({
      label: "Adaptive cruise control",
      value: "not provided",
    });
  } else {
    out.push({
      label: "Adaptive cruise control",
      value: String(view.value),
    });
  }

  const fcw = (fields.ForwardCollisionWarning ?? "").trim();
  if (fcw && !EMPTY.has(fcw.toLowerCase())) {
    out.push({ label: "Forward collision (vPIC)", value: fcw });
  }
  const lks = (fields.LaneKeepingSystem ?? "").trim();
  if (lks && !EMPTY.has(lks.toLowerCase())) {
    out.push({ label: "Lane keeping (vPIC)", value: lks });
  }
  return out;
}

Keep neighboring catalog fields on their own labeled rows. Never concatenate them into "Full Autonomy Package," and never treat a separate lane-keeping catalog key as proof that AdaptiveCruiseControl implies SAE Level 2.

UI copy that stays honest

Prefer:

• "Adaptive cruise control (vPIC): Standard"
• "Adaptive cruise control: not provided by vPIC for this VIN"
• A short footnote: catalog token, not an autonomy or SAE level claim

Avoid:

• "SAE Level 2 -- verified"
• "Self-driving / hands-free included"
• Grey placeholders that look like real adaptive-cruise data when the field was empty

Quick checks

import assert from "node:assert/strict";

assert.equal(viewAdaptiveCruiseControl({}).source, "missing");
assert.deepEqual(
  adaptiveCruiseLines(viewAdaptiveCruiseControl({})),
  ["Adaptive cruise control: not provided by vPIC for this VIN"],
);

const std = viewAdaptiveCruiseControl({
  AdaptiveCruiseControl: "Standard",
});
assert.equal(std.value, "Standard");
assert.ok(
  adaptiveCruiseLines(std).some((l) =>
    /not an autonomy or SAE level/i.test(l),
  ),
);
assert.ok(
  !adaptiveCruiseLines(std).some((l) =>
    /level\s*2|self-driving|autonomy package/i.test(l),
  ),
);

const rows = cardRows({
  AdaptiveCruiseControl: "",
  ForwardCollisionWarning: "Standard",
  LaneKeepingSystem: "Standard",
});
assert.ok(
  rows.some(
    (r) =>
      r.label.includes("Adaptive cruise") && r.value === "not provided",
  ),
);
assert.ok(rows.some((r) => r.label.includes("Forward collision")));
assert.ok(rows.some((r) => r.label.includes("Lane keeping")));
assert.ok(!rows.some((r) => /level\s*2|self-driving/i.test(r.value)));

Review rule: adaptive-cruise modules must not contain SAE-upgrade or autonomy-package phrases except in forbidding tests. Never upgrade a blank into "Standard."

Takeaway

AdaptiveCruiseControl is a catalog token. Display it with clear sourcing, allow "not provided," and never use it as a key into invented SAE levels, self-driving claims, or "full autonomy" bundles. Your free VIN UI stays trustworthy when adaptive-cruise data is either a real vPIC value with a modest footnote -- or absent -- and autonomy marketing lives somewhere else, clearly labeled, or not at all.

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