Kaynağa Gözat

Plate lookup from the header (#312)

A plate palette on every page once a vehicle registry is connected, opened
from a header button or Ctrl+Shift+L. One action asks the workshop's own
records and the registry together, so the desk sees the vehicle, its owner
and history beside what the register publishes: identity, VIN, engine,
dates, weights and tyres. A vehicle the workshop has not seen gets an Add
vehicle button that opens the form with the registry's answer typed in.
The registry lookup moves into a shared library the form's button and the
palette both use.
Bernt Christian Egeland 2 ay önce
ebeveyn
işleme
d4f0656701

+ 58 - 0
messages/de/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Liste aktualisieren",
     "timeZoneRequired": "Die Zeitzone der Werkstatt steht auf automatisch, Buchungszeiten würden also dem Browser folgen, der zuletzt gespeichert hat (derzeit {zone}). Erinnerungen können erst gesendet werden, wenn eine Zone gewählt ist.",
     "timeZoneRequiredLink": "Unter Lokalisierung wählen"
+  },
+  "plateLookup": {
+    "open": "Kennzeichenabfrage",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Kennzeichenabfrage",
+    "description": "Geben Sie ein Kennzeichen ein, um zu sehen, was Ihre Werkstatt und das Fahrzeugregister darüber wissen",
+    "placeholder": "Kennzeichen eingeben",
+    "search": "Abfragen",
+    "hintEnter": "Enter zum Abfragen",
+    "hintClose": "Esc zum Schließen",
+    "recent": "Zuletzt",
+    "clearRecent": "Leeren",
+    "looking": "{source} wird gefragt…",
+    "lookingWorkshop": "Werkstatt wird geprüft…",
+    "invalid": "Das sieht nicht wie ein Kennzeichen aus",
+    "inWorkshop": "In Ihrer Werkstatt",
+    "inWorkshopArchived": "In Ihrer Werkstatt, archiviert",
+    "notInWorkshop": "Noch nicht in Ihrer Werkstatt",
+    "notInWorkshopHint": "Das Register kennt dieses Fahrzeug. Fügen Sie es hinzu, die Felder unten kommen mit.",
+    "notInWorkshopNoRegistry": "Von Hand hinzufügen, oder das Kennzeichen prüfen.",
+    "openVehicle": "Fahrzeug öffnen",
+    "addVehicle": "Fahrzeug hinzufügen",
+    "noOwner": "Kein Kunde verknüpft",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Keine Serviceeinträge} one {# Serviceeintrag} other {# Serviceeinträge}}",
+    "lastService": "Letzter Service {date}",
+    "registryNotFound": "{source} kennt kein Fahrzeug mit diesem Kennzeichen",
+    "registryFailed": "{source} konnte nicht gefragt werden",
+    "registryFailedGeneric": "Das Register konnte nicht gefragt werden",
+    "fromSource": "Von {source}",
+    "registered": "Zugelassen",
+    "notRegistered": "Nicht zugelassen",
+    "vin": "FIN",
+    "copyVin": "FIN kopieren",
+    "copied": "Kopiert",
+    "fuel": "Kraftstoff",
+    "transmission": "Getriebe",
+    "engine": "Motor",
+    "engineCode": "Motorcode",
+    "color": "Farbe",
+    "vehicleClass": "Klasse",
+    "firstRegistered": "Erstzulassung",
+    "inspectionDue": "Prüfung fällig",
+    "lastInspected": "Zuletzt geprüft",
+    "weights": "Gewichte",
+    "weightsValue": "{kerb} kg leer, {gross} kg zulässig",
+    "kerbOnly": "{kerb} kg leer",
+    "grossOnly": "{gross} kg zulässig",
+    "tyres": "Reifen",
+    "axle": "Achse {n}",
+    "tyreSize": "Reifen",
+    "rimSize": "Felge",
+    "loadSpeed": "Last / Geschwindigkeit",
+    "overdue": "Überfällig",
+    "dueSoon": "Bald fällig",
+    "emptyTitle": "Beliebiges Kennzeichen abfragen",
+    "emptyBody": "Sehen Sie das Fahrzeug, wem es hier gehört und was {source} dazu führt. Noch nicht Ihres? In einem Schritt hinzufügen.",
+    "registryWord": "das Register"
   }
 }

+ 58 - 0
messages/en/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Refresh list",
     "timeZoneRequired": "The workshop timezone is on automatic, so booking times would follow whichever browser saved settings last (currently {zone}). Reminders cannot be sent until a zone is chosen.",
     "timeZoneRequiredLink": "Choose it under Localization"
+  },
+  "plateLookup": {
+    "open": "Plate lookup",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Plate lookup",
+    "description": "Type a registration number to see what your workshop and the vehicle registry know about it",
+    "placeholder": "Type a plate",
+    "search": "Look up",
+    "hintEnter": "Enter to look up",
+    "hintClose": "Esc to close",
+    "recent": "Recent",
+    "clearRecent": "Clear",
+    "looking": "Asking {source}…",
+    "lookingWorkshop": "Checking your workshop…",
+    "invalid": "That does not look like a plate",
+    "inWorkshop": "In your workshop",
+    "inWorkshopArchived": "In your workshop, archived",
+    "notInWorkshop": "Not in your workshop yet",
+    "notInWorkshopHint": "The registry knows this vehicle. Add it and the fields below come along.",
+    "notInWorkshopNoRegistry": "Add it by hand, or check the plate.",
+    "openVehicle": "Open vehicle",
+    "addVehicle": "Add vehicle",
+    "noOwner": "No customer linked",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {No service records} one {# service record} other {# service records}}",
+    "lastService": "Last service {date}",
+    "registryNotFound": "{source} has no vehicle with that plate",
+    "registryFailed": "{source} could not be asked",
+    "registryFailedGeneric": "The registry could not be asked",
+    "fromSource": "From {source}",
+    "registered": "Registered",
+    "notRegistered": "Not registered",
+    "vin": "VIN",
+    "copyVin": "Copy VIN",
+    "copied": "Copied",
+    "fuel": "Fuel",
+    "transmission": "Gearbox",
+    "engine": "Engine",
+    "engineCode": "Engine code",
+    "color": "Colour",
+    "vehicleClass": "Class",
+    "firstRegistered": "First registered",
+    "inspectionDue": "Inspection due",
+    "lastInspected": "Last inspected",
+    "weights": "Weights",
+    "weightsValue": "{kerb} kg kerb, {gross} kg max",
+    "kerbOnly": "{kerb} kg kerb",
+    "grossOnly": "{gross} kg max",
+    "tyres": "Tyres",
+    "axle": "Axle {n}",
+    "tyreSize": "Tyre",
+    "rimSize": "Rim",
+    "loadSpeed": "Load / speed",
+    "overdue": "Overdue",
+    "dueSoon": "Due soon",
+    "emptyTitle": "Look up any plate",
+    "emptyBody": "See the vehicle, who owns it here, and what {source} has on file. Not yours yet? Add it in one step.",
+    "registryWord": "the registry"
   }
 }

+ 58 - 0
messages/es/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Actualizar lista",
     "timeZoneRequired": "La zona horaria del taller está en automático, así que las horas de reserva seguirían al último navegador que guardó ajustes (ahora {zone}). No se pueden enviar recordatorios hasta elegir una zona.",
     "timeZoneRequiredLink": "Elígela en Localización"
+  },
+  "plateLookup": {
+    "open": "Buscar matrícula",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Buscar matrícula",
+    "description": "Escribe una matrícula para ver lo que tu taller y el registro de vehículos saben de ella",
+    "placeholder": "Escribe una matrícula",
+    "search": "Buscar",
+    "hintEnter": "Enter para buscar",
+    "hintClose": "Esc para cerrar",
+    "recent": "Recientes",
+    "clearRecent": "Borrar",
+    "looking": "Consultando {source}…",
+    "lookingWorkshop": "Comprobando tu taller…",
+    "invalid": "Eso no parece una matrícula",
+    "inWorkshop": "En tu taller",
+    "inWorkshopArchived": "En tu taller, archivado",
+    "notInWorkshop": "Aún no está en tu taller",
+    "notInWorkshopHint": "El registro conoce este vehículo. Añádelo y los campos de abajo vienen con él.",
+    "notInWorkshopNoRegistry": "Añádelo a mano, o revisa la matrícula.",
+    "openVehicle": "Abrir vehículo",
+    "addVehicle": "Añadir vehículo",
+    "noOwner": "Sin cliente vinculado",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Sin registros de servicio} one {# registro de servicio} other {# registros de servicio}}",
+    "lastService": "Último servicio {date}",
+    "registryNotFound": "{source} no tiene ningún vehículo con esa matrícula",
+    "registryFailed": "No se pudo consultar {source}",
+    "registryFailedGeneric": "No se pudo consultar el registro",
+    "fromSource": "De {source}",
+    "registered": "Matriculado",
+    "notRegistered": "No matriculado",
+    "vin": "VIN",
+    "copyVin": "Copiar VIN",
+    "copied": "Copiado",
+    "fuel": "Combustible",
+    "transmission": "Caja de cambios",
+    "engine": "Motor",
+    "engineCode": "Código de motor",
+    "color": "Color",
+    "vehicleClass": "Clase",
+    "firstRegistered": "Primera matriculación",
+    "inspectionDue": "Inspección vence",
+    "lastInspected": "Última inspección",
+    "weights": "Pesos",
+    "weightsValue": "{kerb} kg en vacío, {gross} kg máx.",
+    "kerbOnly": "{kerb} kg en vacío",
+    "grossOnly": "{gross} kg máx.",
+    "tyres": "Neumáticos",
+    "axle": "Eje {n}",
+    "tyreSize": "Neumático",
+    "rimSize": "Llanta",
+    "loadSpeed": "Carga / velocidad",
+    "overdue": "Vencida",
+    "dueSoon": "Pronto",
+    "emptyTitle": "Busca cualquier matrícula",
+    "emptyBody": "Ve el vehículo, quién es su dueño aquí y lo que {source} tiene registrado. ¿Aún no es tuyo? Añádelo en un paso.",
+    "registryWord": "el registro"
   }
 }

+ 58 - 0
messages/fr/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Actualiser la liste",
     "timeZoneRequired": "Le fuseau horaire de l'atelier est en automatique : les horaires de réservation suivraient le dernier navigateur ayant enregistré les paramètres (actuellement {zone}). Aucun rappel ne peut partir tant qu'un fuseau n'est pas choisi.",
     "timeZoneRequiredLink": "Choisissez-le sous Localisation"
+  },
+  "plateLookup": {
+    "open": "Recherche de plaque",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Recherche de plaque",
+    "description": "Saisissez une immatriculation pour voir ce que votre atelier et le registre des véhicules en savent",
+    "placeholder": "Saisissez une plaque",
+    "search": "Rechercher",
+    "hintEnter": "Entrée pour rechercher",
+    "hintClose": "Échap pour fermer",
+    "recent": "Récentes",
+    "clearRecent": "Effacer",
+    "looking": "Interrogation de {source}…",
+    "lookingWorkshop": "Vérification de votre atelier…",
+    "invalid": "Cela ne ressemble pas à une plaque",
+    "inWorkshop": "Dans votre atelier",
+    "inWorkshopArchived": "Dans votre atelier, archivé",
+    "notInWorkshop": "Pas encore dans votre atelier",
+    "notInWorkshopHint": "Le registre connaît ce véhicule. Ajoutez-le et les champs ci-dessous suivent.",
+    "notInWorkshopNoRegistry": "Ajoutez-le à la main, ou vérifiez la plaque.",
+    "openVehicle": "Ouvrir le véhicule",
+    "addVehicle": "Ajouter le véhicule",
+    "noOwner": "Aucun client associé",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Aucun historique d'entretien} one {# intervention} other {# interventions}}",
+    "lastService": "Dernier entretien {date}",
+    "registryNotFound": "{source} n'a aucun véhicule avec cette plaque",
+    "registryFailed": "{source} n'a pas pu être interrogé",
+    "registryFailedGeneric": "Le registre n'a pas pu être interrogé",
+    "fromSource": "Depuis {source}",
+    "registered": "Immatriculé",
+    "notRegistered": "Non immatriculé",
+    "vin": "VIN",
+    "copyVin": "Copier le VIN",
+    "copied": "Copié",
+    "fuel": "Carburant",
+    "transmission": "Boîte",
+    "engine": "Moteur",
+    "engineCode": "Code moteur",
+    "color": "Couleur",
+    "vehicleClass": "Catégorie",
+    "firstRegistered": "Première immatriculation",
+    "inspectionDue": "Contrôle dû",
+    "lastInspected": "Dernier contrôle",
+    "weights": "Masses",
+    "weightsValue": "{kerb} kg à vide, {gross} kg max",
+    "kerbOnly": "{kerb} kg à vide",
+    "grossOnly": "{gross} kg max",
+    "tyres": "Pneus",
+    "axle": "Essieu {n}",
+    "tyreSize": "Pneu",
+    "rimSize": "Jante",
+    "loadSpeed": "Charge / vitesse",
+    "overdue": "Dépassé",
+    "dueSoon": "Bientôt",
+    "emptyTitle": "Recherchez n'importe quelle plaque",
+    "emptyBody": "Voyez le véhicule, à qui il appartient ici et ce que {source} a enregistré. Pas encore le vôtre ? Ajoutez-le en une étape.",
+    "registryWord": "le registre"
   }
 }

+ 58 - 0
messages/it/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Aggiorna elenco",
     "timeZoneRequired": "Il fuso orario dell'officina è su automatico, quindi gli orari di prenotazione seguirebbero l'ultimo browser che ha salvato le impostazioni (ora {zone}). Non si possono inviare promemoria finché non scegli un fuso.",
     "timeZoneRequiredLink": "Scegli in Localizzazione"
+  },
+  "plateLookup": {
+    "open": "Ricerca targa",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Ricerca targa",
+    "description": "Digita una targa per vedere cosa sanno la tua officina e il registro veicoli",
+    "placeholder": "Digita una targa",
+    "search": "Cerca",
+    "hintEnter": "Invio per cercare",
+    "hintClose": "Esc per chiudere",
+    "recent": "Recenti",
+    "clearRecent": "Svuota",
+    "looking": "Interrogo {source}…",
+    "lookingWorkshop": "Controllo l'officina…",
+    "invalid": "Non sembra una targa",
+    "inWorkshop": "Nella tua officina",
+    "inWorkshopArchived": "Nella tua officina, archiviato",
+    "notInWorkshop": "Non ancora nella tua officina",
+    "notInWorkshopHint": "Il registro conosce questo veicolo. Aggiungilo e i campi qui sotto vengono con lui.",
+    "notInWorkshopNoRegistry": "Aggiungilo a mano, oppure controlla la targa.",
+    "openVehicle": "Apri veicolo",
+    "addVehicle": "Aggiungi veicolo",
+    "noOwner": "Nessun cliente collegato",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Nessun intervento} one {# intervento} other {# interventi}}",
+    "lastService": "Ultimo intervento {date}",
+    "registryNotFound": "{source} non ha alcun veicolo con quella targa",
+    "registryFailed": "Impossibile interrogare {source}",
+    "registryFailedGeneric": "Impossibile interrogare il registro",
+    "fromSource": "Da {source}",
+    "registered": "Immatricolato",
+    "notRegistered": "Non immatricolato",
+    "vin": "VIN",
+    "copyVin": "Copia VIN",
+    "copied": "Copiato",
+    "fuel": "Carburante",
+    "transmission": "Cambio",
+    "engine": "Motore",
+    "engineCode": "Codice motore",
+    "color": "Colore",
+    "vehicleClass": "Categoria",
+    "firstRegistered": "Prima immatricolazione",
+    "inspectionDue": "Revisione entro",
+    "lastInspected": "Ultima revisione",
+    "weights": "Masse",
+    "weightsValue": "{kerb} kg a vuoto, {gross} kg max",
+    "kerbOnly": "{kerb} kg a vuoto",
+    "grossOnly": "{gross} kg max",
+    "tyres": "Pneumatici",
+    "axle": "Asse {n}",
+    "tyreSize": "Pneumatico",
+    "rimSize": "Cerchio",
+    "loadSpeed": "Carico / velocità",
+    "overdue": "Scaduta",
+    "dueSoon": "In scadenza",
+    "emptyTitle": "Cerca qualsiasi targa",
+    "emptyBody": "Vedi il veicolo, chi ne è il proprietario qui e cosa ha registrato {source}. Non è ancora tuo? Aggiungilo in un passaggio.",
+    "registryWord": "il registro"
   }
 }

+ 58 - 0
messages/lt/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Atnaujinti sąrašą",
     "timeZoneRequired": "Dirbtuvių laiko juosta nustatyta automatiškai, todėl rezervacijos laikai sektų naršyklę, paskutinę išsaugojusią nustatymus (dabar {zone}). Priminimų negalima siųsti, kol nepasirinkta juosta.",
     "timeZoneRequiredLink": "Pasirinkite skiltyje Lokalizacija"
+  },
+  "plateLookup": {
+    "open": "Numerio paieška",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Numerio paieška",
+    "description": "Įveskite registracijos numerį ir pamatysite, ką apie jį žino jūsų dirbtuvės ir transporto priemonių registras",
+    "placeholder": "Įveskite numerį",
+    "search": "Ieškoti",
+    "hintEnter": "Enter ieškoti",
+    "hintClose": "Esc uždaryti",
+    "recent": "Naujausi",
+    "clearRecent": "Išvalyti",
+    "looking": "Klausiama {source}…",
+    "lookingWorkshop": "Tikrinamos dirbtuvės…",
+    "invalid": "Tai nepanašu į numerį",
+    "inWorkshop": "Jūsų dirbtuvėse",
+    "inWorkshopArchived": "Jūsų dirbtuvėse, archyvuota",
+    "notInWorkshop": "Dar ne jūsų dirbtuvėse",
+    "notInWorkshopHint": "Registras žino šią transporto priemonę. Pridėkite ją, ir žemiau esantys laukai užsipildys.",
+    "notInWorkshopNoRegistry": "Pridėkite ranka arba patikrinkite numerį.",
+    "openVehicle": "Atverti transporto priemonę",
+    "addVehicle": "Pridėti transporto priemonę",
+    "noOwner": "Klientas nepriskirtas",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Serviso įrašų nėra} one {# serviso įrašas} few {# serviso įrašai} other {# serviso įrašų}}",
+    "lastService": "Paskutinis servisas {date}",
+    "registryNotFound": "{source} neturi transporto priemonės su tokiu numeriu",
+    "registryFailed": "Nepavyko užklausti {source}",
+    "registryFailedGeneric": "Nepavyko užklausti registro",
+    "fromSource": "Iš {source}",
+    "registered": "Registruota",
+    "notRegistered": "Neregistruota",
+    "vin": "VIN",
+    "copyVin": "Kopijuoti VIN",
+    "copied": "Nukopijuota",
+    "fuel": "Degalai",
+    "transmission": "Pavarų dėžė",
+    "engine": "Variklis",
+    "engineCode": "Variklio kodas",
+    "color": "Spalva",
+    "vehicleClass": "Klasė",
+    "firstRegistered": "Pirmoji registracija",
+    "inspectionDue": "Apžiūra iki",
+    "lastInspected": "Paskutinė apžiūra",
+    "weights": "Masės",
+    "weightsValue": "{kerb} kg be krovinio, {gross} kg maks.",
+    "kerbOnly": "{kerb} kg be krovinio",
+    "grossOnly": "{gross} kg maks.",
+    "tyres": "Padangos",
+    "axle": "{n} ašis",
+    "tyreSize": "Padanga",
+    "rimSize": "Ratlankis",
+    "loadSpeed": "Apkrova / greitis",
+    "overdue": "Pradelsta",
+    "dueSoon": "Netrukus",
+    "emptyTitle": "Ieškokite bet kurio numerio",
+    "emptyBody": "Pamatykite transporto priemonę, kam ji čia priklauso ir ką apie ją turi {source}. Dar ne jūsų? Pridėkite vienu žingsniu.",
+    "registryWord": "registras"
   }
 }

+ 58 - 0
messages/nb/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Oppdater listen",
     "timeZoneRequired": "Verkstedets tidssone står på automatisk, så bestillingstider ville fulgt nettleseren som sist lagret innstillinger (nå {zone}). Påminnelser kan ikke sendes før en sone er valgt.",
     "timeZoneRequiredLink": "Velg den under Lokalisering"
+  },
+  "plateLookup": {
+    "open": "Skiltoppslag",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Skiltoppslag",
+    "description": "Skriv inn et registreringsnummer for å se hva verkstedet og kjøretøyregisteret vet om det",
+    "placeholder": "Skriv inn et skilt",
+    "search": "Slå opp",
+    "hintEnter": "Enter for å slå opp",
+    "hintClose": "Esc for å lukke",
+    "recent": "Nylige",
+    "clearRecent": "Tøm",
+    "looking": "Spør {source}…",
+    "lookingWorkshop": "Sjekker verkstedet…",
+    "invalid": "Det ser ikke ut som et skilt",
+    "inWorkshop": "I verkstedet ditt",
+    "inWorkshopArchived": "I verkstedet ditt, arkivert",
+    "notInWorkshop": "Ikke i verkstedet ditt enda",
+    "notInWorkshopHint": "Registeret kjenner dette kjøretøyet. Legg det til, så følger feltene under med.",
+    "notInWorkshopNoRegistry": "Legg det til for hånd, eller sjekk skiltet.",
+    "openVehicle": "Åpne kjøretøy",
+    "addVehicle": "Legg til kjøretøy",
+    "noOwner": "Ingen kunde knyttet",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Ingen servicehistorikk} one {# serviceoppføring} other {# serviceoppføringer}}",
+    "lastService": "Siste service {date}",
+    "registryNotFound": "{source} har ingen kjøretøy med det skiltet",
+    "registryFailed": "{source} kunne ikke spørres",
+    "registryFailedGeneric": "Registeret kunne ikke spørres",
+    "fromSource": "Fra {source}",
+    "registered": "Registrert",
+    "notRegistered": "Ikke registrert",
+    "vin": "Understellsnummer",
+    "copyVin": "Kopier understellsnummer",
+    "copied": "Kopiert",
+    "fuel": "Drivstoff",
+    "transmission": "Girkasse",
+    "engine": "Motor",
+    "engineCode": "Motorkode",
+    "color": "Farge",
+    "vehicleClass": "Klasse",
+    "firstRegistered": "Førstegangsregistrert",
+    "inspectionDue": "Kontrollfrist",
+    "lastInspected": "Sist godkjent",
+    "weights": "Vekter",
+    "weightsValue": "{kerb} kg egenvekt, {gross} kg totalvekt",
+    "kerbOnly": "{kerb} kg egenvekt",
+    "grossOnly": "{gross} kg totalvekt",
+    "tyres": "Dekk",
+    "axle": "Aksel {n}",
+    "tyreSize": "Dekk",
+    "rimSize": "Felg",
+    "loadSpeed": "Last / hastighet",
+    "overdue": "Forfalt",
+    "dueSoon": "Snart",
+    "emptyTitle": "Slå opp et hvilket som helst skilt",
+    "emptyBody": "Se kjøretøyet, hvem som eier det her, og hva {source} har registrert. Ikke ditt enda? Legg det til i ett steg.",
+    "registryWord": "registeret"
   }
 }

+ 58 - 0
messages/nl/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Lijst vernieuwen",
     "timeZoneRequired": "De tijdzone van de werkplaats staat op automatisch, dus boekingstijden zouden de browser volgen die het laatst opsloeg (nu {zone}). Herinneringen kunnen pas worden verstuurd als een zone is gekozen.",
     "timeZoneRequiredLink": "Kies hem onder Lokalisatie"
+  },
+  "plateLookup": {
+    "open": "Kenteken opzoeken",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Kenteken opzoeken",
+    "description": "Typ een kenteken om te zien wat je werkplaats en het voertuigregister erover weten",
+    "placeholder": "Typ een kenteken",
+    "search": "Opzoeken",
+    "hintEnter": "Enter om op te zoeken",
+    "hintClose": "Esc om te sluiten",
+    "recent": "Recent",
+    "clearRecent": "Wissen",
+    "looking": "{source} wordt bevraagd…",
+    "lookingWorkshop": "Je werkplaats wordt gecontroleerd…",
+    "invalid": "Dat lijkt geen kenteken",
+    "inWorkshop": "In je werkplaats",
+    "inWorkshopArchived": "In je werkplaats, gearchiveerd",
+    "notInWorkshop": "Nog niet in je werkplaats",
+    "notInWorkshopHint": "Het register kent dit voertuig. Voeg het toe en de velden hieronder komen mee.",
+    "notInWorkshopNoRegistry": "Voeg het met de hand toe, of controleer het kenteken.",
+    "openVehicle": "Voertuig openen",
+    "addVehicle": "Voertuig toevoegen",
+    "noOwner": "Geen klant gekoppeld",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Geen onderhoudshistorie} one {# onderhoudsbeurt} other {# onderhoudsbeurten}}",
+    "lastService": "Laatste onderhoud {date}",
+    "registryNotFound": "{source} heeft geen voertuig met dat kenteken",
+    "registryFailed": "{source} kon niet worden bevraagd",
+    "registryFailedGeneric": "Het register kon niet worden bevraagd",
+    "fromSource": "Van {source}",
+    "registered": "Geregistreerd",
+    "notRegistered": "Niet geregistreerd",
+    "vin": "VIN",
+    "copyVin": "VIN kopiëren",
+    "copied": "Gekopieerd",
+    "fuel": "Brandstof",
+    "transmission": "Versnellingsbak",
+    "engine": "Motor",
+    "engineCode": "Motorcode",
+    "color": "Kleur",
+    "vehicleClass": "Soort",
+    "firstRegistered": "Eerste toelating",
+    "inspectionDue": "Keuring vervalt",
+    "lastInspected": "Laatste keuring",
+    "weights": "Massa's",
+    "weightsValue": "{kerb} kg ledig, {gross} kg max",
+    "kerbOnly": "{kerb} kg ledig",
+    "grossOnly": "{gross} kg max",
+    "tyres": "Banden",
+    "axle": "As {n}",
+    "tyreSize": "Band",
+    "rimSize": "Velg",
+    "loadSpeed": "Last / snelheid",
+    "overdue": "Verlopen",
+    "dueSoon": "Binnenkort",
+    "emptyTitle": "Zoek elk kenteken op",
+    "emptyBody": "Zie het voertuig, van wie het hier is en wat {source} erover heeft. Nog niet van jou? Voeg het in één stap toe.",
+    "registryWord": "het register"
   }
 }

+ 58 - 0
messages/pl/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Odśwież listę",
     "timeZoneRequired": "Strefa czasowa warsztatu jest ustawiona na automatyczną, więc godziny rezerwacji zależałyby od przeglądarki, która ostatnio zapisała ustawienia (teraz {zone}). Przypomnień nie można wysłać, dopóki nie wybierzesz strefy.",
     "timeZoneRequiredLink": "Wybierz ją w Lokalizacji"
+  },
+  "plateLookup": {
+    "open": "Sprawdź tablicę",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Sprawdź tablicę",
+    "description": "Wpisz numer rejestracyjny, aby zobaczyć, co wie o nim Twój warsztat i rejestr pojazdów",
+    "placeholder": "Wpisz tablicę",
+    "search": "Sprawdź",
+    "hintEnter": "Enter, aby sprawdzić",
+    "hintClose": "Esc, aby zamknąć",
+    "recent": "Ostatnie",
+    "clearRecent": "Wyczyść",
+    "looking": "Pytam {source}…",
+    "lookingWorkshop": "Sprawdzam warsztat…",
+    "invalid": "To nie wygląda jak tablica",
+    "inWorkshop": "W Twoim warsztacie",
+    "inWorkshopArchived": "W Twoim warsztacie, zarchiwizowany",
+    "notInWorkshop": "Jeszcze nie w Twoim warsztacie",
+    "notInWorkshopHint": "Rejestr zna ten pojazd. Dodaj go, a poniższe pola wypełnią się same.",
+    "notInWorkshopNoRegistry": "Dodaj ręcznie albo sprawdź tablicę.",
+    "openVehicle": "Otwórz pojazd",
+    "addVehicle": "Dodaj pojazd",
+    "noOwner": "Brak powiązanego klienta",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Brak historii serwisowej} one {# wpis serwisowy} few {# wpisy serwisowe} other {# wpisów serwisowych}}",
+    "lastService": "Ostatni serwis {date}",
+    "registryNotFound": "{source} nie ma pojazdu o tej tablicy",
+    "registryFailed": "Nie udało się odpytać {source}",
+    "registryFailedGeneric": "Nie udało się odpytać rejestru",
+    "fromSource": "Z {source}",
+    "registered": "Zarejestrowany",
+    "notRegistered": "Niezarejestrowany",
+    "vin": "VIN",
+    "copyVin": "Kopiuj VIN",
+    "copied": "Skopiowano",
+    "fuel": "Paliwo",
+    "transmission": "Skrzynia biegów",
+    "engine": "Silnik",
+    "engineCode": "Kod silnika",
+    "color": "Kolor",
+    "vehicleClass": "Klasa",
+    "firstRegistered": "Pierwsza rejestracja",
+    "inspectionDue": "Przegląd do",
+    "lastInspected": "Ostatni przegląd",
+    "weights": "Masy",
+    "weightsValue": "{kerb} kg własna, {gross} kg maks.",
+    "kerbOnly": "{kerb} kg własna",
+    "grossOnly": "{gross} kg maks.",
+    "tyres": "Opony",
+    "axle": "Oś {n}",
+    "tyreSize": "Opona",
+    "rimSize": "Felga",
+    "loadSpeed": "Nośność / prędkość",
+    "overdue": "Po terminie",
+    "dueSoon": "Wkrótce",
+    "emptyTitle": "Sprawdź dowolną tablicę",
+    "emptyBody": "Zobacz pojazd, kto jest tu jego właścicielem i co ma o nim {source}. Jeszcze nie Twój? Dodaj go jednym krokiem.",
+    "registryWord": "rejestr"
   }
 }

+ 58 - 0
messages/pt-BR/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Atualizar lista",
     "timeZoneRequired": "O fuso horário da oficina está em automático, então os horários de agendamento seguiriam o último navegador que salvou configurações (agora {zone}). Lembretes não podem ser enviados até escolher um fuso.",
     "timeZoneRequiredLink": "Escolha em Localização"
+  },
+  "plateLookup": {
+    "open": "Consultar placa",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Consultar placa",
+    "description": "Digite uma placa para ver o que a sua oficina e o registro de veículos sabem sobre ela",
+    "placeholder": "Digite uma placa",
+    "search": "Consultar",
+    "hintEnter": "Enter para consultar",
+    "hintClose": "Esc para fechar",
+    "recent": "Recentes",
+    "clearRecent": "Limpar",
+    "looking": "Consultando {source}…",
+    "lookingWorkshop": "Verificando sua oficina…",
+    "invalid": "Isso não parece uma placa",
+    "inWorkshop": "Na sua oficina",
+    "inWorkshopArchived": "Na sua oficina, arquivado",
+    "notInWorkshop": "Ainda não está na sua oficina",
+    "notInWorkshopHint": "O registro conhece este veículo. Adicione-o e os campos abaixo vêm junto.",
+    "notInWorkshopNoRegistry": "Adicione manualmente, ou confira a placa.",
+    "openVehicle": "Abrir veículo",
+    "addVehicle": "Adicionar veículo",
+    "noOwner": "Nenhum cliente vinculado",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Sem registros de serviço} one {# registro de serviço} other {# registros de serviço}}",
+    "lastService": "Último serviço {date}",
+    "registryNotFound": "{source} não tem nenhum veículo com essa placa",
+    "registryFailed": "Não foi possível consultar {source}",
+    "registryFailedGeneric": "Não foi possível consultar o registro",
+    "fromSource": "De {source}",
+    "registered": "Registrado",
+    "notRegistered": "Não registrado",
+    "vin": "VIN",
+    "copyVin": "Copiar VIN",
+    "copied": "Copiado",
+    "fuel": "Combustível",
+    "transmission": "Câmbio",
+    "engine": "Motor",
+    "engineCode": "Código do motor",
+    "color": "Cor",
+    "vehicleClass": "Classe",
+    "firstRegistered": "Primeiro registro",
+    "inspectionDue": "Inspeção vence",
+    "lastInspected": "Última inspeção",
+    "weights": "Pesos",
+    "weightsValue": "{kerb} kg em ordem de marcha, {gross} kg máx.",
+    "kerbOnly": "{kerb} kg em ordem de marcha",
+    "grossOnly": "{gross} kg máx.",
+    "tyres": "Pneus",
+    "axle": "Eixo {n}",
+    "tyreSize": "Pneu",
+    "rimSize": "Roda",
+    "loadSpeed": "Carga / velocidade",
+    "overdue": "Vencida",
+    "dueSoon": "Em breve",
+    "emptyTitle": "Consulte qualquer placa",
+    "emptyBody": "Veja o veículo, de quem é aqui e o que {source} tem registrado. Ainda não é seu? Adicione em um passo.",
+    "registryWord": "o registro"
   }
 }

+ 58 - 0
messages/ru/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Обновить список",
     "timeZoneRequired": "Часовой пояс мастерской стоит на автоматическом, поэтому время записи зависело бы от браузера, сохранившего настройки последним (сейчас {zone}). Напоминания нельзя отправить, пока пояс не выбран.",
     "timeZoneRequiredLink": "Выберите в Локализации"
+  },
+  "plateLookup": {
+    "open": "Поиск по номеру",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Поиск по номеру",
+    "description": "Введите регистрационный номер, чтобы увидеть, что о нём знают ваша мастерская и реестр транспортных средств",
+    "placeholder": "Введите номер",
+    "search": "Найти",
+    "hintEnter": "Enter для поиска",
+    "hintClose": "Esc для закрытия",
+    "recent": "Недавние",
+    "clearRecent": "Очистить",
+    "looking": "Запрос в {source}…",
+    "lookingWorkshop": "Проверка мастерской…",
+    "invalid": "Это не похоже на номер",
+    "inWorkshop": "В вашей мастерской",
+    "inWorkshopArchived": "В вашей мастерской, в архиве",
+    "notInWorkshop": "Пока не в вашей мастерской",
+    "notInWorkshopHint": "Реестр знает этот автомобиль. Добавьте его, и поля ниже заполнятся.",
+    "notInWorkshopNoRegistry": "Добавьте вручную или проверьте номер.",
+    "openVehicle": "Открыть автомобиль",
+    "addVehicle": "Добавить автомобиль",
+    "noOwner": "Клиент не привязан",
+    "mileage": "{km} км",
+    "services": "{count, plural, =0 {Нет записей о сервисе} one {# запись о сервисе} few {# записи о сервисе} other {# записей о сервисе}}",
+    "lastService": "Последний сервис {date}",
+    "registryNotFound": "В {source} нет автомобиля с таким номером",
+    "registryFailed": "Не удалось запросить {source}",
+    "registryFailedGeneric": "Не удалось запросить реестр",
+    "fromSource": "Из {source}",
+    "registered": "Зарегистрирован",
+    "notRegistered": "Не зарегистрирован",
+    "vin": "VIN",
+    "copyVin": "Скопировать VIN",
+    "copied": "Скопировано",
+    "fuel": "Топливо",
+    "transmission": "Коробка передач",
+    "engine": "Двигатель",
+    "engineCode": "Код двигателя",
+    "color": "Цвет",
+    "vehicleClass": "Класс",
+    "firstRegistered": "Первая регистрация",
+    "inspectionDue": "Техосмотр до",
+    "lastInspected": "Последний техосмотр",
+    "weights": "Массы",
+    "weightsValue": "{kerb} кг снаряжённая, {gross} кг макс.",
+    "kerbOnly": "{kerb} кг снаряжённая",
+    "grossOnly": "{gross} кг макс.",
+    "tyres": "Шины",
+    "axle": "Ось {n}",
+    "tyreSize": "Шина",
+    "rimSize": "Диск",
+    "loadSpeed": "Нагрузка / скорость",
+    "overdue": "Просрочен",
+    "dueSoon": "Скоро",
+    "emptyTitle": "Найдите любой номер",
+    "emptyBody": "Посмотрите автомобиль, кто его владелец здесь и что о нём есть в {source}. Ещё не ваш? Добавьте за один шаг.",
+    "registryWord": "реестр"
   }
 }

+ 58 - 0
messages/tr/vehicles.json

@@ -462,5 +462,63 @@
     "refresh": "Listeyi yenile",
     "timeZoneRequired": "Atölyenin saat dilimi otomatik olduğundan randevu saatleri ayarları en son kaydeden tarayıcıyı izlerdi (şu anda {zone}). Bir dilim seçilene kadar hatırlatma gönderilemez.",
     "timeZoneRequiredLink": "Yerelleştirme altından seçin"
+  },
+  "plateLookup": {
+    "open": "Plaka sorgula",
+    "shortcut": "Ctrl+Shift+L",
+    "title": "Plaka sorgula",
+    "description": "Atölyenizin ve araç sicilinin bir plaka hakkında bildiklerini görmek için plakayı yazın",
+    "placeholder": "Bir plaka yazın",
+    "search": "Sorgula",
+    "hintEnter": "Sorgulamak için Enter",
+    "hintClose": "Kapatmak için Esc",
+    "recent": "Son aramalar",
+    "clearRecent": "Temizle",
+    "looking": "{source} sorgulanıyor…",
+    "lookingWorkshop": "Atölyeniz kontrol ediliyor…",
+    "invalid": "Bu bir plakaya benzemiyor",
+    "inWorkshop": "Atölyenizde",
+    "inWorkshopArchived": "Atölyenizde, arşivlenmiş",
+    "notInWorkshop": "Henüz atölyenizde değil",
+    "notInWorkshopHint": "Sicil bu aracı tanıyor. Ekleyin, aşağıdaki alanlar da gelsin.",
+    "notInWorkshopNoRegistry": "Elle ekleyin veya plakayı kontrol edin.",
+    "openVehicle": "Aracı aç",
+    "addVehicle": "Araç ekle",
+    "noOwner": "Bağlı müşteri yok",
+    "mileage": "{km} km",
+    "services": "{count, plural, =0 {Servis kaydı yok} one {# servis kaydı} other {# servis kaydı}}",
+    "lastService": "Son servis {date}",
+    "registryNotFound": "{source} sicilinde bu plakaya sahip araç yok",
+    "registryFailed": "{source} sorgulanamadı",
+    "registryFailedGeneric": "Sicil sorgulanamadı",
+    "fromSource": "Kaynak: {source}",
+    "registered": "Tescilli",
+    "notRegistered": "Tescilli değil",
+    "vin": "VIN",
+    "copyVin": "VIN'i kopyala",
+    "copied": "Kopyalandı",
+    "fuel": "Yakıt",
+    "transmission": "Şanzıman",
+    "engine": "Motor",
+    "engineCode": "Motor kodu",
+    "color": "Renk",
+    "vehicleClass": "Sınıf",
+    "firstRegistered": "İlk tescil",
+    "inspectionDue": "Muayene tarihi",
+    "lastInspected": "Son muayene",
+    "weights": "Ağırlıklar",
+    "weightsValue": "{kerb} kg boş, {gross} kg azami",
+    "kerbOnly": "{kerb} kg boş",
+    "grossOnly": "{gross} kg azami",
+    "tyres": "Lastikler",
+    "axle": "{n}. aks",
+    "tyreSize": "Lastik",
+    "rimSize": "Jant",
+    "loadSpeed": "Yük / hız",
+    "overdue": "Süresi geçti",
+    "dueSoon": "Yaklaşıyor",
+    "emptyTitle": "Herhangi bir plakayı sorgulayın",
+    "emptyBody": "Aracı, burada kime ait olduğunu ve {source} kaydında ne olduğunu görün. Henüz sizin değil mi? Tek adımda ekleyin.",
+    "registryWord": "sicil"
   }
 }

+ 174 - 0
src/__tests__/features/vehicles/plate-lookup.test.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/cached-session', () => ({
+  getCachedSession: vi.fn(),
+  getCachedMembership: vi.fn(),
+}))
+vi.mock('@/lib/features', () => ({ getFeatures: vi.fn() }))
+vi.mock('@/features/integrations/Lib/vehicle-lookup', () => ({
+  findLookupConnection: vi.fn(),
+  askRegistry: vi.fn(),
+  withinLookupBudget: vi.fn(() => true),
+}))
+vi.mock('@/features/integrations/Lib/inspection-sync', () => ({
+  recordRegistryAnswer: vi.fn(async () => undefined),
+}))
+vi.mock('@/lib/db', () => ({
+  db: {
+    $queryRaw: vi.fn(),
+    user: { findUnique: vi.fn(async () => ({ isSuperAdmin: false })) },
+    vehicle: { findUnique: vi.fn(), findFirst: vi.fn() },
+  },
+}))
+
+import { recordRegistryAnswer } from '@/features/integrations/Lib/inspection-sync'
+import { askRegistry, findLookupConnection } from '@/features/integrations/Lib/vehicle-lookup'
+import { lookupPlate } from '@/features/vehicles/Actions/plateLookupActions'
+import { compactPlate, looksLikePlate } from '@/features/vehicles/Lib/plate'
+import { getCachedMembership, getCachedSession } from '@/lib/cached-session'
+import { db } from '@/lib/db'
+import { getFeatures } from '@/lib/features'
+
+const ROW = {
+  id: 'v1',
+  make: 'Toyota',
+  model: 'Prius+',
+  year: 2018,
+  licensePlate: 'SK-209-X',
+  vin: 'JTDZN3EU0E3298500',
+  color: 'Zwart',
+  mileage: 84210,
+  imageUrl: null,
+  isArchived: false,
+  customer: { id: 'c1', name: 'Anna de Vries', company: null, phone: '+31 6 1234' },
+  inspectionStatus: { dueAt: new Date('2027-04-26T00:00:00Z') },
+  _count: { serviceRecords: 3 },
+  serviceRecords: [{ serviceDate: new Date('2026-05-02T09:00:00Z') }],
+}
+
+const REGISTRY = {
+  result: { make: 'Toyota', model: 'PRIUS PLUS', year: 2018, vin: 'JTDZN3EU0E3298500' },
+  source: 'RDW Open Data',
+  connectorId: 'rdw',
+}
+
+function signIn() {
+  vi.mocked(getCachedSession).mockResolvedValue({
+    user: { id: 'u1', email: 'a@b.c', name: 'A', isSuperAdmin: false },
+  } as never)
+  vi.mocked(getCachedMembership).mockResolvedValue({
+    organizationId: 'org1',
+    role: 'owner',
+    roleId: null,
+    customRole: null,
+  } as never)
+}
+
+describe('plate helpers', () => {
+  it('compacts what people type to what registries and comparisons take', () => {
+    expect(compactPlate('sk-209-x')).toBe('SK209X')
+    expect(compactPlate(' AB 123 CD ')).toBe('AB123CD')
+    expect(compactPlate('90-27-QL')).toBe('9027QL')
+  })
+
+  it('knows a plate from a stray keystroke', () => {
+    expect(looksLikePlate('SK209X')).toBe(true)
+    expect(looksLikePlate('a')).toBe(false)
+    expect(looksLikePlate('')).toBe(false)
+    expect(looksLikePlate('ABCDEFGHIJKLM')).toBe(false)
+  })
+})
+
+describe('lookupPlate', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    signIn()
+    vi.mocked(getFeatures).mockResolvedValue({ integrations: true } as never)
+    vi.mocked(findLookupConnection).mockResolvedValue({ id: 'conn1', connectorId: 'rdw' })
+    vi.mocked(askRegistry).mockResolvedValue(REGISTRY)
+    vi.mocked(db.$queryRaw).mockResolvedValue([])
+    vi.mocked(db.vehicle.findUnique).mockResolvedValue(null)
+    vi.mocked(db.vehicle.findFirst).mockResolvedValue(null)
+  })
+
+  it('finds the workshop vehicle by compacted plate and records the registry answer on it', async () => {
+    vi.mocked(db.$queryRaw).mockResolvedValue([{ id: 'v1' }])
+    vi.mocked(db.vehicle.findUnique).mockResolvedValue(ROW as never)
+    const res = await lookupPlate({ plate: 'sk 209 x' })
+    expect(res.success).toBe(true)
+    const data = res.data
+    expect(data?.plate).toBe('SK209X')
+    expect(data?.vehicle).toMatchObject({
+      id: 'v1',
+      make: 'Toyota',
+      customer: { name: 'Anna de Vries' },
+      inspectionDueAt: '2027-04-26T00:00:00.000Z',
+      serviceCount: 3,
+      lastServiceAt: '2026-05-02T09:00:00.000Z',
+    })
+    expect(data?.registry).toMatchObject({ make: 'Toyota', source: 'RDW Open Data' })
+    expect(askRegistry).toHaveBeenCalledWith('conn1', { plate: 'SK209X' })
+    // The compacted plate, not the typed one, is what the SQL compares against.
+    const sql = vi.mocked(db.$queryRaw).mock.calls[0]
+    expect(sql.slice(1)).toContain('SK209X')
+    expect(recordRegistryAnswer).toHaveBeenCalledWith(
+      expect.objectContaining({ vehicleId: 'v1', source: 'rdw', result: REGISTRY.result })
+    )
+  })
+
+  it('falls back to the registry VIN when the plate is new to the workshop', async () => {
+    vi.mocked(db.vehicle.findFirst).mockResolvedValue({
+      ...ROW,
+      licensePlate: 'OLD-PLATE',
+    } as never)
+    const res = await lookupPlate({ plate: 'SK209X' })
+    expect(res.data?.vehicle?.licensePlate).toBe('OLD-PLATE')
+    expect(db.vehicle.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          vin: { equals: 'JTDZN3EU0E3298500', mode: 'insensitive' },
+        }),
+      })
+    )
+  })
+
+  it('still answers from the workshop when the registry fails, and says why', async () => {
+    vi.mocked(db.$queryRaw).mockResolvedValue([{ id: 'v1' }])
+    vi.mocked(db.vehicle.findUnique).mockResolvedValue(ROW as never)
+    vi.mocked(askRegistry).mockRejectedValue(new Error('RDW is throttling requests'))
+    const res = await lookupPlate({ plate: 'SK209X' })
+    expect(res.data?.vehicle?.id).toBe('v1')
+    expect(res.data?.registry).toBeNull()
+    expect(res.data?.registryError).toBe('RDW is throttling requests')
+    expect(recordRegistryAnswer).not.toHaveBeenCalled()
+  })
+
+  it('reports a miss on both sides without an error', async () => {
+    vi.mocked(askRegistry).mockResolvedValue({ ...REGISTRY, result: null })
+    const res = await lookupPlate({ plate: 'ZZ99ZZZ' })
+    expect(res.data).toMatchObject({
+      plate: 'ZZ99ZZZ',
+      vehicle: null,
+      registry: null,
+      registryError: null,
+      source: 'RDW Open Data',
+    })
+  })
+
+  it('leaves the registry alone when none is connected or the plan has no integrations', async () => {
+    vi.mocked(findLookupConnection).mockResolvedValue(null)
+    const res = await lookupPlate({ plate: 'SK209X' })
+    expect(res.data?.source).toBeNull()
+    expect(askRegistry).not.toHaveBeenCalled()
+    vi.mocked(getFeatures).mockResolvedValue({ integrations: false } as never)
+    await lookupPlate({ plate: 'SK209X' })
+    expect(findLookupConnection).toHaveBeenCalledTimes(1)
+  })
+
+  it('refuses something that is not a plate', async () => {
+    const res = await lookupPlate({ plate: '?' })
+    expect(res.success).toBe(false)
+    expect(res.error).toMatch(/not look like a plate/)
+    expect(db.$queryRaw).not.toHaveBeenCalled()
+  })
+})

+ 54 - 23
src/app/(authenticated)/layout.tsx

@@ -28,6 +28,10 @@ import { LicenseExpiryProvider } from '@/components/license-expiry-context'
 import { db } from '@/lib/db'
 import { isDemoMode } from '@/lib/demo'
 import { isTireHotelEnabled } from '@/features/tire-hotel/Lib/tireHotelSettings'
+import { findLookupConnection } from '@/features/integrations/Lib/vehicle-lookup'
+import { getManifest } from '@/integrations/registry'
+import { PlateLookupProvider } from '@/components/plate-lookup-context'
+import { PlateLookupCommand } from '@/features/vehicles/Components/PlateLookupCommand'
 
 export default async function DashboardLayout({ children }: { children: React.ReactNode }) {
   const data = await getLayoutData()
@@ -89,6 +93,8 @@ export default async function DashboardLayout({ children }: { children: React.Re
    * refused, one at a time.
    */
   let hasAnyAccess = true
+  /** Whether the plate lookup may offer to add a vehicle it did not find. */
+  let canCreateVehicles = true
 
   if (!isOwnerOrAdmin) {
     const membership = await getCachedMembership(data.userId)
@@ -101,6 +107,10 @@ export default async function DashboardLayout({ children }: { children: React.Re
           subject: subject as PermissionSubject,
         })
       )
+      canCreateVehicles = hasPermission(userPermissions, {
+        action: PermissionAction.CREATE,
+        subject: PermissionSubject.VEHICLES,
+      })
       // A role that grants nothing readable. Every page behind the nav would
       // answer "Your role does not allow this", so say it once instead.
       hasAnyAccess = visibleSubjects.length > 0
@@ -123,6 +133,18 @@ export default async function DashboardLayout({ children }: { children: React.Re
     seen: seenHints,
   })
 
+  // The header offers a plate lookup once a vehicle registry is connected.
+  // Resolved here so the first paint knows, rather than a button appearing a
+  // beat after the page does.
+  const lookupConnection =
+    features.integrations && visibleSubjects.includes(PermissionSubject.VEHICLES)
+      ? await findLookupConnection(data.organizationId)
+      : null
+  const plateLookupAvailable = lookupConnection !== null
+  const plateLookupRegistry = lookupConnection
+    ? (getManifest(lookupConnection.connectorId)?.name ?? null)
+    : null
+
   // Check license expiry (only for admin/owner with white-label)
   let daysUntilExpiry: number | null = null
   let licenseExpiryDismissed = false
@@ -189,34 +211,43 @@ export default async function DashboardLayout({ children }: { children: React.Re
                 currencyFormat={data.currencyFormat}
               >
                 <ConfirmProvider>
-                  <FeatureHintProvider
-                    initialSeen={seenHints}
-                    pending={[...pendingHints, ...announcements]}
+                  <PlateLookupProvider
+                    value={{
+                      available: plateLookupAvailable,
+                      canCreate: canCreateVehicles,
+                      registryName: plateLookupRegistry,
+                    }}
                   >
-                    <AppSidebar
-                      companyLogo={data.companyLogo}
-                      organizations={data.organizations}
-                      activeOrgId={data.organizationId}
-                      isSuperAdmin={data.isSuperAdmin}
-                      features={features}
-                      tireHotelEnabled={tireHotelEnabled}
-                      visibleSubjects={visibleSubjects}
-                      announcement={announcements[0] ?? null}
-                      isAdminOrOwner={isOwnerOrAdmin}
-                    />
-                    <SidebarInset>
-                      {/* A flex column with a real height, so the `flex-1` every
+                    <FeatureHintProvider
+                      initialSeen={seenHints}
+                      pending={[...pendingHints, ...announcements]}
+                    >
+                      <AppSidebar
+                        companyLogo={data.companyLogo}
+                        organizations={data.organizations}
+                        activeOrgId={data.organizationId}
+                        isSuperAdmin={data.isSuperAdmin}
+                        features={features}
+                        tireHotelEnabled={tireHotelEnabled}
+                        visibleSubjects={visibleSubjects}
+                        announcement={announcements[0] ?? null}
+                        isAdminOrOwner={isOwnerOrAdmin}
+                      />
+                      <SidebarInset>
+                        {/* A flex column with a real height, so the `flex-1` every
                           page already writes on its wrapper actually resolves.
                           Without it a page that wants to fill the window (the
                           work board's week timeline) stopped at its content and
                           left the rest of the screen blank. */}
-                      <div className="flex min-h-0 flex-1 flex-col pb-14 md:pb-0">{children}</div>
-                    </SidebarInset>
-                    <SearchCommand />
-                    {isOwnerOrAdmin && <NotificationInitializer />}
-                    <OnlineTracker />
-                    <InstallBanner />
-                  </FeatureHintProvider>
+                        <div className="flex min-h-0 flex-1 flex-col pb-14 md:pb-0">{children}</div>
+                      </SidebarInset>
+                      <SearchCommand />
+                      <PlateLookupCommand />
+                      {isOwnerOrAdmin && <NotificationInitializer />}
+                      <OnlineTracker />
+                      <InstallBanner />
+                    </FeatureHintProvider>
+                  </PlateLookupProvider>
                 </ConfirmProvider>
               </CurrencySettingsProvider>
             </DateSettingsProvider>

+ 31 - 0
src/components/page-header.tsx

@@ -16,6 +16,7 @@ import { Button } from '@/components/ui/button'
 import { Separator } from '@/components/ui/separator'
 import { SidebarTrigger } from '@/components/ui/sidebar'
 import { AlertTriangle, Search, X, Zap } from 'lucide-react'
+import { openPlateLookup, usePlateLookupAccess } from '@/components/plate-lookup-context'
 import { useShowWhiteLabelCta } from '@/components/white-label-cta-context'
 import { useLicenseExpiry } from '@/components/license-expiry-context'
 import { BANNER_PRIORITY, useBannerSlot } from '@/components/banner-slot'
@@ -41,6 +42,35 @@ function SearchTrigger() {
   )
 }
 
+/**
+ * The plate lookup, drawn as the thing it looks up: a small plate beside
+ * the word. Only rendered once a registry is connected, so a workshop that
+ * has none never sees a button that would only explain itself away.
+ */
+function PlateTrigger() {
+  const t = useTranslations('vehicles.plateLookup')
+  const { available } = usePlateLookupAccess()
+  if (!available) return null
+  return (
+    <button
+      type="button"
+      className="group flex h-8 cursor-pointer items-center gap-2 rounded-md border bg-muted/50 px-2.5 text-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+      onClick={() => openPlateLookup()}
+      aria-label={t('open')}
+      title={`${t('open')} (${t('shortcut')})`}
+    >
+      <span
+        aria-hidden
+        className="flex h-4 items-center overflow-hidden rounded-[3px] border border-foreground/40 bg-background font-mono text-[9px] font-semibold leading-none tracking-wider text-foreground/80"
+      >
+        <span className="h-full w-1.5 bg-primary/80" />
+        <span className="px-1">AB 123</span>
+      </span>
+      <span className="hidden lg:inline">{t('open')}</span>
+    </button>
+  )
+}
+
 type BreadcrumbSegment = { key: string; href?: string }
 
 /**
@@ -262,6 +292,7 @@ export function PageHeader() {
         </Breadcrumb>
         <div className="ml-auto flex items-center gap-2">
           {docsHref && <DocsLink href={docsHref} variant="header" className="hidden sm:flex" />}
+          <PlateTrigger />
           <SearchTrigger />
           <QuickCreateMenu />
           {showWhiteLabelCta && (

+ 43 - 0
src/components/plate-lookup-context.tsx

@@ -0,0 +1,43 @@
+'use client'
+
+import { createContext, useContext } from 'react'
+
+export interface PlateLookupAccess {
+  /** A registry with plate lookup is connected and the plan allows integrations. */
+  available: boolean
+  /** The signed-in account may add vehicles, so a miss can offer to. */
+  canCreate: boolean
+  /** The connected registry's name, such as "RDW Open Data", for the palette's wording. */
+  registryName: string | null
+}
+
+const PlateLookupContext = createContext<PlateLookupAccess>({
+  available: false,
+  canCreate: false,
+  registryName: null,
+})
+
+/**
+ * Resolved once in the layout so the header knows on first paint whether to
+ * show the plate lookup, instead of every page asking the server again.
+ */
+export function PlateLookupProvider({
+  value,
+  children,
+}: {
+  value: PlateLookupAccess
+  children: React.ReactNode
+}) {
+  return <PlateLookupContext.Provider value={value}>{children}</PlateLookupContext.Provider>
+}
+
+export function usePlateLookupAccess() {
+  return useContext(PlateLookupContext)
+}
+
+/** The event the header trigger fires; the palette listens for it. */
+export const PLATE_LOOKUP_EVENT = 'torqvoice:plate-lookup'
+
+export function openPlateLookup(plate?: string) {
+  document.dispatchEvent(new CustomEvent(PLATE_LOOKUP_EVENT, { detail: { plate } }))
+}

+ 11 - 68
src/features/integrations/Actions/vehicleLookupActions.ts

@@ -4,84 +4,29 @@ import { db } from '@/lib/db'
 import { getFeatures } from '@/lib/features'
 import { PermissionAction, PermissionSubject } from '@/lib/permissions'
 import { withAuth } from '@/lib/with-auth'
-import { SETTING_KEYS } from '@/features/settings/Schema/settingsSchema'
-import { getManifest } from '@/integrations/registry'
-import { loadConnection } from '../Lib/connections'
 import { recordRegistryAnswer } from '../Lib/inspection-sync'
 import type { VehicleLookupResult } from '../Lib/types'
+import { askRegistry, findLookupConnection, withinLookupBudget } from '../Lib/vehicle-lookup'
 
 /**
- * Plate and VIN lookups against whichever vehicle registry the workshop has
- * connected. The form asks here rather than knowing about connectors, so a
- * second country's registry is a new folder under src/integrations and
- * nothing else.
+ * The form's plate and VIN lookups. The registry logic lives in
+ * Lib/vehicle-lookup so the header's plate palette can ask the same way.
  */
 
-const CAPABILITY = 'vehicle.lookup'
 const READ_VEHICLES = [{ action: PermissionAction.READ, subject: PermissionSubject.VEHICLES }]
 
-/**
- * How many lookups an organisation may make per minute. A registry key has a
- * daily quota that belongs to the workshop, and one stuck retry loop or a
- * pasted spreadsheet should not spend it. Generous for a person at a form.
- */
-const LOOKUPS_PER_MINUTE = 30
-const budgets = new Map<string, { count: number; resetAt: number }>()
-
-function withinBudget(organizationId: string): boolean {
-  const now = Date.now()
-  const entry = budgets.get(organizationId)
-  if (!entry || entry.resetAt <= now) {
-    budgets.set(organizationId, { count: 1, resetAt: now + 60_000 })
-    return true
-  }
-  entry.count += 1
-  return entry.count <= LOOKUPS_PER_MINUTE
-}
-
 export interface VehicleLookup extends VehicleLookupResult {
   /** Registry name for the attribution line, such as "Statens vegvesen". */
   source: string
 }
 
-/**
- * The active connection that can answer, preferring one for the workshop's
- * own country when more than one registry is connected.
- */
-async function lookupConnection(
-  organizationId: string
-): Promise<{ id: string; connectorId: string } | null> {
-  const [rows, countrySetting] = await Promise.all([
-    db.integrationConnection.findMany({
-      where: { organizationId, status: 'active' },
-      select: { id: true, connectorId: true },
-    }),
-    db.appSetting.findUnique({
-      where: {
-        organizationId_key: { organizationId, key: SETTING_KEYS.WORKSHOP_DEFAULT_COUNTRY_CODE },
-      },
-      select: { value: true },
-    }),
-  ])
-  const country = countrySetting?.value?.toUpperCase() ?? null
-  const candidates = rows.filter((r) =>
-    getManifest(r.connectorId)?.capabilities.includes(CAPABILITY)
-  )
-  if (candidates.length === 0) return null
-  const local = candidates.find((r) => {
-    const countries = getManifest(r.connectorId)?.countries
-    return country && Array.isArray(countries) && countries.includes(country)
-  })
-  return local ?? candidates[0]
-}
-
 /** Whether the form should offer a lookup at all: plan on, registry connected. */
 export async function isVehicleLookupAvailable() {
   return withAuth(
     async ({ organizationId }) => {
       const features = await getFeatures(organizationId)
       if (!features.integrations) return false
-      return (await lookupConnection(organizationId)) !== null
+      return (await findLookupConnection(organizationId)) !== null
     },
     { requiredPermissions: READ_VEHICLES }
   )
@@ -102,14 +47,12 @@ export async function lookupVehicle(query: { plate?: string; vin?: string; vehic
         throw new Error('That does not look like a plate or VIN')
       const features = await getFeatures(organizationId)
       if (!features.integrations) throw new Error('Integrations are not included in your plan')
-      const target = await lookupConnection(organizationId)
+      const target = await findLookupConnection(organizationId)
       if (!target) throw new Error('No vehicle registry is connected')
-      if (!withinBudget(organizationId))
+      if (!withinLookupBudget(organizationId))
         throw new Error('Too many lookups, wait a minute and try again')
 
-      const { ctx, server } = await loadConnection(target.id)
-      if (!server.lookupVehicle) throw new Error('This integration cannot look up vehicles')
-      const result = await server.lookupVehicle(ctx, {
+      const answer = await askRegistry(target.id, {
         plate: plate || undefined,
         vin: vin || undefined,
       })
@@ -122,13 +65,13 @@ export async function lookupVehicle(query: { plate?: string; vin?: string; vehic
           await recordRegistryAnswer({
             organizationId,
             vehicleId: owned.id,
-            source: target.connectorId,
-            result,
+            source: answer.connectorId,
+            result: answer.result,
           })
         }
       }
-      if (!result) return null
-      return { ...result, source: server.manifest.name }
+      if (!answer.result) return null
+      return { ...answer.result, source: answer.source }
     },
     { requiredPermissions: READ_VEHICLES }
   )

+ 83 - 0
src/features/integrations/Lib/vehicle-lookup.ts

@@ -0,0 +1,83 @@
+import { SETTING_KEYS } from '@/features/settings/Schema/settingsSchema'
+import { getManifest } from '@/integrations/registry'
+import { db } from '@/lib/db'
+import { loadConnection } from './connections'
+import type { VehicleLookupQuery, VehicleLookupResult } from './types'
+
+/**
+ * Plate and VIN lookups against whichever vehicle registry the workshop has
+ * connected. Actions ask here rather than knowing about connectors, so a
+ * second country's registry is a new folder under src/integrations and
+ * nothing else.
+ */
+
+export const LOOKUP_CAPABILITY = 'vehicle.lookup'
+
+/**
+ * How many lookups an organisation may make per minute. A registry key has a
+ * daily quota that belongs to the workshop, and some registries bill per
+ * call, so one stuck retry loop or a pasted spreadsheet should not spend it.
+ * Generous for a person at a form.
+ */
+const LOOKUPS_PER_MINUTE = 30
+const budgets = new Map<string, { count: number; resetAt: number }>()
+
+export function withinLookupBudget(organizationId: string): boolean {
+  const now = Date.now()
+  const entry = budgets.get(organizationId)
+  if (!entry || entry.resetAt <= now) {
+    budgets.set(organizationId, { count: 1, resetAt: now + 60_000 })
+    return true
+  }
+  entry.count += 1
+  return entry.count <= LOOKUPS_PER_MINUTE
+}
+
+/**
+ * The active connection that can answer, preferring one for the workshop's
+ * own country when more than one registry is connected.
+ */
+export async function findLookupConnection(
+  organizationId: string
+): Promise<{ id: string; connectorId: string } | null> {
+  const [rows, countrySetting] = await Promise.all([
+    db.integrationConnection.findMany({
+      where: { organizationId, status: 'active' },
+      select: { id: true, connectorId: true },
+    }),
+    db.appSetting.findUnique({
+      where: {
+        organizationId_key: { organizationId, key: SETTING_KEYS.WORKSHOP_DEFAULT_COUNTRY_CODE },
+      },
+      select: { value: true },
+    }),
+  ])
+  const country = countrySetting?.value?.toUpperCase() ?? null
+  const candidates = rows.filter((r) =>
+    getManifest(r.connectorId)?.capabilities.includes(LOOKUP_CAPABILITY)
+  )
+  if (candidates.length === 0) return null
+  const local = candidates.find((r) => {
+    const countries = getManifest(r.connectorId)?.countries
+    return country && Array.isArray(countries) && countries.includes(country)
+  })
+  return local ?? candidates[0]
+}
+
+export interface RegistryAnswer {
+  result: VehicleLookupResult | null
+  /** Registry name for the attribution line, such as "Statens vegvesen". */
+  source: string
+  connectorId: string
+}
+
+/** One lookup through the given connection. Throws with the connector's own reason when it fails. */
+export async function askRegistry(
+  connectionId: string,
+  query: VehicleLookupQuery
+): Promise<RegistryAnswer> {
+  const { ctx, server } = await loadConnection(connectionId)
+  if (!server.lookupVehicle) throw new Error('This integration cannot look up vehicles')
+  const result = await server.lookupVehicle(ctx, query)
+  return { result, source: server.manifest.name, connectorId: server.manifest.id }
+}

+ 179 - 0
src/features/vehicles/Actions/plateLookupActions.ts

@@ -0,0 +1,179 @@
+'use server'
+
+import { Prisma } from '@/generated/prisma/client'
+import { db } from '@/lib/db'
+import { getFeatures } from '@/lib/features'
+import { PermissionAction, PermissionSubject } from '@/lib/permissions'
+import { withAuth } from '@/lib/with-auth'
+import { recordRegistryAnswer } from '@/features/integrations/Lib/inspection-sync'
+import type { VehicleLookupResult } from '@/features/integrations/Lib/types'
+import {
+  askRegistry,
+  findLookupConnection,
+  withinLookupBudget,
+} from '@/features/integrations/Lib/vehicle-lookup'
+import { compactPlate, looksLikePlate } from '../Lib/plate'
+
+/**
+ * The header's plate lookup: one plate, two answers. What the workshop
+ * already knows about the vehicle, and what the connected registry says,
+ * asked together so the person at the desk sees both at once.
+ */
+
+const READ_VEHICLES = [{ action: PermissionAction.READ, subject: PermissionSubject.VEHICLES }]
+
+/** A vehicle of this workshop, as much as the palette shows of it. */
+export interface WorkshopVehicle {
+  id: string
+  make: string
+  model: string
+  year: number
+  licensePlate: string | null
+  vin: string | null
+  color: string | null
+  mileage: number
+  imageUrl: string | null
+  isArchived: boolean
+  customer: { id: string; name: string; company: string | null; phone: string | null } | null
+  inspectionDueAt: string | null
+  serviceCount: number
+  lastServiceAt: string | null
+}
+
+export interface PlateLookup {
+  /** The plate as it was searched, compacted. */
+  plate: string
+  /** The workshop's own vehicle with this plate (or the registry's VIN), when there is one. */
+  vehicle: WorkshopVehicle | null
+  /** What the registry said, null when it has no such vehicle. */
+  registry: (VehicleLookupResult & { source: string }) | null
+  /** Set when the registry could not be asked; the workshop half still stands. */
+  registryError: string | null
+  /** Registry name, for the empty state's attribution. */
+  source: string | null
+}
+
+const VEHICLE_SELECT = {
+  id: true,
+  make: true,
+  model: true,
+  year: true,
+  licensePlate: true,
+  vin: true,
+  color: true,
+  mileage: true,
+  imageUrl: true,
+  isArchived: true,
+  customer: { select: { id: true, name: true, company: true, phone: true } },
+  inspectionStatus: { select: { dueAt: true } },
+  _count: { select: { serviceRecords: true } },
+  serviceRecords: {
+    select: { serviceDate: true },
+    orderBy: { serviceDate: 'desc' as const },
+    take: 1,
+  },
+} satisfies Prisma.VehicleSelect
+
+type VehicleRow = Prisma.VehicleGetPayload<{ select: typeof VEHICLE_SELECT }>
+
+function toWorkshopVehicle(row: VehicleRow): WorkshopVehicle {
+  return {
+    id: row.id,
+    make: row.make,
+    model: row.model,
+    year: row.year,
+    licensePlate: row.licensePlate,
+    vin: row.vin,
+    color: row.color,
+    mileage: row.mileage,
+    imageUrl: row.imageUrl,
+    isArchived: row.isArchived,
+    customer: row.customer,
+    inspectionDueAt: row.inspectionStatus?.dueAt?.toISOString() ?? null,
+    serviceCount: row._count.serviceRecords,
+    lastServiceAt: row.serviceRecords[0]?.serviceDate?.toISOString() ?? null,
+  }
+}
+
+/**
+ * The workshop's vehicle with this plate. Plates are stored the way people
+ * typed them, with or without hyphens and spaces, so the comparison strips
+ * both sides down to letters and digits in the database. An active vehicle
+ * wins over an archived one with the same plate.
+ */
+async function findByPlate(organizationId: string, compact: string): Promise<VehicleRow | null> {
+  const ids = await db.$queryRaw<{ id: string }[]>`
+    SELECT id FROM vehicles
+    WHERE "organizationId" = ${organizationId}
+      AND "licensePlate" IS NOT NULL
+      AND regexp_replace(upper("licensePlate"), '[^A-Z0-9]', '', 'g') = ${compact}
+    ORDER BY "isArchived" ASC, "updatedAt" DESC
+    LIMIT 1
+  `
+  const id = ids[0]?.id
+  if (!id) return null
+  return db.vehicle.findUnique({ where: { id }, select: VEHICLE_SELECT })
+}
+
+/** The same vehicle under a new plate: the registry's VIN is already on file. */
+async function findByVin(organizationId: string, vin: string): Promise<VehicleRow | null> {
+  return db.vehicle.findFirst({
+    where: { organizationId, vin: { equals: vin, mode: 'insensitive' } },
+    orderBy: [{ isArchived: 'asc' }, { updatedAt: 'desc' }],
+    select: VEHICLE_SELECT,
+  })
+}
+
+export async function lookupPlate(input: { plate: string }) {
+  return withAuth(
+    async ({ organizationId }): Promise<PlateLookup> => {
+      const typed = input.plate?.trim() ?? ''
+      if (!looksLikePlate(typed)) throw new Error('That does not look like a plate')
+      const plate = compactPlate(typed)
+
+      const features = await getFeatures(organizationId)
+      const target = features.integrations ? await findLookupConnection(organizationId) : null
+
+      // The workshop's own records first, so a registry that is slow or down
+      // still leaves the desk with the vehicle they were asking about.
+      let vehicle = await findByPlate(organizationId, plate)
+
+      let registry: PlateLookup['registry'] = null
+      let registryError: string | null = null
+      let source: string | null = null
+      if (target) {
+        if (!withinLookupBudget(organizationId)) {
+          registryError = 'Too many lookups, wait a minute and try again'
+        } else {
+          try {
+            const answer = await askRegistry(target.id, { plate })
+            source = answer.source
+            if (answer.result) registry = { ...answer.result, source: answer.source }
+            if (!vehicle && answer.result?.vin) {
+              vehicle = await findByVin(organizationId, answer.result.vin)
+            }
+            if (vehicle) {
+              await recordRegistryAnswer({
+                organizationId,
+                vehicleId: vehicle.id,
+                source: answer.connectorId,
+                result: answer.result,
+              })
+            }
+          } catch (err) {
+            registryError = err instanceof Error ? err.message : 'The registry could not be asked'
+          }
+        }
+      }
+
+      return {
+        plate,
+        vehicle: vehicle ? toWorkshopVehicle(vehicle) : null,
+        registry,
+        registryError,
+        source,
+      }
+    },
+    { requiredPermissions: READ_VEHICLES }
+  )
+}

+ 635 - 0
src/features/vehicles/Components/PlateLookupCommand.tsx

@@ -0,0 +1,635 @@
+'use client'
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import { useFormatter, useTranslations } from 'next-intl'
+import {
+  ArrowRight,
+  Building2,
+  Car,
+  Check,
+  Copy,
+  Loader2,
+  Plus,
+  Search,
+  ShieldCheck,
+  ShieldOff,
+  User,
+  X,
+} from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { Dialog, DialogContent, DialogDescription, DialogTitle } from '@/components/ui/dialog'
+import { PLATE_LOOKUP_EVENT, usePlateLookupAccess } from '@/components/plate-lookup-context'
+import { getCustomersList } from '@/features/customers/Actions/customerActions'
+import type { VehicleLookup } from '@/features/integrations/Actions/vehicleLookupActions'
+import { cn } from '@/lib/utils'
+import { type PlateLookup, lookupPlate } from '../Actions/plateLookupActions'
+import { compactPlate, looksLikePlate } from '../Lib/plate'
+import { VehicleForm } from './VehicleForm'
+
+/**
+ * The header's plate lookup: one field, one answer sheet.
+ *
+ * Type a plate, press Enter, and the sheet fills with what the workshop knows
+ * (the vehicle, its owner, its history) beside what the registry publishes
+ * (identity, engine, dates, tyres). A vehicle the workshop has not seen gets
+ * an "Add vehicle" that opens the ordinary form with the registry's answer
+ * already typed in.
+ *
+ * Opened from the header button, from Ctrl+Shift+L, or by any code that
+ * dispatches the plate-lookup event, optionally with a plate to search.
+ */
+
+const RECENT_KEY = 'torqvoice.plate-lookup.recent'
+const RECENT_MAX = 6
+
+function readRecent(): string[] {
+  try {
+    const raw = window.localStorage.getItem(RECENT_KEY)
+    const parsed = raw ? (JSON.parse(raw) as unknown) : []
+    return Array.isArray(parsed) ? parsed.filter((p): p is string => typeof p === 'string') : []
+  } catch {
+    return []
+  }
+}
+
+function writeRecent(plates: string[]) {
+  try {
+    window.localStorage.setItem(RECENT_KEY, JSON.stringify(plates))
+  } catch {
+    // Private windows and blocked storage: the list is a convenience.
+  }
+}
+
+/** Days until a date, negative when past. */
+function daysUntil(iso: string): number {
+  return Math.round((new Date(iso).getTime() - Date.now()) / 86_400_000)
+}
+
+type Phase = 'idle' | 'loading' | 'done'
+
+export function PlateLookupCommand() {
+  const t = useTranslations('vehicles.plateLookup')
+  const tf = useTranslations('vehicles.form')
+  const format = useFormatter()
+  const router = useRouter()
+  const { available, canCreate, registryName } = usePlateLookupAccess()
+
+  const [open, setOpen] = useState(false)
+  const [plate, setPlate] = useState('')
+  const [phase, setPhase] = useState<Phase>('idle')
+  const [result, setResult] = useState<PlateLookup | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [recent, setRecent] = useState<string[]>([])
+  const [copied, setCopied] = useState(false)
+  const [formOpen, setFormOpen] = useState(false)
+  const [formLookup, setFormLookup] = useState<VehicleLookup | null>(null)
+  const [customers, setCustomers] = useState<
+    { id: string; name: string; company: string | null }[]
+  >([])
+  const inputRef = useRef<HTMLInputElement>(null)
+  const requestRef = useRef(0)
+
+  const run = useCallback(
+    async (typed: string) => {
+      const value = typed.trim()
+      if (!looksLikePlate(value)) {
+        setError(t('invalid'))
+        return
+      }
+      const id = ++requestRef.current
+      setPhase('loading')
+      setError(null)
+      setResult(null)
+      setCopied(false)
+      const res = await lookupPlate({ plate: value })
+      if (id !== requestRef.current) return
+      if (!res.success || !res.data) {
+        setPhase('idle')
+        setError(res.error || t('registryFailedGeneric'))
+        return
+      }
+      setResult(res.data)
+      setPhase('done')
+      const compact = res.data.plate
+      setRecent((prev) => {
+        const next = [compact, ...prev.filter((p) => p !== compact)].slice(0, RECENT_MAX)
+        writeRecent(next)
+        return next
+      })
+    },
+    [t]
+  )
+
+  // Open on the header button, the shortcut, or a request carrying a plate.
+  useEffect(() => {
+    if (!available) return
+    const onEvent = (e: Event) => {
+      const detail = (e as CustomEvent<{ plate?: string }>).detail
+      setOpen(true)
+      if (detail?.plate) {
+        setPlate(compactPlate(detail.plate))
+        void run(detail.plate)
+      }
+    }
+    const onKey = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key.toLowerCase() === 'l') {
+        e.preventDefault()
+        setOpen((prev) => !prev)
+      }
+    }
+    document.addEventListener(PLATE_LOOKUP_EVENT, onEvent)
+    document.addEventListener('keydown', onKey)
+    return () => {
+      document.removeEventListener(PLATE_LOOKUP_EVENT, onEvent)
+      document.removeEventListener('keydown', onKey)
+    }
+  }, [available, run])
+
+  useEffect(() => {
+    if (!open) return
+    setRecent(readRecent())
+    const frame = requestAnimationFrame(() => inputRef.current?.focus())
+    return () => cancelAnimationFrame(frame)
+  }, [open])
+
+  const reset = () => {
+    setPlate('')
+    setPhase('idle')
+    setResult(null)
+    setError(null)
+  }
+
+  const handleOpenChange = (next: boolean) => {
+    setOpen(next)
+    if (!next) reset()
+  }
+
+  const openVehicle = (id: string) => {
+    handleOpenChange(false)
+    router.push(`/vehicles/${id}`)
+  }
+
+  const addVehicle = async () => {
+    if (!result) return
+    const registry = result.registry
+    setFormLookup(
+      registry
+        ? { ...registry, licensePlate: registry.licensePlate ?? result.plate }
+        : { licensePlate: result.plate, source: '' }
+    )
+    const list = await getCustomersList()
+    setCustomers(list.success && list.data ? list.data : [])
+    setOpen(false)
+    setFormOpen(true)
+  }
+
+  const copyVin = async (vin: string) => {
+    try {
+      await navigator.clipboard.writeText(vin)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 1500)
+    } catch {
+      // Clipboard blocked: the VIN is still on screen to select.
+    }
+  }
+
+  const fuelLabel = (fuel: string) => {
+    const known = ['gasoline', 'diesel', 'electric', 'hybrid', 'other']
+    return known.includes(fuel) ? tf(fuel) : fuel
+  }
+  const gearboxLabel = (gearbox: string) => {
+    const known = ['automatic', 'manual', 'cvt']
+    return known.includes(gearbox) ? tf(gearbox) : gearbox
+  }
+  const date = (iso: string) => format.dateTime(new Date(iso), { dateStyle: 'medium' })
+
+  const registry = result?.registry ?? null
+  const vehicle = result?.vehicle ?? null
+  /** The headline: the workshop's own record if there is one, else the registry's. */
+  const headline = useMemo(() => {
+    if (vehicle) return { make: vehicle.make, model: vehicle.model, year: vehicle.year }
+    if (registry?.make || registry?.model)
+      return { make: registry.make ?? '', model: registry.model ?? '', year: registry.year }
+    return null
+  }, [vehicle, registry])
+
+  const details = useMemo(() => {
+    if (!registry) return []
+    const rows: { key: string; label: string; value: string; tone?: 'overdue' | 'soon' }[] = []
+    const push = (key: string, label: string, value?: string | null, tone?: 'overdue' | 'soon') => {
+      if (value) rows.push({ key, label, value, tone })
+    }
+    push('fuel', t('fuel'), registry.fuelType ? fuelLabel(registry.fuelType) : undefined)
+    push(
+      'transmission',
+      t('transmission'),
+      registry.transmission ? gearboxLabel(registry.transmission) : undefined
+    )
+    push('engine', t('engine'), registry.engineSize)
+    push('engineCode', t('engineCode'), registry.engineCode)
+    push('color', t('color'), registry.color)
+    push('class', t('vehicleClass'), registry.vehicleClass)
+    push(
+      'firstRegistered',
+      t('firstRegistered'),
+      registry.firstRegistered ? date(registry.firstRegistered) : undefined
+    )
+    if (registry.inspectionDue) {
+      const days = daysUntil(registry.inspectionDue)
+      push(
+        'inspectionDue',
+        t('inspectionDue'),
+        date(registry.inspectionDue),
+        days < 0 ? 'overdue' : days <= 60 ? 'soon' : undefined
+      )
+    }
+    push(
+      'lastInspected',
+      t('lastInspected'),
+      registry.lastInspected ? date(registry.lastInspected) : undefined
+    )
+    if (registry.weights?.kerb && registry.weights.grossMax) {
+      push(
+        'weights',
+        t('weights'),
+        t('weightsValue', { kerb: registry.weights.kerb, gross: registry.weights.grossMax })
+      )
+    } else if (registry.weights?.kerb) {
+      push('weights', t('weights'), t('kerbOnly', { kerb: registry.weights.kerb }))
+    } else if (registry.weights?.grossMax) {
+      push('weights', t('weights'), t('grossOnly', { gross: registry.weights.grossMax }))
+    }
+    return rows
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [registry, t, tf, format])
+
+  if (!available) return null
+
+  return (
+    <>
+      <Dialog open={open} onOpenChange={handleOpenChange}>
+        <DialogContent
+          className="gap-0 overflow-hidden p-0 sm:max-w-2xl"
+          showCloseButton={false}
+          onOpenAutoFocus={(e) => e.preventDefault()}
+        >
+          <DialogTitle className="sr-only">{t('title')}</DialogTitle>
+          <DialogDescription className="sr-only">{t('description')}</DialogDescription>
+
+          {/* The plate field, drawn as a plate: a band at the left, the
+              characters in a fixed-width face, spaced the way a plate is. */}
+          <form
+            className="flex items-stretch gap-2 border-b bg-muted/30 p-3"
+            onSubmit={(e) => {
+              e.preventDefault()
+              void run(plate)
+            }}
+          >
+            <div className="flex flex-1 items-stretch overflow-hidden rounded-lg border-2 border-foreground/25 bg-background shadow-sm transition-colors focus-within:border-primary">
+              <div className="flex w-7 shrink-0 items-end justify-center bg-primary/85 pb-1.5">
+                <Car className="h-3.5 w-3.5 text-primary-foreground" aria-hidden />
+              </div>
+              <input
+                ref={inputRef}
+                value={plate}
+                onChange={(e) => {
+                  setPlate(e.target.value.toUpperCase())
+                  if (error) setError(null)
+                }}
+                placeholder={t('placeholder')}
+                autoComplete="off"
+                autoCorrect="off"
+                spellCheck={false}
+                maxLength={16}
+                aria-label={t('placeholder')}
+                className="h-14 min-w-0 flex-1 bg-transparent px-4 font-mono text-2xl font-semibold uppercase tracking-[0.18em] text-foreground outline-none placeholder:font-sans placeholder:text-base placeholder:font-normal placeholder:normal-case placeholder:tracking-normal placeholder:text-muted-foreground/70"
+              />
+              {plate && (
+                <button
+                  type="button"
+                  onClick={() => {
+                    reset()
+                    inputRef.current?.focus()
+                  }}
+                  className="px-3 text-muted-foreground hover:text-foreground"
+                  aria-label={t('clearRecent')}
+                >
+                  <X className="h-4 w-4" />
+                </button>
+              )}
+            </div>
+            <Button type="submit" className="h-auto px-4" disabled={phase === 'loading'}>
+              {phase === 'loading' ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Search className="h-4 w-4" />
+              )}
+              <span className="hidden sm:inline">{t('search')}</span>
+            </Button>
+          </form>
+
+          <div className="min-h-[320px]">
+            {error && (
+              <p className="border-b bg-destructive/5 px-4 py-2 text-sm text-destructive">
+                {error}
+              </p>
+            )}
+
+            {phase === 'idle' && !result && (
+              <div className="flex flex-col gap-6 px-5 py-6">
+                <div className="flex items-start gap-4">
+                  <div className="rounded-xl bg-primary/10 p-3 text-primary">
+                    <Search className="h-6 w-6" />
+                  </div>
+                  <div className="space-y-1">
+                    <p className="font-medium">{t('emptyTitle')}</p>
+                    <p className="text-sm text-muted-foreground">
+                      {t('emptyBody', { source: registryName ?? t('registryWord') })}
+                    </p>
+                  </div>
+                </div>
+                {recent.length > 0 && (
+                  <div className="space-y-2">
+                    <div className="flex items-center justify-between text-xs text-muted-foreground">
+                      <span className="font-medium uppercase tracking-wide">{t('recent')}</span>
+                      <button
+                        type="button"
+                        className="hover:text-foreground"
+                        onClick={() => {
+                          setRecent([])
+                          writeRecent([])
+                        }}
+                      >
+                        {t('clearRecent')}
+                      </button>
+                    </div>
+                    <div className="flex flex-wrap gap-2">
+                      {recent.map((p) => (
+                        <button
+                          key={p}
+                          type="button"
+                          onClick={() => {
+                            setPlate(p)
+                            void run(p)
+                          }}
+                          className="rounded-md border bg-background px-2.5 py-1 font-mono text-sm tracking-wider transition-colors hover:border-primary hover:text-primary"
+                        >
+                          {p}
+                        </button>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            )}
+
+            {phase === 'loading' && (
+              <div className="space-y-4 px-5 py-6" aria-busy>
+                <div className="h-7 w-2/3 animate-pulse rounded bg-muted" />
+                <div className="h-4 w-1/3 animate-pulse rounded bg-muted" />
+                <div className="mt-6 grid grid-cols-2 gap-3 sm:grid-cols-3">
+                  {Array.from({ length: 6 }, (_, i) => (
+                    <div key={i} className="space-y-1.5">
+                      <div className="h-3 w-16 animate-pulse rounded bg-muted" />
+                      <div className="h-4 w-24 animate-pulse rounded bg-muted" />
+                    </div>
+                  ))}
+                </div>
+                <p className="pt-2 text-xs text-muted-foreground">
+                  {registryName ? t('looking', { source: registryName }) : t('lookingWorkshop')}
+                </p>
+              </div>
+            )}
+
+            {phase === 'done' && result && (
+              <div className="divide-y">
+                {/* Headline: what the car is, and which register said so. */}
+                <div className="flex flex-wrap items-start justify-between gap-3 px-5 py-4">
+                  <div className="min-w-0">
+                    {headline ? (
+                      <p className="truncate text-xl font-semibold leading-tight">
+                        {headline.year ? `${headline.year} ` : ''}
+                        {headline.make} {headline.model}
+                      </p>
+                    ) : (
+                      <p className="text-xl font-semibold leading-tight text-muted-foreground">
+                        {result.source
+                          ? t('registryNotFound', { source: result.source })
+                          : t('registryFailedGeneric')}
+                      </p>
+                    )}
+                    <div className="mt-1.5 flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+                      <span className="rounded border px-1.5 py-0.5 font-mono text-[11px] tracking-wider text-foreground">
+                        {vehicle?.licensePlate ?? registry?.licensePlate ?? result.plate}
+                      </span>
+                      {registry && <span>{t('fromSource', { source: registry.source })}</span>}
+                      {registry?.registered === true && (
+                        <span className="inline-flex items-center gap-1 text-emerald-600 dark:text-emerald-400">
+                          <ShieldCheck className="h-3.5 w-3.5" /> {t('registered')}
+                        </span>
+                      )}
+                      {registry?.registered === false && (
+                        <span className="inline-flex items-center gap-1 text-amber-600 dark:text-amber-400">
+                          <ShieldOff className="h-3.5 w-3.5" /> {t('notRegistered')}
+                        </span>
+                      )}
+                    </div>
+                    {result.registryError && (
+                      <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">
+                        {result.source
+                          ? `${t('registryFailed', { source: result.source })}: ${result.registryError}`
+                          : result.registryError}
+                      </p>
+                    )}
+                    {!result.registryError && !registry && result.source && headline && (
+                      <p className="mt-2 text-xs text-muted-foreground">
+                        {t('registryNotFound', { source: result.source })}
+                      </p>
+                    )}
+                  </div>
+                  {registry?.vin && (
+                    <button
+                      type="button"
+                      onClick={() => copyVin(registry.vin as string)}
+                      className="group flex items-center gap-2 rounded-md border bg-muted/40 px-2.5 py-1.5 text-left transition-colors hover:bg-muted"
+                      title={t('copyVin')}
+                    >
+                      <div>
+                        <div className="text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
+                          {t('vin')}
+                        </div>
+                        <div className="font-mono text-sm">{registry.vin}</div>
+                      </div>
+                      {copied ? (
+                        <Check className="h-4 w-4 text-emerald-600" />
+                      ) : (
+                        <Copy className="h-4 w-4 text-muted-foreground group-hover:text-foreground" />
+                      )}
+                    </button>
+                  )}
+                </div>
+
+                {/* The workshop's half: the car is yours, or it could be. */}
+                {vehicle ? (
+                  <div className="flex flex-wrap items-center gap-4 px-5 py-3">
+                    <div className="flex h-10 w-10 shrink-0 items-center justify-center overflow-hidden rounded-lg bg-primary/10 text-primary">
+                      {vehicle.imageUrl ? (
+                        // eslint-disable-next-line @next/next/no-img-element
+                        <img src={vehicle.imageUrl} alt="" className="h-full w-full object-cover" />
+                      ) : (
+                        <Car className="h-5 w-5" />
+                      )}
+                    </div>
+                    <div className="min-w-0 flex-1">
+                      <p className="text-sm font-medium">
+                        {vehicle.isArchived ? t('inWorkshopArchived') : t('inWorkshop')}
+                      </p>
+                      <p className="flex flex-wrap items-center gap-x-2 text-xs text-muted-foreground">
+                        {vehicle.customer ? (
+                          <span className="inline-flex items-center gap-1">
+                            {vehicle.customer.company ? (
+                              <Building2 className="h-3 w-3" />
+                            ) : (
+                              <User className="h-3 w-3" />
+                            )}
+                            {vehicle.customer.name}
+                            {vehicle.customer.company ? ` (${vehicle.customer.company})` : ''}
+                          </span>
+                        ) : (
+                          <span>{t('noOwner')}</span>
+                        )}
+                        {vehicle.mileage > 0 && (
+                          <span>· {t('mileage', { km: format.number(vehicle.mileage) })}</span>
+                        )}
+                        <span>· {t('services', { count: vehicle.serviceCount })}</span>
+                        {vehicle.lastServiceAt && (
+                          <span>· {t('lastService', { date: date(vehicle.lastServiceAt) })}</span>
+                        )}
+                      </p>
+                    </div>
+                    <Button size="sm" onClick={() => openVehicle(vehicle.id)}>
+                      {t('openVehicle')}
+                      <ArrowRight className="ml-1 h-3.5 w-3.5" />
+                    </Button>
+                  </div>
+                ) : (
+                  (registry || canCreate) && (
+                    <div className="flex flex-wrap items-center gap-4 px-5 py-3">
+                      <div className="flex h-10 w-10 shrink-0 items-center justify-center rounded-lg border border-dashed text-muted-foreground">
+                        <Plus className="h-5 w-5" />
+                      </div>
+                      <div className="min-w-0 flex-1">
+                        <p className="text-sm font-medium">{t('notInWorkshop')}</p>
+                        <p className="text-xs text-muted-foreground">
+                          {registry ? t('notInWorkshopHint') : t('notInWorkshopNoRegistry')}
+                        </p>
+                      </div>
+                      {canCreate && (
+                        <Button
+                          size="sm"
+                          variant={registry ? 'default' : 'outline'}
+                          onClick={addVehicle}
+                        >
+                          <Plus className="mr-1 h-3.5 w-3.5" />
+                          {t('addVehicle')}
+                        </Button>
+                      )}
+                    </div>
+                  )
+                )}
+
+                {/* The registry's half: everything it publishes, as a sheet. */}
+                {details.length > 0 && (
+                  <dl className="grid grid-cols-2 gap-x-4 gap-y-3 px-5 py-4 sm:grid-cols-3">
+                    {details.map((row) => (
+                      <div key={row.key} className="min-w-0">
+                        <dt className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                          {row.label}
+                        </dt>
+                        <dd
+                          className={cn(
+                            'truncate text-sm',
+                            row.tone === 'overdue' && 'font-medium text-destructive',
+                            row.tone === 'soon' && 'font-medium text-amber-600 dark:text-amber-400'
+                          )}
+                          title={row.value}
+                        >
+                          {row.value}
+                          {row.tone === 'overdue' && (
+                            <span className="ml-1.5 text-[10px] uppercase">{t('overdue')}</span>
+                          )}
+                          {row.tone === 'soon' && (
+                            <span className="ml-1.5 text-[10px] uppercase">{t('dueSoon')}</span>
+                          )}
+                        </dd>
+                      </div>
+                    ))}
+                  </dl>
+                )}
+
+                {registry?.tyres && registry.tyres.length > 0 && (
+                  <div className="px-5 py-4">
+                    <p className="mb-2 text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                      {t('tyres')}
+                    </p>
+                    <table className="w-full text-sm">
+                      <thead className="text-left text-xs text-muted-foreground">
+                        <tr>
+                          <th className="pb-1 font-medium" />
+                          <th className="pb-1 font-medium">{t('tyreSize')}</th>
+                          <th className="pb-1 font-medium">{t('rimSize')}</th>
+                          <th className="pb-1 font-medium">{t('loadSpeed')}</th>
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {registry.tyres.map((axle) => (
+                          <tr key={axle.axle} className="border-t">
+                            <td className="py-1.5 text-muted-foreground">
+                              {t('axle', { n: axle.axle })}
+                            </td>
+                            <td className="py-1.5 font-mono">{axle.tyre ?? '–'}</td>
+                            <td className="py-1.5 font-mono">{axle.rim ?? '–'}</td>
+                            <td className="py-1.5 font-mono">
+                              {[axle.loadIndex, axle.speedRating].filter(Boolean).join(' ') || '–'}
+                            </td>
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+                )}
+              </div>
+            )}
+          </div>
+
+          <div className="flex items-center gap-4 border-t px-4 py-2 text-xs text-muted-foreground">
+            <span>
+              <kbd className="pointer-events-none inline-flex h-5 items-center rounded border bg-muted px-1.5 font-mono text-[10px] font-medium">
+                ↵
+              </kbd>
+              <span className="ml-1.5">{t('hintEnter')}</span>
+            </span>
+            <span>
+              <kbd className="pointer-events-none inline-flex h-5 items-center rounded border bg-muted px-1.5 font-mono text-[10px] font-medium">
+                ESC
+              </kbd>
+              <span className="ml-1.5">{t('hintClose')}</span>
+            </span>
+            <span className="ml-auto hidden sm:inline">{t('shortcut')}</span>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      <VehicleForm
+        open={formOpen}
+        onOpenChange={(next) => {
+          setFormOpen(next)
+          if (!next) setFormLookup(null)
+        }}
+        customers={customers}
+        initialLookup={formLookup}
+      />
+    </>
+  )
+}

+ 23 - 0
src/features/vehicles/Components/VehicleForm.tsx

@@ -82,6 +82,11 @@ interface VehicleFormProps {
   customers?: { id: string; name: string; company: string | null }[]
   /** Preselects the customer when creating a new vehicle (ignored when editing) */
   defaultCustomerId?: string
+  /**
+   * What a registry already said about the plate, for a form opened from the
+   * plate lookup: filled in as if the search button had been pressed.
+   */
+  initialLookup?: VehicleLookup | null
 }
 
 export function VehicleForm({
@@ -90,6 +95,7 @@ export function VehicleForm({
   vehicle,
   customers,
   defaultCustomerId,
+  initialLookup,
 }: VehicleFormProps) {
   const serviceType = useServiceType()
   const isMarine = serviceType === 'marine'
@@ -256,6 +262,23 @@ export function VehicleForm({
     setLookupNote(data)
   }
 
+  // The fields are uncontrolled, so the registry's answer is written once the
+  // form has rendered, the same way the lookup button writes it.
+  const appliedLookupRef = useRef<VehicleLookup | null>(null)
+  useEffect(() => {
+    if (!open || vehicle || !initialLookup) return
+    if (appliedLookupRef.current === initialLookup) return
+    appliedLookupRef.current = initialLookup
+    const frame = requestAnimationFrame(() => applyLookup(initialLookup))
+    return () => cancelAnimationFrame(frame)
+    // applyLookup reads the current form and selects; running it again on
+    // their change would overwrite what the user has since typed.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open, vehicle, initialLookup])
+  useEffect(() => {
+    if (!open) appliedLookupRef.current = null
+  }, [open])
+
   const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
     e.preventDefault()
     const formData = new FormData(e.currentTarget)

+ 14 - 0
src/features/vehicles/Lib/plate.ts

@@ -0,0 +1,14 @@
+/**
+ * Plates as people type and store them: "SK-209-X", "sk 209 x", "SK209X" are
+ * one plate. The compact form is what registries take and what two stored
+ * plates are compared on.
+ */
+export function compactPlate(plate: string): string {
+  return plate.replace(/[^A-Za-z0-9]+/g, '').toUpperCase()
+}
+
+/** Whether a string could be a plate at all: two to twelve letters and digits once compacted. */
+export function looksLikePlate(plate: string): boolean {
+  const compact = compactPlate(plate)
+  return compact.length >= 2 && compact.length <= 12
+}