@meterapp/vehicle-db 2.5.0 → 2.6.0

package/README.md

@@ -2,8 +2,14 @@
 
 An offline, international vehicle make/model catalog for Node.js and TypeScript. The package combines U.S. model-year data, the UK registered fleet, Asian-origin vehicles registered in New Zealand, Malaysian registration transactions, and an Indian manufacturer catalog into one small, zero-dependency API. It never makes runtime network requests.
 
+The current snapshot spans **1990–2026** and includes **1,145 makes**, **14,841 model names**, and **132,491 deduplicated model-year entries** from **5 data sources**.
+
 The catalog covers seven vehicle types: **Motorcycle**, **Passenger Car**, **Truck**, **Bus**, **Multipurpose Passenger Vehicle (MPV)**, **Auto Rickshaw**, and **Other Vehicle**. The Asia-Pacific sources add Japanese domestic and kei models, Chinese EVs, Indian and Korean vehicles, Southeast Asian makes such as Perodua and Proton, and additional motorcycles and commercial vehicles.
 
+## Demo and playground
+
+Want to see the API in action? Browse [Car Images](https://car-imgs.vercel.app), an example app built with this package, or explore the data directly in the [interactive playground](https://car-imgs.vercel.app/playground).
+
 ## Install
 
 ```bash
@@ -75,9 +81,51 @@ const malaysiaMakes = getMakes({
 // Existing queries remain valid.
 const toyota = getMakes({ year: 2024 }).find((make) => make.makeName === "TOYOTA");
 const toyotaModels = getModels({ makeId: toyota!.makeId, year: 2024 });
-const years = getAvailableYears();
+const years = getAvailableYears({
+  makeId: toyota!.makeId,
+  vehicleTypeId: 2,
+  sourceId: "nhtsa-vpic",
+});
 ```
 
+## Driver search and autocomplete
+
+The optional, zero-dependency search entry point turns free-form driver input into canonical catalog candidates. Its index is built lazily on the first search, and matching runs entirely in memory without network requests.
+
+```typescript
+import { searchVehicles } from "@meterapp/vehicle-db/search";
+
+const suggestions = searchVehicles("2020 toy cam", {
+  sourceId: "nhtsa-vpic",
+  vehicleTypeId: 2,
+  limit: 10,
+});
+
+const camry = suggestions.find(
+  (result) => result.kind === "model" && result.modelName === "Camry",
+);
+
+if (camry?.kind === "model") {
+  // A query containing a year has one directly selectable variant.
+  const selection = camry.variants[0];
+  // Persist year, makeId, modelId, and vehicleTypeId — not display text alone.
+}
+```
+
+Search accepts year, make, and model tokens in any order. It recognizes common punctuation variants such as `F-150`/`f150` and `CR-V`/`crv`, a small set of make aliases such as `VW` and `Chevy`, and conservative misspellings. Results are ranked deterministically by exact, prefix, token, substring, then fuzzy match. Fuzzy matching is only used when no lexical result exists.
+
+Queries without a year group a canonical make/model/type across all available years rather than returning duplicate suggestions for every year. Each model result contains `variants`, which provides the preferred catalog `modelId` for every selectable year.
+
+For the simplest driver experience:
+
+1. Infer the relevant market and pass its `sourceId`; year semantics differ by source.
+2. Offer one field labelled “Search year, make, or model” and begin suggesting after two characters.
+3. If the driver enters only a year, use `getMakes({ year, ... })` for the next step; a year-only search intentionally returns no arbitrary alphabetical suggestions.
+4. On empty input, show application-owned recent vehicles. The catalog intentionally does not pretend that record frequency is vehicle popularity.
+5. Use the manual fallback Year → Make → Model. `getAvailableYears(options)` supports every step.
+
+Applications with regional telemetry can request more candidates and rerank **within the same `matchKind`**. Text quality and market compatibility should remain ahead of behavioral popularity so an exact result never loses to an unrelated popular vehicle.
+
 ## API
 
 ### `getDataSources(): DataSource[]`
@@ -133,10 +181,11 @@ interface Make {
 
 ### `getModels(options?): Model[]`
 
-Returns models, optionally filtered by `year`, `vehicleTypeId`, `makeId`, and/or `sourceId`. `sourceIds` preserves provenance when equivalent records appear in more than one source.
+Returns models, optionally filtered by `year`, `vehicleTypeId`, `makeId`, `modelId`, and/or `sourceId`. `sourceIds` preserves provenance when equivalent records appear in more than one source.
 
 ```typescript
 getModels({ makeId: 474, year: 2024 });
+getModels({ modelId: 2469, year: 2024 });
 getModels({ year: 2024, vehicleTypeId: 1 });
 getModels({ year: 2024, vehicleTypeId: 5, sourceId: "uk-dft-vehicle-licensing" });
 ```
@@ -153,9 +202,21 @@ interface Model {
 }
 ```
 
-### `getAvailableYears(): number[]`
+### `getAvailableYears(options?): number[]`
+
+Returns years present in the combined catalog, optionally filtered by `makeId`, `modelId`, `vehicleTypeId`, and/or `sourceId`. Results are sorted ascending.
+
+```typescript
+getAvailableYears();
+getAvailableYears({ makeId: 448, vehicleTypeId: 2, sourceId: "nhtsa-vpic" });
+getAvailableYears({ modelId: 2469, sourceId: "nhtsa-vpic" });
+```
+
+### `searchVehicles(query, options?): VehicleSearchResult[]`
+
+Import from `@meterapp/vehicle-db/search`. Returns deterministic make and grouped model candidates for free-form input. Options include `year`, `vehicleTypeId`, `sourceId`, `limit` (default 10, maximum 100), and `fuzzy` (default `true`).
 
-Returns all years present in the combined catalog, sorted ascending.
+Model results contain `years` and a year-specific `variants` array. Make results intentionally omit models, allowing applications to transition into the existing `getModels` flow after the driver chooses a make.
 
 ## Data sources
 

package/dist/index.d.ts

@@ -39,6 +39,13 @@ export interface GetModelsOptions {
     year?: number;
     vehicleTypeId?: number;
     makeId?: number;
+    modelId?: number;
+    sourceId?: string;
+}
+export interface GetAvailableYearsOptions {
+    vehicleTypeId?: number;
+    makeId?: number;
+    modelId?: number;
     sourceId?: string;
 }
 /**
@@ -58,6 +65,6 @@ export declare function getMakes(options?: GetMakesOptions): Make[];
  */
 export declare function getModels(options?: GetModelsOptions): Model[];
 /**
- * Get all available years in the database.
+ * Gets available years, optionally filtered by vehicle identity and source.
  */
-export declare function getAvailableYears(): number[];
+export declare function getAvailableYears(options?: GetAvailableYearsOptions): number[];

package/dist/index.js

@@ -105,7 +105,7 @@ function getMakes(options = {}) {
 function getModels(options = {}) {
     const makeMap = getMakeMap();
     const typeMap = getTypeMap();
-    const { year, vehicleTypeId, makeId, sourceId } = options;
+    const { year, vehicleTypeId, makeId, modelId, sourceId } = options;
     const sourceMask = sourceId == null ? undefined : getSourceMaskMap().get(sourceId);
     if (sourceId != null && sourceMask == null)
         return [];
@@ -115,6 +115,8 @@ function getModels(options = {}) {
             continue;
         if (makeId != null && m[1] !== makeId)
             continue;
+        if (modelId != null && m[2] !== modelId)
+            continue;
         if (vehicleTypeId != null && m[4] !== vehicleTypeId)
             continue;
         if (sourceMask != null && (m[5] & sourceMask) === 0)
@@ -133,11 +135,23 @@ function getModels(options = {}) {
         a.vehicleTypeId - b.vehicleTypeId);
 }
 /**
- * Get all available years in the database.
+ * Gets available years, optionally filtered by vehicle identity and source.
  */
-function getAvailableYears() {
+function getAvailableYears(options = {}) {
+    const { vehicleTypeId, makeId, modelId, sourceId } = options;
+    const sourceMask = sourceId == null ? undefined : getSourceMaskMap().get(sourceId);
+    if (sourceId != null && sourceMask == null)
+        return [];
     const years = new Set();
     for (const m of data_1.default.models) {
+        if (makeId != null && m[1] !== makeId)
+            continue;
+        if (modelId != null && m[2] !== modelId)
+            continue;
+        if (vehicleTypeId != null && m[4] !== vehicleTypeId)
+            continue;
+        if (sourceMask != null && (m[5] & sourceMask) === 0)
+            continue;
         years.add(m[0]);
     }
     return [...years].sort((a, b) => a - b);

package/dist/search.d.ts

@@ -0,0 +1,47 @@
+export type VehicleSearchMatchKind = "exact" | "prefix" | "token" | "contains" | "fuzzy";
+export interface SearchVehiclesOptions {
+    /** Restrict results to one catalog year. A year in the query is detected automatically. */
+    year?: number;
+    vehicleTypeId?: number;
+    sourceId?: string;
+    /** Maximum number of results. Defaults to 10 and is capped at 100. */
+    limit?: number;
+    /** Enables conservative typo matching. Defaults to true. */
+    fuzzy?: boolean;
+}
+interface VehicleSearchResultBase {
+    makeId: number;
+    makeName: string;
+    /** Available years after applying the supplied filters, sorted ascending. */
+    years: number[];
+    sourceIds: string[];
+    matchKind: VehicleSearchMatchKind;
+}
+export interface VehicleMakeSearchResult extends VehicleSearchResultBase {
+    kind: "make";
+}
+export interface VehicleSearchVariant {
+    year: number;
+    /** The preferred catalog model ID for this canonical make/model/type/year. */
+    modelId: number;
+    sourceIds: string[];
+}
+export interface VehicleModelSearchResult extends VehicleSearchResultBase {
+    kind: "model";
+    modelName: string;
+    vehicleTypeId: number;
+    vehicleTypeName: string;
+    /** One directly selectable catalog identity per available year. */
+    variants: VehicleSearchVariant[];
+}
+export type VehicleSearchResult = VehicleMakeSearchResult | VehicleModelSearchResult;
+/**
+ * Finds canonical make and model candidates for a driver-entered query.
+ *
+ * Matching is deterministic and popularity-neutral: exact, prefix, token,
+ * substring, then conservative typo matching. Applications can request a
+ * larger candidate set and rerank within the returned `matchKind` using local
+ * recents or regional telemetry.
+ */
+export declare function searchVehicles(query: string, options?: SearchVehiclesOptions): VehicleSearchResult[];
+export {};

package/dist/search.js

@@ -0,0 +1,482 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchVehicles = searchVehicles;
+const data_1 = __importDefault(require("./data"));
+const MATCH_RANK = {
+    exact: 0,
+    prefix: 1,
+    token: 2,
+    contains: 3,
+    fuzzy: 4,
+};
+// These are search-only colloquialisms. They do not rewrite catalog identities.
+const MAKE_SEARCH_ALIASES = new Map([
+    ["alfa romeo", ["alfa"]],
+    ["bmw", ["bimmer", "beemer"]],
+    ["chevrolet", ["chevy"]],
+    ["general motors", ["gm"]],
+    ["harley davidson", ["harley"]],
+    ["mercedes benz", ["mercedes", "benz", "merc"]],
+    ["volkswagen", ["vw"]],
+]);
+const sourceMaskById = new Map(data_1.default.sources.map((source, index) => [source.source_id, 2 ** index]));
+const vehicleTypeNameById = new Map(data_1.default.vehicleTypes.map((type) => [type.vehicle_type_id, type.vehicle_type_name]));
+let _searchIndex = null;
+/**
+ * Finds canonical make and model candidates for a driver-entered query.
+ *
+ * Matching is deterministic and popularity-neutral: exact, prefix, token,
+ * substring, then conservative typo matching. Applications can request a
+ * larger candidate set and rerank within the returned `matchKind` using local
+ * recents or regional telemetry.
+ */
+function searchVehicles(query, options = {}) {
+    if (options.year != null && !Number.isInteger(options.year))
+        return [];
+    const parsedQueries = parseQueries(query, options.year);
+    if (parsedQueries.length === 0)
+        return [];
+    const sourceMask = options.sourceId == null ? undefined : sourceMaskById.get(options.sourceId);
+    if (options.sourceId != null && sourceMask == null)
+        return [];
+    const limit = normalizeLimit(options.limit);
+    if (limit === 0)
+        return [];
+    const index = getSearchIndex();
+    const rankedByKey = collectQueryInterpretations(index, parsedQueries, options, sourceMask, false);
+    preferUnmodifiedInterpretation(rankedByKey);
+    // Typo matching is a fallback, not filler after a good lexical match. This
+    // keeps an exact vehicle from being followed by unrelated near-spellings.
+    if (options.fuzzy !== false && rankedByKey.size === 0) {
+        for (const [key, result] of collectQueryInterpretations(index, parsedQueries, options, sourceMask, true)) {
+            rankedByKey.set(key, result);
+        }
+        preferUnmodifiedInterpretation(rankedByKey);
+    }
+    const ranked = [...rankedByKey.values()];
+    ranked.sort(compareRankedResults);
+    return ranked.slice(0, limit).map(({ result }) => result);
+}
+function preferUnmodifiedInterpretation(results) {
+    if (![...results.values()].some((result) => result.interpretationRank === 0))
+        return;
+    for (const [key, result] of results) {
+        if (result.interpretationRank > 0)
+            results.delete(key);
+    }
+}
+function collectQueryInterpretations(index, parsedQueries, options, sourceMask, fuzzyOnly) {
+    const rankedByKey = new Map();
+    for (const parsed of parsedQueries) {
+        const interpretationResults = [];
+        collectMatches(index, parsed.text, parsed.year, parsed.interpretationRank, options, sourceMask, fuzzyOnly, interpretationResults, new Set());
+        for (const result of interpretationResults) {
+            const existing = rankedByKey.get(result.key);
+            if (!existing || compareRankedResults(result, existing) < 0) {
+                rankedByKey.set(result.key, result);
+            }
+        }
+    }
+    return rankedByKey;
+}
+function collectMatches(index, query, year, interpretationRank, options, sourceMask, fuzzyOnly, results, includedKeys) {
+    for (const make of index.makes) {
+        const key = `make\u0000${make.makeId}`;
+        if (includedKeys.has(key))
+            continue;
+        const match = matchForms(query, make.forms, fuzzyOnly);
+        if (!match || (fuzzyOnly && match.kind !== "fuzzy"))
+            continue;
+        const availability = selectMakeAvailability(make.rows, year, options.vehicleTypeId, sourceMask);
+        if (availability.years.length === 0)
+            continue;
+        includedKeys.add(key);
+        results.push({
+            key,
+            rank: match.rank,
+            interpretationRank,
+            closeness: match.closeness,
+            result: {
+                kind: "make",
+                makeId: make.makeId,
+                makeName: make.makeName,
+                years: availability.years,
+                sourceIds: getSourceIds(availability.sourceMask),
+                matchKind: match.kind,
+            },
+        });
+    }
+    for (const model of index.models) {
+        if (options.vehicleTypeId != null && model.vehicleTypeId !== options.vehicleTypeId)
+            continue;
+        const key = `model\u0000${model.makeId}\u0000${model.modelForms[0].compact}\u0000${model.vehicleTypeId}`;
+        if (includedKeys.has(key))
+            continue;
+        const modelMatch = matchForms(query, model.modelForms, fuzzyOnly);
+        const makeMatch = matchForms(query, model.makeForms, fuzzyOnly);
+        const match = modelMatch ?? (makeMatch ? undefined : matchForms(query, model.combinedForms, fuzzyOnly));
+        if (!match || (fuzzyOnly && match.kind !== "fuzzy"))
+            continue;
+        const variants = selectModelVariants(model.rows, year, sourceMask);
+        if (variants.length === 0)
+            continue;
+        const representative = variants.reduce((best, variant) => compareRepresentativeVariants(variant, best) < 0 ? variant : best);
+        const combinedSourceMask = variants.reduce((mask, variant) => mask | variant.sourceMask, 0);
+        includedKeys.add(key);
+        results.push({
+            key,
+            rank: match.rank,
+            interpretationRank,
+            closeness: match.closeness,
+            result: {
+                kind: "model",
+                makeId: model.makeId,
+                makeName: model.makeName,
+                modelName: representative.modelName,
+                vehicleTypeId: model.vehicleTypeId,
+                vehicleTypeName: model.vehicleTypeName,
+                years: variants.map((variant) => variant.year),
+                sourceIds: getSourceIds(combinedSourceMask),
+                matchKind: match.kind,
+                variants: variants.map(({ year: variantYear, modelId, sourceIds }) => ({
+                    year: variantYear,
+                    modelId,
+                    sourceIds,
+                })),
+            },
+        });
+    }
+}
+function getSearchIndex() {
+    if (_searchIndex)
+        return _searchIndex;
+    const makesById = new Map();
+    const makeRowsById = new Map();
+    for (const make of data_1.default.makes) {
+        const baseForm = normalizeSearchText(make.make_name);
+        const aliases = MAKE_SEARCH_ALIASES.get(baseForm.spaced) ?? [];
+        makesById.set(make.make_id, {
+            makeId: make.make_id,
+            makeName: make.make_name,
+            forms: uniqueForms([baseForm, ...aliases.map(normalizeSearchText)]),
+            rows: [],
+        });
+        makeRowsById.set(make.make_id, new Map());
+    }
+    const modelsByKey = new Map();
+    for (const row of data_1.default.models) {
+        const [year, makeId, modelId, modelNameIndex, vehicleTypeId, sourceMask] = row;
+        const make = makesById.get(makeId);
+        const modelName = data_1.default.modelNames[modelNameIndex];
+        const vehicleTypeName = vehicleTypeNameById.get(vehicleTypeId);
+        if (!make || modelName == null || vehicleTypeName == null)
+            continue;
+        const makeRows = makeRowsById.get(makeId);
+        const makeRowKey = `${year}\u0000${vehicleTypeId}`;
+        const existingMakeRow = makeRows.get(makeRowKey);
+        if (existingMakeRow)
+            existingMakeRow.sourceMask |= sourceMask;
+        else
+            makeRows.set(makeRowKey, { year, vehicleTypeId, sourceMask });
+        const modelForm = normalizeSearchText(modelName);
+        const key = `${makeId}\u0000${modelForm.compact}\u0000${vehicleTypeId}`;
+        let model = modelsByKey.get(key);
+        if (!model) {
+            model = {
+                makeId,
+                makeName: make.makeName,
+                vehicleTypeId,
+                vehicleTypeName,
+                makeForms: make.forms,
+                modelForms: [],
+                combinedForms: [],
+                modelFormMap: new Map(),
+                rows: [],
+            };
+            modelsByKey.set(key, model);
+        }
+        model.modelFormMap.set(`${modelForm.spaced}\u0000${modelForm.compact}`, modelForm);
+        model.rows.push(row);
+    }
+    for (const make of makesById.values()) {
+        make.rows = [...makeRowsById.get(make.makeId).values()];
+    }
+    const models = [...modelsByKey.values()].map(({ modelFormMap, ...model }) => {
+        model.modelForms = [...modelFormMap.values()];
+        model.combinedForms = uniqueForms(model.makeForms.flatMap((makeForm) => model.modelForms.map((modelForm) => normalizeSearchText(`${makeForm.spaced} ${modelForm.spaced}`))));
+        return model;
+    });
+    _searchIndex = {
+        makes: [...makesById.values()],
+        models,
+    };
+    return _searchIndex;
+}
+function normalizeSearchText(value) {
+    const spaced = value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLocaleLowerCase("en-US")
+        .replace(/&/g, " and ")
+        .replace(/[\u2019']/g, "")
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim()
+        .replace(/\s+/g, " ");
+    return {
+        spaced,
+        compact: spaced.replace(/\s/g, ""),
+        tokens: spaced.length === 0 ? [] : spaced.split(" "),
+    };
+}
+function uniqueForms(forms) {
+    const seen = new Set();
+    return forms.filter((form) => {
+        const key = `${form.spaced}\u0000${form.compact}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function parseQueries(query, optionYear) {
+    const fullText = normalizeSearchText(query);
+    if (fullText.spaced.length === 0)
+        return [];
+    const detectedYears = [...query.matchAll(/\b(?:19|20)\d{2}\b/g)].map((match) => Number(match[0]));
+    const uniqueYears = [...new Set(detectedYears)];
+    const onlyYearTokens = fullText.tokens.length > 0 && fullText.tokens.every((token) => {
+        const value = Number(token);
+        return Number.isInteger(value) && uniqueYears.includes(value);
+    });
+    if (onlyYearTokens)
+        return [];
+    const interpretations = [
+        { text: fullText, year: optionYear, interpretationRank: 0 },
+    ];
+    const inferredYears = optionYear == null ? uniqueYears : uniqueYears.filter((year) => year === optionYear);
+    for (const year of inferredYears) {
+        const text = normalizeSearchText(query.replace(new RegExp(`\\b${year}\\b`, "g"), " "));
+        if (text.spaced.length === 0)
+            continue;
+        interpretations.push({ text, year: optionYear ?? year, interpretationRank: 1 });
+    }
+    return interpretations;
+}
+function normalizeLimit(limit) {
+    if (limit == null)
+        return 10;
+    if (!Number.isFinite(limit) || limit <= 0)
+        return 0;
+    return Math.min(100, Math.floor(limit));
+}
+function matchForms(query, forms, fuzzyOnly) {
+    let best;
+    for (const form of forms) {
+        const match = fuzzyOnly ? fuzzyMatch(query, form) : nonFuzzyMatch(query, form);
+        if (match && (!best || compareMatches(match, best) < 0))
+            best = match;
+    }
+    return best;
+}
+function nonFuzzyMatch(query, target) {
+    if (query.spaced === target.spaced || query.compact === target.compact) {
+        return lexicalMatch("exact", 0);
+    }
+    if (target.spaced.startsWith(query.spaced) || target.compact.startsWith(query.compact)) {
+        return lexicalMatch("prefix", Math.max(0, target.compact.length - query.compact.length));
+    }
+    const tokenCloseness = tokenPrefixCloseness(query.tokens, target.tokens);
+    if (tokenCloseness != null)
+        return lexicalMatch("token", tokenCloseness);
+    const spacedIndex = target.spaced.indexOf(query.spaced);
+    const compactIndex = target.compact.indexOf(query.compact);
+    if (spacedIndex >= 0 || compactIndex >= 0) {
+        const index = Math.min(spacedIndex < 0 ? Number.MAX_SAFE_INTEGER : spacedIndex, compactIndex < 0 ? Number.MAX_SAFE_INTEGER : compactIndex);
+        return lexicalMatch("contains", index + target.compact.length - query.compact.length);
+    }
+    return undefined;
+}
+function fuzzyMatch(query, target) {
+    const fullLimit = allowedEdits(query.compact.length);
+    if (fullLimit > 0 && Math.abs(query.compact.length - target.compact.length) <= fullLimit) {
+        const distance = damerauLevenshtein(query.compact, target.compact, fullLimit);
+        if (distance <= fullLimit)
+            return lexicalMatch("fuzzy", distance);
+    }
+    const tokenDistance = fuzzyTokenDistance(query.tokens, target.tokens);
+    return tokenDistance == null ? undefined : lexicalMatch("fuzzy", tokenDistance);
+}
+function lexicalMatch(kind, closeness) {
+    return { kind, rank: MATCH_RANK[kind], closeness };
+}
+function compareMatches(left, right) {
+    return left.rank - right.rank || left.closeness - right.closeness;
+}
+function tokenPrefixCloseness(queryTokens, targetTokens) {
+    if (queryTokens.length === 0 || queryTokens.length > targetTokens.length)
+        return undefined;
+    const unused = new Set(targetTokens.map((_, index) => index));
+    let closeness = 0;
+    for (const queryToken of [...queryTokens].sort((left, right) => right.length - left.length)) {
+        let bestIndex;
+        let bestDifference = Number.MAX_SAFE_INTEGER;
+        for (const index of unused) {
+            const targetToken = targetTokens[index];
+            if (!targetToken.startsWith(queryToken))
+                continue;
+            const difference = targetToken.length - queryToken.length;
+            if (difference < bestDifference) {
+                bestDifference = difference;
+                bestIndex = index;
+            }
+        }
+        if (bestIndex == null)
+            return undefined;
+        unused.delete(bestIndex);
+        closeness += bestDifference;
+    }
+    return closeness;
+}
+function fuzzyTokenDistance(queryTokens, targetTokens) {
+    if (queryTokens.length === 0 || queryTokens.length > targetTokens.length)
+        return undefined;
+    const unused = new Set(targetTokens.map((_, index) => index));
+    let totalDistance = 0;
+    for (const queryToken of [...queryTokens].sort((left, right) => right.length - left.length)) {
+        const limit = allowedEdits(queryToken.length);
+        if (limit === 0)
+            return undefined;
+        let bestIndex;
+        let bestDistance = Number.MAX_SAFE_INTEGER;
+        for (const index of unused) {
+            const targetToken = targetTokens[index];
+            if (Math.abs(queryToken.length - targetToken.length) > limit)
+                continue;
+            const distance = damerauLevenshtein(queryToken, targetToken, limit);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestIndex = index;
+            }
+        }
+        if (bestIndex == null || bestDistance > limit)
+            return undefined;
+        unused.delete(bestIndex);
+        totalDistance += bestDistance;
+    }
+    return totalDistance;
+}
+function allowedEdits(length) {
+    if (length < 4)
+        return 0;
+    return length < 6 ? 1 : 2;
+}
+function damerauLevenshtein(left, right, maximum) {
+    if (Math.abs(left.length - right.length) > maximum)
+        return maximum + 1;
+    let previousPrevious = new Array(right.length + 1).fill(0);
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex++) {
+        const current = new Array(right.length + 1).fill(0);
+        current[0] = leftIndex;
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex++) {
+            const substitutionCost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+            current[rightIndex] = Math.min(previous[rightIndex] + 1, current[rightIndex - 1] + 1, previous[rightIndex - 1] + substitutionCost);
+            if (leftIndex > 1 &&
+                rightIndex > 1 &&
+                left[leftIndex - 1] === right[rightIndex - 2] &&
+                left[leftIndex - 2] === right[rightIndex - 1]) {
+                current[rightIndex] = Math.min(current[rightIndex], previousPrevious[rightIndex - 2] + 1);
+            }
+        }
+        previousPrevious = previous;
+        previous = current;
+    }
+    return previous[right.length];
+}
+function selectMakeAvailability(rows, year, vehicleTypeId, sourceMask) {
+    const years = new Set();
+    let combinedSourceMask = 0;
+    for (const row of rows) {
+        if (year != null && row.year !== year)
+            continue;
+        if (vehicleTypeId != null && row.vehicleTypeId !== vehicleTypeId)
+            continue;
+        if (sourceMask != null && (row.sourceMask & sourceMask) === 0)
+            continue;
+        years.add(row.year);
+        combinedSourceMask |= row.sourceMask;
+    }
+    return { years: [...years].sort((left, right) => left - right), sourceMask: combinedSourceMask };
+}
+function selectModelVariants(rows, year, sourceMask) {
+    const variantsByYear = new Map();
+    for (const row of rows) {
+        const [rowYear, , modelId, modelNameIndex, , rowSourceMask] = row;
+        if (year != null && rowYear !== year)
+            continue;
+        if (sourceMask != null && (rowSourceMask & sourceMask) === 0)
+            continue;
+        const existing = variantsByYear.get(rowYear);
+        const candidate = {
+            year: rowYear,
+            modelId,
+            modelName: data_1.default.modelNames[modelNameIndex],
+            sourceMask: rowSourceMask,
+            sourceIds: getSourceIds(rowSourceMask),
+        };
+        if (!existing) {
+            variantsByYear.set(rowYear, candidate);
+            continue;
+        }
+        const combinedSourceMask = existing.sourceMask | rowSourceMask;
+        const preferred = compareRepresentativeVariants(candidate, existing) < 0 ? candidate : existing;
+        variantsByYear.set(rowYear, {
+            ...preferred,
+            sourceMask: combinedSourceMask,
+            sourceIds: getSourceIds(combinedSourceMask),
+        });
+    }
+    return [...variantsByYear.values()].sort((left, right) => left.year - right.year);
+}
+function compareRepresentativeVariants(left, right) {
+    return (firstSourceIndex(left.sourceMask) - firstSourceIndex(right.sourceMask) ||
+        displayNameRank(left.modelName) - displayNameRank(right.modelName) ||
+        left.modelName.length - right.modelName.length ||
+        compareStrings(left.modelName, right.modelName) ||
+        left.modelId - right.modelId);
+}
+function firstSourceIndex(sourceMask) {
+    for (let index = 0; index < data_1.default.sources.length; index++) {
+        if ((sourceMask & 2 ** index) !== 0)
+            return index;
+    }
+    return Number.MAX_SAFE_INTEGER;
+}
+function displayNameRank(value) {
+    return /[a-z]/.test(value) && /[A-Z]/.test(value) ? 0 : 1;
+}
+function getSourceIds(sourceMask) {
+    const sourceIds = [];
+    for (let index = 0; index < data_1.default.sources.length; index++) {
+        if ((sourceMask & 2 ** index) !== 0)
+            sourceIds.push(data_1.default.sources[index].source_id);
+    }
+    return sourceIds;
+}
+function compareRankedResults(left, right) {
+    return (left.rank - right.rank ||
+        left.interpretationRank - right.interpretationRank ||
+        left.closeness - right.closeness ||
+        (left.result.kind === right.result.kind ? 0 : left.result.kind === "make" ? -1 : 1) ||
+        compareStrings(left.result.makeName, right.result.makeName) ||
+        compareStrings(left.result.kind === "model" ? left.result.modelName : "", right.result.kind === "model" ? right.result.modelName : "") ||
+        (left.result.kind === "model" ? left.result.vehicleTypeId : 0) -
+            (right.result.kind === "model" ? right.result.vehicleTypeId : 0) ||
+        compareStrings(left.key, right.key));
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/package.json

@@ -1,13 +1,34 @@
 {
   "name": "@meterapp/vehicle-db",
-  "version": "2.5.0",
-  "description": "Offline international vehicle makes/models database — zero dependencies",
+  "version": "2.6.0",
+  "description": "Offline international database for cars, motorcycles, trucks, buses, MPVs, and more",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MeterApp/vehicle-db.git"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./search": {
+      "types": "./dist/search.d.ts",
+      "require": "./dist/search.js",
+      "default": "./dist/search.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "search": [
+        "dist/search.d.ts"
+      ]
+    }
+  },
+  "sideEffects": false,
   "files": [
     "dist"
   ],
@@ -28,6 +49,9 @@
     "nhtsa",
     "dvla",
     "vehicles",
+    "vehicle-search",
+    "autocomplete",
+    "fuzzy-search",
     "makes",
     "models",
     "motorcycles",