feat(i18n): country/phone/timezone/subdivision primitives + form wiring

Cross-cutting i18n polish for forms across the marina + residential + company
domains. Introduces a single source of truth for country/phone/timezone/
subdivision data and replaces every nationality-as-free-text and timezone-
as-string Input with a dedicated combobox.

PR1  Countries — ALL_COUNTRY_CODES (~250 ISO-3166-1 alpha-2), Intl.DisplayNames
     for localized labels, detectDefaultCountry() with navigator-region
     fallback to US, CountryCombobox with regional-indicator flag glyphs +
     compact mode for inline use.
PR2  Phone — libphonenumber-js wrapper (parsePhone / formatAsYouType /
     callingCodeFor), PhoneInput with flag dropdown + national-format
     AsYouType + paste-detect that flips the country dropdown for pasted
     international strings.
PR3  Timezones — country->IANA map (250 entries, multi-zone for AU/BR/CA/CD/
     ID/KZ/MN/MX/RU/US), formatTimezoneLabel ("Europe/London (UTC+1)"),
     TimezoneCombobox with Suggested/All grouping driven by countryHint.
PR4  Subdivisions — wraps the iso-3166-2 npm package (~5000 ISO 3166-2
     codes for every country), per-country cache, SubdivisionCombobox with
     "Pick a country first" / "No regions available" empty states.
PR5  Schema deltas (migration 0015) — clients.nationality_iso, clientContacts
     {value_e164, value_country}, clientAddresses {country_iso, subdivision_iso},
     residentialClients {phone_e164, phone_country, nationality_iso, timezone,
     place_of_residence_country_iso, subdivision_iso}, companies {incorporation_
     country_iso, incorporation_subdivision_iso}, companyAddresses {country_iso,
     subdivision_iso}. Plus shared zod validators (validators/i18n.ts) used
     by every entity validator + route handler.
PR6  ClientForm + ClientDetail — CountryCombobox replaces nationality Input,
     TimezoneCombobox replaces timezone Input (driven by nationalityIso hint),
     PhoneInput conditionally rendered for phone/whatsapp contacts. Inline
     editors (InlineCountryField / InlineTimezoneField / InlinePhoneField)
     for the detail-page overview rows + ContactsEditor.
PR7  Residential client form + detail — phone -> PhoneInput, nationality/
     timezone/place-of-residence-country/subdivision rows in both create
     sheet and inline-editable detail view. Subdivision wipes when country
     flips since codes are country-scoped.
PR8  Company form + detail — incorporation country -> CountryCombobox,
     incorporation region -> SubdivisionCombobox in both modes.
PR9  Public inquiry endpoint — accepts pre-normalized phoneE164/phoneCountry
     and i18n fields from newer website builds, server-side parsePhone()
     fallback for legacy raw-international submissions. Old Nuxt builds
     keep working unchanged.

Tests: 4 unit suites for the primitives (25 tests), 1 integration spec for
the public phone-normalization path (3 tests), 1 smoke spec asserting the
combobox triggers render in all three create sheets.

Test totals: vitest 713 -> 741 (+28).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/unit/i18n-countries.test.ts

@@ -0,0 +1,87 @@
+/**
+ * i18n PR1 — country dataset.
+ *
+ * Validates:
+ *  1. The dataset includes every common ISO-3166-1 alpha-2 code we'd
+ *     reasonably want (sanity sample, not exhaustive)
+ *  2. `isValidCountryCode` rejects bogus inputs
+ *  3. `getCountryName` returns localized names; falls back to the code
+ *  4. `detectDefaultCountry` returns the fallback in non-browser envs
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  ALL_COUNTRY_CODES,
+  ISO_COUNTRIES,
+  isValidCountryCode,
+  getCountryName,
+  detectDefaultCountry,
+} from '@/lib/i18n/countries';
+
+describe('i18n countries', () => {
+  it('includes core anglophone, EU, MENA, APAC, and Americas codes', () => {
+    const sample = ['US', 'GB', 'PL', 'DE', 'FR', 'AU', 'JP', 'BR', 'AE', 'NG', 'AI'];
+    for (const code of sample) {
+      expect(ISO_COUNTRIES.has(code)).toBe(true);
+    }
+  });
+
+  it('has at least 240 codes and is unique', () => {
+    expect(ALL_COUNTRY_CODES.length).toBeGreaterThanOrEqual(240);
+    expect(new Set(ALL_COUNTRY_CODES).size).toBe(ALL_COUNTRY_CODES.length);
+  });
+
+  it('isValidCountryCode rejects unknown / lowercased / 3-letter codes', () => {
+    expect(isValidCountryCode('US')).toBe(true);
+    expect(isValidCountryCode('us')).toBe(false);
+    expect(isValidCountryCode('USA')).toBe(false);
+    expect(isValidCountryCode('XX')).toBe(false);
+    expect(isValidCountryCode('')).toBe(false);
+  });
+
+  it('getCountryName returns localized names and falls back to the code on error', () => {
+    expect(getCountryName('US', 'en')).toMatch(/United States/);
+    expect(getCountryName('GB', 'en')).toMatch(/United Kingdom/);
+    expect(getCountryName('PL', 'pl')).toMatch(/Polska/i);
+    // Unknown code -> code itself.
+    expect(getCountryName('ZZ', 'en')).toBe('ZZ');
+  });
+
+  it('detectDefaultCountry returns the navigator region when valid', () => {
+    const original = globalThis.navigator;
+    Object.defineProperty(globalThis, 'navigator', {
+      value: { language: 'en-GB' },
+      configurable: true,
+    });
+    expect(detectDefaultCountry()).toBe('GB');
+    Object.defineProperty(globalThis, 'navigator', {
+      value: original,
+      configurable: true,
+    });
+  });
+
+  it('detectDefaultCountry uses the fallback when navigator is unset', () => {
+    const original = globalThis.navigator;
+    // @ts-expect-error force navigator to undefined for the duration of this test
+    delete globalThis.navigator;
+    expect(detectDefaultCountry()).toBe('US');
+    expect(detectDefaultCountry('GB')).toBe('GB');
+    Object.defineProperty(globalThis, 'navigator', {
+      value: original,
+      configurable: true,
+    });
+  });
+
+  it('detectDefaultCountry falls back when the navigator region is unknown', () => {
+    const original = globalThis.navigator;
+    Object.defineProperty(globalThis, 'navigator', {
+      value: { language: 'xx-ZZ' },
+      configurable: true,
+    });
+    expect(detectDefaultCountry()).toBe('US');
+    Object.defineProperty(globalThis, 'navigator', {
+      value: original,
+      configurable: true,
+    });
+  });
+});

tests/unit/i18n-phone.test.ts

@@ -0,0 +1,60 @@
+/**
+ * i18n PR2 — phone helpers.
+ *
+ * Validates:
+ *  1. parsePhone yields E.164 + country + display formats
+ *  2. parsePhone returns the empty record for unparseable input
+ *  3. AsYouType formats digits in the country's national style
+ *  4. isValidE164 accepts only E.164 form
+ *  5. callingCodeFor returns the dial prefix
+ *  6. International-format paste detects country
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parsePhone, formatAsYouType, isValidE164, callingCodeFor } from '@/lib/i18n/phone';
+
+describe('i18n phone', () => {
+  it('parses an international-format input regardless of defaultCountry', () => {
+    const r = parsePhone('+44 20 7946 0958');
+    expect(r.e164).toBe('+442079460958');
+    expect(r.country).toBe('GB');
+    expect(r.isValid).toBe(true);
+    expect(r.national).toMatch(/020 7946 0958/);
+    expect(r.international).toMatch(/\+44 20 7946 0958/);
+  });
+
+  it('parses a national-format input against the defaultCountry', () => {
+    const r = parsePhone('020 7946 0958', 'GB');
+    expect(r.e164).toBe('+442079460958');
+    expect(r.country).toBe('GB');
+    expect(r.isValid).toBe(true);
+  });
+
+  it('returns the empty record for empty / nonsense input', () => {
+    expect(parsePhone('').isValid).toBe(false);
+    expect(parsePhone('abc').isValid).toBe(false);
+    expect(parsePhone('').e164).toBeNull();
+  });
+
+  it('formatAsYouType produces national-format output', () => {
+    // GB national-format breaks 020 7946 0958.
+    const out = formatAsYouType('2079460958', 'GB');
+    expect(out.length).toBeGreaterThan(0);
+    // US national-format breaks (415) 555-1234.
+    const us = formatAsYouType('4155551234', 'US');
+    expect(us).toContain('415');
+  });
+
+  it('isValidE164 accepts only E.164', () => {
+    expect(isValidE164('+442079460958')).toBe(true);
+    expect(isValidE164('+1 415 555 1234')).toBe(true); // libphonenumber tolerates spaces
+    expect(isValidE164('020 7946 0958')).toBe(false); // missing +country prefix
+    expect(isValidE164('not a phone')).toBe(false);
+  });
+
+  it('callingCodeFor returns the dial prefix', () => {
+    expect(callingCodeFor('US')).toBe('+1');
+    expect(callingCodeFor('GB')).toBe('+44');
+    expect(callingCodeFor('PL')).toBe('+48');
+  });
+});

tests/unit/i18n-subdivisions.test.ts

@@ -0,0 +1,57 @@
+/**
+ * i18n PR4 — subdivisions.
+ *
+ * Validates:
+ *  1. Major countries (PL, US, CA, GB, AU) return non-empty lists
+ *  2. Sample known codes resolve to expected names
+ *  3. hasSubdivisions correctly classifies micro-states with no subs
+ *  4. Validation rejects garbage codes
+ *  5. getSubdivisionName returns the human name
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  subdivisionsForCountry,
+  hasSubdivisions,
+  isValidSubdivisionCode,
+  getSubdivisionName,
+} from '@/lib/i18n/subdivisions';
+
+describe('i18n subdivisions', () => {
+  it('major countries return populated subdivision lists', () => {
+    expect(subdivisionsForCountry('PL').length).toBeGreaterThanOrEqual(16);
+    expect(subdivisionsForCountry('US').length).toBeGreaterThanOrEqual(50);
+    expect(subdivisionsForCountry('CA').length).toBeGreaterThanOrEqual(13);
+    expect(subdivisionsForCountry('GB').length).toBeGreaterThan(4); // GB has constituent + 200+ admin areas
+    expect(subdivisionsForCountry('AU').length).toBeGreaterThanOrEqual(8);
+  });
+
+  it('returns sorted-by-name results', () => {
+    const us = subdivisionsForCountry('US');
+    const names = us.map((s) => s.name);
+    const sortedCopy = [...names].sort((a, b) => a.localeCompare(b));
+    expect(names).toEqual(sortedCopy);
+  });
+
+  it('hasSubdivisions is true for known countries', () => {
+    expect(hasSubdivisions('US')).toBe(true);
+    expect(hasSubdivisions('PL')).toBe(true);
+    expect(hasSubdivisions('GB')).toBe(true);
+  });
+
+  it('isValidSubdivisionCode accepts known codes and rejects junk', () => {
+    expect(isValidSubdivisionCode('US-CA')).toBe(true);
+    expect(isValidSubdivisionCode('PL-MZ')).toBe(true);
+    expect(isValidSubdivisionCode('US-XX')).toBe(false);
+    expect(isValidSubdivisionCode('GARBAGE')).toBe(false);
+    expect(isValidSubdivisionCode('')).toBe(false);
+  });
+
+  it('getSubdivisionName returns the human name', () => {
+    expect(getSubdivisionName('US-CA')).toMatch(/California/);
+    expect(getSubdivisionName('PL-MZ')).toMatch(/Mazowieckie|Masovian/);
+    expect(getSubdivisionName('AU-NSW')).toMatch(/New South Wales/);
+    // Unknown -> code itself
+    expect(getSubdivisionName('XX-YY')).toBe('XX-YY');
+  });
+});

tests/unit/i18n-timezones.test.ts

@@ -0,0 +1,71 @@
+/**
+ * i18n PR3 — timezone helpers.
+ *
+ * Validates:
+ *  1. Single-zone countries return one IANA string
+ *  2. Multi-zone countries return >1 zones with the most-populous first
+ *  3. primaryTimezoneFor returns the first entry
+ *  4. isMultiZone correctly classifies a sample of single + multi countries
+ *  5. listAllTimezones returns at least our bundled set
+ *  6. formatTimezoneLabel renders an offset for known zones
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  timezonesForCountry,
+  primaryTimezoneFor,
+  isMultiZone,
+  listAllTimezones,
+  formatTimezoneLabel,
+} from '@/lib/i18n/timezones';
+
+describe('i18n timezones', () => {
+  it('single-zone countries map to one IANA zone', () => {
+    expect(timezonesForCountry('PL')).toEqual(['Europe/Warsaw']);
+    expect(timezonesForCountry('GB')).toEqual(['Europe/London']);
+    expect(timezonesForCountry('JP')).toEqual(['Asia/Tokyo']);
+    expect(timezonesForCountry('AE')).toEqual(['Asia/Dubai']);
+  });
+
+  it('multi-zone countries return ordered lists with the primary first', () => {
+    const us = timezonesForCountry('US');
+    expect(us[0]).toBe('America/New_York');
+    expect(us.length).toBeGreaterThan(5);
+    const ru = timezonesForCountry('RU');
+    expect(ru[0]).toBe('Europe/Moscow');
+    expect(ru.length).toBeGreaterThan(5);
+  });
+
+  it('primaryTimezoneFor returns the first entry or null', () => {
+    expect(primaryTimezoneFor('FR')).toBe('Europe/Paris');
+    expect(primaryTimezoneFor('US')).toBe('America/New_York');
+    // 'AQ' is in our map; Antarctica/McMurdo
+    expect(primaryTimezoneFor('AQ')).toBe('Antarctica/McMurdo');
+  });
+
+  it('isMultiZone discriminates correctly', () => {
+    expect(isMultiZone('US')).toBe(true);
+    expect(isMultiZone('RU')).toBe(true);
+    expect(isMultiZone('AU')).toBe(true);
+    expect(isMultiZone('PL')).toBe(false);
+    expect(isMultiZone('JP')).toBe(false);
+  });
+
+  it('listAllTimezones returns at minimum the entries from the country map', () => {
+    const all = listAllTimezones();
+    expect(all.length).toBeGreaterThanOrEqual(200);
+    expect(all).toContain('Europe/Warsaw');
+    expect(all).toContain('America/New_York');
+    expect(all).toContain('Asia/Tokyo');
+  });
+
+  it('formatTimezoneLabel includes an offset for known zones', () => {
+    const label = formatTimezoneLabel('Europe/London');
+    expect(label).toMatch(/Europe\/London/);
+    expect(label).toMatch(/UTC|GMT/);
+  });
+
+  it('formatTimezoneLabel falls back to the bare zone for unknown input', () => {
+    expect(formatTimezoneLabel('Not/A_Zone')).toBe('Not/A_Zone');
+  });
+});