Displaying EngineModel from vPIC Without Inventing Performance Trim Names

NHTSA vPIC often returns an EngineModel field on DecodeVinValues-style payloads: a catalog string naming the engine pattern when the decode includes it. That text is useful on a free VIN decode card. The trap is rewriting it into brochure performance trim language -- "Sport," "High Output," "Track Package" -- that the catalog string never asserted.

This post is about honest display: show EngineModel when vPIC provides it, refuse performance-trim inventing, and allow a clean "not provided" state when the field is empty. Keep EngineModel catalog text separate from Series/Trim, EngineHP, ForcedInduction, and marketing badge names. A dense OEM engine code is still catalog text: it is not permission to invent a performance sub-brand for the decode card. (EngineCylinders and EngineHP honesty are separate topics; here the focus is the EngineModel string alone.)

What EngineModel is (and is not)

EngineModel is a catalog attribute associated with the VIN decode. It answers a narrow question: which engine-model label did the decode associate with this pattern?

It does not answer:

• Whether the vehicle is a Sport, GT, or High Output trim
• Brochure 0-60, dyno, or tow claims
• That you may rewrite "2.0L" style catalog text into "Turbo Sport mill"
• Option-package content the dealer sold under a performance name
• Whether the installed engine still matches the original pattern

Empty EngineModel does not authorize a default "Base" or "Sport" badge, and a dense catalog string does not mean you may append "HO" or "Performance." Do not fill gaps from Make/Model/Year folklore or a chart keyed only by displacement. Prefer a visible "not provided" over a polished guess that looks official.

Normalize empties, do not invent trim names

Treat blank, "Not Applicable", "N/A", and similar tokens as missing. Keep the sourced string when present; do not rewrite it into "Sport," "High Output," or other brochure trim names.

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

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

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

export function engineModelLines(view: EngineModelView): string[] {
  if (view.source === "missing") {
    return [
      "Engine model: not provided by vPIC for this VIN",
    ];
  }
  return [
    `Engine model (vPIC): ${view.value}`,
    "Catalog text only -- not a Sport / High Output / performance trim claim",
  ];
}

The footnote matters. Buyers over-read engine labels as trim upgrades. Show the sourced string; if blank, say "not provided" -- no greyed "Sport" and no invented HO suffix.

Forbidden upgrades

Product pressure often asks for:

1. Mapping any EngineModel containing "2.0" into "Turbo Sport"
2. Appending "High Output" or "HO" without a sourced field that says so
3. Rewriting catalog codes into brochure trim names (Sport, Track, Performance)
4. Defaulting blank EngineModel to "Base" so the card looks complete
5. Merging EngineModel with Series/Trim into a single invented powertrain badge

Refuse those. If you show Series, Trim, or EngineHP from other sourced fields, show each on its own row. Never invent performance-trim arithmetic inside the EngineModel mapper.

export function assertNoEngineModelTrimInvent(
  moduleSource: string,
): void {
  const banned = [
    /high output/i,
    /\bho\b/i,
    /turbo sport/i,
    /track package/i,
    /performance trim/i,
    /0-60/i,
  ];
  for (const re of banned) {
    if (re.test(moduleSource)) {
      throw new Error(
        `EngineModel module must not invent performance trims: ${re}`,
      );
    }
  }
}

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

export function cardRows(fields: {
  EngineModel?: string | null;
  Series?: string | null;
  Trim?: string | null;
}): CardRow[] {
  const view = viewEngineModel(fields);
  const out: CardRow[] = [];
  if (view.source === "missing") {
    out.push({
      label: "Engine model",
      value: "not provided",
    });
  } else {
    out.push({
      label: "Engine model",
      value: String(view.value),
    });
  }

  const series = (fields.Series ?? "").trim();
  if (series && !EMPTY.has(series.toLowerCase())) {
    out.push({ label: "Series (vPIC)", value: series });
  }
  const trim = (fields.Trim ?? "").trim();
  if (trim && !EMPTY.has(trim.toLowerCase())) {
    out.push({ label: "Trim (vPIC)", value: trim });
  }
  return out;
}

Keep Series and Trim on their own labeled rows. Never concatenate EngineModel with Trim into "Sport High Output."

UI copy that stays honest

Prefer:

• "Engine model (vPIC): 2.0L I4 DOHC"
• "Engine model: not provided by vPIC for this VIN"
• A short footnote: catalog text, not a performance trim claim

Avoid:

• "High Output Sport mill verified"
• "Track Package engine from EngineModel"
• Grey placeholders that look like real engine-model data when the field was empty

Quick checks

import assert from "node:assert/strict";

assert.equal(viewEngineModel({}).source, "missing");
assert.deepEqual(
  engineModelLines(viewEngineModel({})),
  ["Engine model: not provided by vPIC for this VIN"],
);

const twoLit = viewEngineModel({ EngineModel: "2.0L I4 DOHC" });
assert.equal(twoLit.value, "2.0L I4 DOHC");
assert.ok(
  engineModelLines(twoLit).some((l) =>
    /not a Sport \/ High Output/i.test(l),
  ),
);
assert.ok(
  !engineModelLines(twoLit).some((l) =>
    /high output|turbo sport|track package/i.test(l),
  ),
);

const rows = cardRows({
  EngineModel: "",
  Series: "SE",
  Trim: "Limited",
});
assert.ok(
  rows.some(
    (r) =>
      r.label.includes("Engine model") && r.value === "not provided",
  ),
);
assert.ok(rows.some((r) => r.label.includes("Series")));
assert.ok(rows.some((r) => r.label.includes("Trim")));
assert.ok(!rows.some((r) => /high output|sport mill/i.test(r.value)));

Review rule: EngineModel modules must not contain performance-trim marketing phrases except in forbidding tests. Never upgrade a blank into "Sport."

Takeaway

EngineModel is catalog text. Display it with clear sourcing, allow "not provided," and never rewrite it into Sport, High Output, or brochure performance trim names. Your free VIN UI stays trustworthy when engine model is either a real vPIC string with a modest footnote -- or absent -- and performance marketing lives somewhere else, clearly labeled, or not at all. Catalog honesty beats a flashy trim label every time.

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