signalk-race-control 0.2.0 → 0.4.0

package/README.md

@@ -53,6 +53,23 @@ and a live projected finishing order — during and after the race.
   from a live AIS/self vessel with a matching name), it's remembered in a small
   cross-race registry: add a boat with the same name in a later race and its MMSI
   fills in on its own.
+- **Import a whole fleet from Manage2Sail** — off by default (`raceImportEnabled` in
+  the plugin's settings, alongside `vetEnabled`); once turned on, an **Import boats
+  from Manage2Sail** section lets you paste a Manage2Sail event URL, pick one or more
+  of its classes, and add every entry in them as a boat in the current race. Since a
+  class's published handicap number isn't always a directly-usable Time-on-Time
+  factor — Yardstick numbers, for instance, run the opposite direction (lower number
+  = faster boat) and need `TCF = 100 / number` (or `1000 /` for the RYA scale) rather
+  than being used as-is — the plugin converts it automatically once it recognizes the
+  system. If a class's numbers don't clearly match a known system's scale, you're
+  asked to pick which one applies (e.g. Yardstick vs. Portsmouth Yardstick) before
+  anything is imported for it; anything else unrecognized (ORC, IRC, ...) is used
+  as-is, same as before. Re-importing updates TCF on boats it already added (matched
+  by name) instead of duplicating them. Not every entry has a named boat — where
+  Manage2Sail has no boat name, the sail number is used as the identifier instead of
+  falling back to the skipper's name, and every imported boat's sail number is also
+  set in its own **Sail #** column (editable directly, like MMSI) whether or not it
+  ended up as the name.
 - **Editable finish times** — click **Now** to record a finish as it happens, type a
   specific `HH:MM:SS` into the finish-time field to correct a mistimed click, or
   **Clear** to undo. Handles races that cross midnight.
@@ -88,23 +105,28 @@ and a live projected finishing order — during and after the race.
   both have finished. With no boat marked self, the column instead compares everyone
   against the current **leader** (tagged accordingly), so it's never just blank.
 - **Export to Excel** — a genuine `.xlsx` snapshot of the current standings (same
-  ranking, same rows as the on-screen table: rank, boat, MMSI, TCF, start time,
-  elapsed, corrected, finish time, status), with the time columns rendered in your
-  browser's own timezone rather than the server's (and with the date included, for a
-  multi-day race).
+  ranking, same rows as the on-screen table: rank, boat, sail number, MMSI, TCF,
+  start time, elapsed, corrected, finish time, status), with the time columns
+  rendered in your browser's own timezone rather than the server's (and with the
+  date included, for a multi-day race).
 - **Download Offline Timer** — a single self-contained `.html` file, seeded with the
   current race's boats, TCF, and multi-day setting, that runs the core of race timing
   (start/stop/resume/reset, add/remove boats, edit TCF, individual start times,
-  record finishes, DNF, self-comparison) with no server and no internet connection at
+  record finishes, DNF, self-comparison) with no server connection to this plugin at
   all — including its own editable **Race start** field (Now/Clear, right under the
   Start/Stop/Resume/Reset buttons) for backdating or correcting the race's start time
   directly, without needing to click Start Race and lose already-recorded progress —
   a backup for keeping a race running if
   this plugin's server becomes unreachable mid-event. It saves everything to that
   browser's own local storage, so closing and reopening the same downloaded file picks
-  up right where you left off. AIS boat names/positions, VET-tall lookup, and the
-  course/chart all need the live server and aren't included; TCF is entered by hand
-  instead. Also has its own "Download results as CSV" button.
+  up right where you left off. If VET-tall is enabled, the register is seeded in at
+  download time and a **Refresh VET register** link lets the offline page re-fetch the
+  current sheet straight from Google Sheets (no plugin server needed for that — just
+  whatever internet connection the browser has), with the same alternatives dropdown
+  and autocomplete as the main webapp. AIS boat names/positions, the course/chart, and
+  importing a fleet from Manage2Sail still need the live server (Manage2Sail's own API
+  doesn't allow browser-side fetches at all) — TCF is entered by hand for anything the
+  VET register doesn't cover. Also has its own "Download results as CSV" button.
 
 ## Install
 

package/index.js

@@ -125,6 +125,92 @@ async function resolveHandicapCsvUrl(sourceUrl) {
   return `https://docs.google.com/spreadsheets/d/${sheetId}/export?format=csv`;
 }
 
+// Manage2Sail has no public "list classes for this event" API — the event
+// page itself embeds the classes ("regattas" in their terminology) as JSON
+// in a window.boostrapedResourceData script tag, and the event's own GUID
+// (needed for the entries API below) only appears in a support-form link on
+// the same page. Both are scraped from the page's HTML.
+function parseManage2SailEventPage(html) {
+  const eventIdMatch = html.match(/EventIssue\?eventId=([0-9a-f-]{36})/i);
+  if (!eventIdMatch) {
+    throw new Error("Could not find this event's id on the page — check the URL is a Manage2Sail event page");
+  }
+  const dataMatch = html.match(/window\.boostrapedResourceData\s*=\s*(\{.*?\});/s);
+  if (!dataMatch) {
+    throw new Error('Could not find class data on the page — check the URL is a Manage2Sail event page');
+  }
+  let data;
+  try {
+    data = JSON.parse(dataMatch[1]);
+  } catch (e) {
+    throw new Error('Could not parse class data from the Manage2Sail page');
+  }
+  const classes = (data.Regatta || []).map((r) => ({ id: r.Id, name: r.Name }));
+  return { eventId: eventIdMatch[1], classes };
+}
+
+// Many entries (dinghies, small keelboats) have no named boat — the display
+// name falls back through BoatName -> SailNumber -> TeamName -> SkipperName.
+// SailNumber comes before Team/SkipperName specifically because it
+// identifies the boat itself (stable across a re-import even if the
+// skipper changes), where a person's name doesn't.
+//
+// hcp is left as the raw published number here — converting it to a usable
+// TCF depends on which handicap system it's actually under (see
+// HANDICAP_SYSTEMS / resolveHandicapSystem below), which isn't known until
+// the caller has both hcpName and a look at the actual values.
+function parseManage2SailEntries(json) {
+  const hcpName = json.HcpName || '';
+  const entries = [];
+  let skipped = 0;
+  (json.Entries || []).forEach((e) => {
+    const name = ((e.BoatName || e.SailNumber || e.TeamName || e.SkipperName || '') + '').trim();
+    const hcp = parseFloat(((e.Hcp || '') + '').replace(',', '.'));
+    if (!name || !isFinite(hcp) || hcp <= 0) {
+      skipped++;
+      return;
+    }
+    entries.push({ name, hcp, sailNumber: e.SailNumber || '' });
+  });
+  return { hcpName, entries, skipped };
+}
+
+// Handicap systems this plugin knows how to turn into a Time-on-Time TCF
+// (corrected = elapsed * TCF, higher = faster). "tcf" is the fallback: the
+// published number is assumed to already be usable as-is. Yardstick systems
+// work the other way around (lower number = faster boat) and aren't a
+// direct multiplier, so they need the conversion below instead.
+const HANDICAP_SYSTEMS = [
+  { key: 'tcf', label: 'Time-on-Time — use the published number as TCF directly', convert: (hcp) => hcp },
+  { key: 'ys', label: 'Yardstick — YS (German/DSV, scale 100): TCF = 100 / number', convert: (hcp) => 100 / hcp },
+  { key: 'py', label: 'Portsmouth Yardstick — PY/PN (RYA, scale 1000): TCF = 1000 / number', convert: (hcp) => 1000 / hcp }
+];
+
+function findHandicapSystem(key) {
+  return HANDICAP_SYSTEMS.find((s) => s.key === key) || null;
+}
+
+// hcpName alone doesn't reliably say which system is in play — different
+// clubs/countries publish under the same label with very different scales.
+// Where the label maps to exactly one system whose scale actually matches
+// the observed values, resolve automatically; otherwise report the
+// candidates so the caller can ask the user to pick.
+function resolveHandicapSystem(hcpName, sampleHcpValues) {
+  const name = (hcpName || '').trim().toUpperCase();
+  const looksDsvScale = sampleHcpValues.length > 0 && sampleHcpValues.every((v) => v >= 40 && v <= 250);
+  const looksRyaScale = sampleHcpValues.length > 0 && sampleHcpValues.every((v) => v >= 400 && v <= 3000);
+  if (name === 'YS') {
+    if (looksDsvScale && !looksRyaScale) return { resolved: 'ys' };
+    if (looksRyaScale && !looksDsvScale) return { resolved: 'py' };
+    return { resolved: null, candidates: ['ys', 'py', 'tcf'] };
+  }
+  if (name === 'PY' || name === 'PN') {
+    return { resolved: 'py' };
+  }
+  // Unrecognized/blank/ORC/IRC/etc. — default to treating it as already TCF.
+  return { resolved: 'tcf' };
+}
+
 function makeRaceId() {
   return 'r' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
 }
@@ -164,6 +250,7 @@ function ensureRaceShape(race) {
     if (b.dnf === undefined) b.dnf = false;
     if (b.dnfPosition === undefined) b.dnfPosition = null;
     if (b.startTime === undefined) b.startTime = null;
+    if (b.sailNumber === undefined) b.sailNumber = null;
   });
 }
 
@@ -258,7 +345,8 @@ function formatLocalDateTime(utcMs, tzOffsetMinutes) {
 // downloaded file picks up where it left off. Course/chart, AIS boat
 // names/positions, estimated finish, and VET-tall import all need the live
 // server and are intentionally left out.
-function buildOfflineTimerHtml(race, defaultTcf) {
+function buildOfflineTimerHtml(race, defaultTcf, vetOptions) {
+  vetOptions = vetOptions || {};
   const seed = {
     name: race.name,
     startTime: race.startTime,
@@ -266,9 +354,13 @@ function buildOfflineTimerHtml(race, defaultTcf) {
     selfBoatId: race.selfBoatId,
     multiDay: !!race.multiDay,
     defaultTcf: defaultTcf,
+    vetEnabled: !!vetOptions.vetEnabled,
+    handicapCsvUrl: vetOptions.handicapCsvUrl || null,
+    handicapBoats: vetOptions.handicapBoats || [],
     boats: Object.values(race.boats).map((b) => ({
       id: b.id,
       name: b.name,
+      sailNumber: b.sailNumber || null,
       tcf: b.tcf != null ? b.tcf : defaultTcf,
       startTime: b.startTime || null,
       finishTime: b.finishTime || null,
@@ -310,6 +402,8 @@ h2 { margin: 0 0 0.75rem; font-size: 1.3rem; }
 .race-start-row { margin-top: 0.6rem; display: flex; gap: 0.4rem; justify-content: center; align-items: center; font-size: 0.85rem; color: var(--muted); flex-wrap: wrap; }
 .race-start-row input { padding: 0.3rem 0.4rem; background: var(--panel); color: var(--text); border: 1px solid var(--border); border-radius: 4px; font-variant-numeric: tabular-nums; }
 .race-start-row button { padding: 0.3rem 0.6rem; font-size: 0.8rem; }
+.vet-status { display: flex; gap: 0.6rem; justify-content: center; align-items: center; margin-top: 0.4rem; }
+.link-btn { background: none; border: none; padding: 0; font-size: 0.8rem; color: var(--accent); text-decoration: underline; cursor: pointer; }
 button { font-size: 0.95rem; padding: 0.5rem 1.1rem; border-radius: 6px; border: 1px solid var(--border); background: var(--accent); color: #04202e; font-weight: 600; cursor: pointer; }
 button.secondary { background: transparent; color: var(--text); }
 button.danger { border-color: var(--bad); color: var(--bad); }
@@ -329,8 +423,13 @@ tbody tr.finished td { color: var(--good); }
 tbody tr.dnf td { color: var(--muted); }
 .dnf-tag { color: var(--bad); font-weight: 700; font-size: 0.85rem; letter-spacing: 0.03em; }
 .tcf-input { width: 5.5rem; padding: 0.3rem 0.4rem; background: var(--panel); color: var(--text); border: 1px solid var(--border); border-radius: 4px; }
+.sail-number-input { width: 5.5rem; padding: 0.3rem 0.4rem; background: var(--panel); color: var(--text); border: 1px solid var(--border); border-radius: 4px; }
 .tcf-input::-webkit-outer-spin-button, .tcf-input::-webkit-inner-spin-button { -webkit-appearance: none; margin: 0; }
 .tcf-input[type='number'] { -moz-appearance: textfield; }
+.vet-cell { display: flex; flex-wrap: wrap; gap: 0.3rem; align-items: center; min-width: 11rem; }
+.vet-select { max-width: 13rem; padding: 0.3rem 0.4rem; background: var(--panel); color: var(--text); border: 1px solid var(--border); border-radius: 4px; font-size: 0.8rem; }
+.vet-badge { font-size: 0.7rem; color: var(--muted); }
+.vet-badge.warn { color: var(--bad); }
 .self-btn { background: none; border: none; padding: 0 0.3rem 0 0; font-size: 1rem; color: var(--muted); cursor: pointer; vertical-align: middle; }
 .self-btn.active { color: var(--accent); }
 .vs-self { font-variant-numeric: tabular-nums; font-size: 0.85rem; color: var(--muted); }
@@ -349,10 +448,10 @@ tbody tr.dnf td { color: var(--muted); }
 <body>
 <header>
   <h1>Race Control — Offline Timer</h1>
-  <p class="offline-note">Standalone backup — works with no server or internet connection.
+  <p class="offline-note">Standalone backup — works with no server connection to this plugin.
     Everything you do here is saved in this browser only (reopen this same downloaded file
-    to continue). Boat names/positions from AIS, VET-tall handicap lookup, and the
-    course/chart aren't available offline — TCF is entered by hand.</p>
+    to continue). Boat names/positions from AIS and the course/chart aren't available
+    offline. ${vetOptions.vetEnabled ? 'VET-tall handicaps can be refreshed here directly from the internet (see below) — importing a whole fleet from Manage2Sail still needs the live plugin server, though.' : 'TCF is entered by hand.'}</p>
   <h2 id="raceName"></h2>
   <div id="clock" class="clock">00:00:00</div>
   <div class="controls">
@@ -367,11 +466,16 @@ tbody tr.dnf td { color: var(--muted); }
     <button id="raceStartNowBtn" type="button" class="secondary">Now</button>
     <button id="raceStartClearBtn" type="button" class="secondary">Clear</button>
   </div>
+  <div id="vetStatusLine" class="status vet-status" hidden>
+    <span id="vetStatusText"></span>
+    <button id="vetRefreshBtn" type="button" class="link-btn">Refresh VET register</button>
+  </div>
   <div id="statusLine" class="status"></div>
 </header>
 <main>
   <div class="add-boat-row">
-    <input type="text" id="addBoatName" placeholder="Add boat by name…" autocomplete="off" />
+    <input type="text" id="addBoatName" placeholder="Add boat by name…" autocomplete="off" list="addBoatSuggestions" />
+    <datalist id="addBoatSuggestions"></datalist>
     <input type="number" id="addBoatTcf" step="0.001" min="0.01" title="TCF" />
     <button id="addBoatBtn">Add Boat</button>
   </div>
@@ -380,7 +484,9 @@ tbody tr.dnf td { color: var(--muted); }
       <thead>
         <tr>
           <th>Boat</th>
+          <th>Sail #</th>
           <th>TCF</th>
+          <th id="vetAlternativesTh" hidden>VET alternatives</th>
           <th>Start time</th>
           <th>Elapsed</th>
           <th>Corrected</th>
@@ -417,8 +523,16 @@ tbody tr.dnf td { color: var(--muted); }
       race = seed;
       save();
     }
+    // vetEnabled/handicapCsvUrl reflect the server's current plugin config,
+    // not user-entered race data, so a re-download's seed always wins for
+    // those even if a locally-saved copy is otherwise newer. The fetched
+    // register itself is kept from local storage when present, so an
+    // already-refreshed register isn't thrown away by a re-download.
+    race.vetEnabled = !!seed.vetEnabled;
+    race.handicapCsvUrl = seed.handicapCsvUrl || null;
+    if (!Array.isArray(race.handicapBoats)) race.handicapBoats = seed.handicapBoats || [];
   } catch (e) {
-    race = { name: 'Race', startTime: null, stopTime: null, selfBoatId: null, multiDay: false, boats: [], defaultTcf: 1.0 };
+    race = { name: 'Race', startTime: null, stopTime: null, selfBoatId: null, multiDay: false, boats: [], defaultTcf: 1.0, vetEnabled: false, handicapCsvUrl: null, handicapBoats: [] };
   }
 
   function save() {
@@ -468,6 +582,164 @@ tbody tr.dnf td { color: var(--muted); }
     statusEl.classList.toggle('error', !!isError);
   }
 
+  var vetStatusLine = document.getElementById('vetStatusLine');
+  var vetStatusText = document.getElementById('vetStatusText');
+  var vetRefreshBtn = document.getElementById('vetRefreshBtn');
+  var vetAlternativesTh = document.getElementById('vetAlternativesTh');
+  var addBoatSuggestions = document.getElementById('addBoatSuggestions');
+  var handicapVersion = 0;
+  function setVetStatus(msg, isError) {
+    vetStatusText.textContent = msg || '';
+    vetStatusText.classList.toggle('error', !!isError);
+  }
+
+  // Mirrors the plugin server's own CSV parsing (index.js: parseCsvText /
+  // parseNorwegianNumber / parseHandicapSheet) so this page can refresh the
+  // VET-tall register on its own — the sheet export is CORS-friendly and
+  // fetchable directly from a browser, unlike the SSCA lookup page or
+  // Manage2Sail, which is why only VET-tall (not fleet import) works offline.
+  function parseCsvText(text) {
+    var rows = [];
+    var row = [];
+    var field = '';
+    var inQuotes = false;
+    for (var i = 0; i < text.length; i++) {
+      var c = text[i];
+      if (inQuotes) {
+        if (c === '"') {
+          if (text[i + 1] === '"') { field += '"'; i++; } else { inQuotes = false; }
+        } else {
+          field += c;
+        }
+      } else if (c === '"') {
+        inQuotes = true;
+      } else if (c === ',') {
+        row.push(field); field = '';
+      } else if (c === '\\n') {
+        row.push(field); rows.push(row); row = []; field = '';
+      } else if (c === '\\r') {
+        // ignore
+      } else {
+        field += c;
+      }
+    }
+    if (field.length || row.length) { row.push(field); rows.push(row); }
+    return rows;
+  }
+  function parseNorwegianNumber(s) {
+    if (s == null) return null;
+    var t = String(s).trim().replace(',', '.');
+    if (t === '') return null;
+    var n = Number(t);
+    return isFinite(n) ? n : null;
+  }
+  function parseHandicapSheet(csvText) {
+    var rows = parseCsvText(csvText);
+    var headerRowIndex = -1;
+    for (var i = 0; i < rows.length; i++) {
+      if (rows[i].indexOf('Klasse') !== -1 && rows[i].indexOf('VET 1') !== -1) { headerRowIndex = i; break; }
+    }
+    if (headerRowIndex === -1) throw new Error('Could not find the "Klasse" / "VET 1" header row in the handicap sheet');
+    var header = rows[headerRowIndex];
+    function col(name) { return header.indexOf(name); }
+    var vetCols = [col('VET 1'), col('VET 2'), col('VET 3')].filter(function (i) { return i !== -1; });
+    var classCol = col('Klasse');
+    var ownerCol = col('Eier');
+    var boats = [];
+    for (var r = headerRowIndex + 1; r < rows.length; r++) {
+      var row = rows[r];
+      var name = (row[0] || '').trim();
+      if (!name) continue;
+      var validity = (row[1] || '').trim();
+      var vets = vetCols.map(function (vc, idx) {
+        var value = parseNorwegianNumber(row[vc]);
+        if (value == null) return null;
+        var label = (row[vc - 1] || '').replace(/:\\s*$/, '').trim() || ('VET ' + (idx + 1));
+        return { label: label, value: value };
+      }).filter(Boolean);
+      if (!vets.length) continue;
+      boats.push({
+        name: name,
+        validity: validity,
+        class: classCol !== -1 ? (row[classCol] || '').trim() : '',
+        owner: ownerCol !== -1 ? (row[ownerCol] || '').trim() : '',
+        vets: vets
+      });
+    }
+    return boats;
+  }
+
+  function rebuildAddBoatSuggestions() {
+    addBoatSuggestions.innerHTML = '';
+    var seen = {};
+    race.handicapBoats.forEach(function (b) {
+      var key = b.name.toLowerCase();
+      if (seen[key]) return;
+      seen[key] = true;
+      var opt = document.createElement('option');
+      opt.value = b.name;
+      addBoatSuggestions.appendChild(opt);
+    });
+  }
+
+  function loadHandicapRegister(force) {
+    if (!race.vetEnabled) return;
+    if (!race.handicapCsvUrl) {
+      setVetStatus('No VET register configured on the server.', true);
+      return;
+    }
+    setVetStatus('Loading VET register…');
+    fetch(race.handicapCsvUrl)
+      .then(function (res) {
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        return res.text();
+      })
+      .then(function (csvText) {
+        race.handicapBoats = parseHandicapSheet(csvText);
+        handicapVersion++;
+        save();
+        rebuildAddBoatSuggestions();
+        setVetStatus('VET register: ' + race.handicapBoats.length + ' boats loaded.');
+        render();
+      })
+      .catch(function (e) {
+        setVetStatus('Could not load VET register: ' + e.message, true);
+      });
+  }
+
+  // Rebuilds a row's VET-alternatives <select> from the current register —
+  // only called when the register itself (re)loads, not every render tick.
+  function refreshVetAlternatives(row, boatName) {
+    var entry = race.handicapBoats.find(function (h) { return h.name.toLowerCase() === boatName.trim().toLowerCase(); });
+    row.vetSelect.innerHTML = '';
+    var placeholder = document.createElement('option');
+    placeholder.value = '';
+    placeholder.textContent = entry ? 'Pick VET…' : 'No VET match';
+    row.vetSelect.appendChild(placeholder);
+    row.vetSelect.disabled = !entry;
+    if (entry) {
+      entry.vets.forEach(function (v) {
+        var opt = document.createElement('option');
+        opt.value = String(v.value);
+        opt.textContent = v.label + ': ' + v.value;
+        row.vetSelect.appendChild(opt);
+      });
+      var notValid = /ikke/i.test(entry.validity || '');
+      row.vetBadge.textContent = entry.validity ? (notValid ? '⚠ ' + entry.validity : entry.validity) : '';
+      row.vetBadge.classList.toggle('warn', notValid);
+    } else {
+      row.vetBadge.textContent = '';
+      row.vetBadge.classList.remove('warn');
+    }
+  }
+  function syncVetSelectValue(row, tcf) {
+    if (document.activeElement === row.vetSelect) return;
+    var match = Array.from(row.vetSelect.options).find(function (o) {
+      return o.value !== '' && Math.abs(parseFloat(o.value) - tcf) < 1e-9;
+    });
+    row.vetSelect.value = match ? match.value : '';
+  }
+
   function pad(n) { return String(n).padStart(2, '0'); }
   function fmtDuration(ms) {
     if (ms == null || ms < 0 || !isFinite(ms)) return '--:--:--';
@@ -653,6 +925,20 @@ tbody tr.dnf td { color: var(--muted); }
     var tdName = document.createElement('td');
     tdName.append(selfBtn, nameSpan);
 
+    var sailNumberInput = document.createElement('input');
+    sailNumberInput.type = 'text';
+    sailNumberInput.className = 'sail-number-input';
+    sailNumberInput.placeholder = 'Sail #';
+    sailNumberInput.addEventListener('change', function () {
+      var boat = findBoat(boatId);
+      if (!boat) return;
+      boat.sailNumber = sailNumberInput.value.trim() || null;
+      save();
+      render();
+    });
+    var tdSailNumber = document.createElement('td');
+    tdSailNumber.appendChild(sailNumberInput);
+
     var tcfInput = document.createElement('input');
     tcfInput.type = 'number';
     tcfInput.step = '0.001';
@@ -672,6 +958,27 @@ tbody tr.dnf td { color: var(--muted); }
     var tdTcf = document.createElement('td');
     tdTcf.appendChild(tcfInput);
 
+    var vetSelect = document.createElement('select');
+    vetSelect.className = 'vet-select';
+    vetSelect.addEventListener('change', function () {
+      var val = parseFloat(vetSelect.value);
+      var boat = findBoat(boatId);
+      if (boat && isFinite(val) && val > 0) {
+        boat.tcf = val;
+        save();
+        render();
+      }
+      // Left showing the picked alternative (synced from tcf on future
+      // renders) rather than reset to the placeholder — see
+      // syncVetSelectValue.
+    });
+    var vetBadge = document.createElement('span');
+    vetBadge.className = 'vet-badge';
+    var tdVet = document.createElement('td');
+    tdVet.className = 'vet-cell';
+    tdVet.hidden = !race.vetEnabled;
+    tdVet.append(vetSelect, vetBadge);
+
     var startTimeInput = document.createElement('input');
     startTimeInput.type = race.multiDay ? 'datetime-local' : 'time';
     startTimeInput.step = '1';
@@ -813,9 +1120,10 @@ tbody tr.dnf td { color: var(--muted); }
     var tdRemove = document.createElement('td');
     tdRemove.appendChild(removeBtn);
 
-    tr.append(tdName, tdTcf, tdStart, tdElapsed, tdCorrected, tdVsSelf, tdFinish, tdRemove);
+    tr.append(tdName, tdSailNumber, tdTcf, tdVet, tdStart, tdElapsed, tdCorrected, tdVsSelf, tdFinish, tdRemove);
     return {
-      tr: tr, selfBtn: selfBtn, nameSpan: nameSpan, tcfInput: tcfInput,
+      tr: tr, selfBtn: selfBtn, nameSpan: nameSpan, sailNumberInput: sailNumberInput, tcfInput: tcfInput,
+      vetSelect: vetSelect, vetBadge: vetBadge, vetHandicapVersion: -1,
       startTimeInput: startTimeInput, startNowBtn: startNowBtn, startClearBtn: startClearBtn,
       tdElapsed: tdElapsed, tdCorrected: tdCorrected, tdVsSelf: tdVsSelf,
       finishNormalWrap: finishNormalWrap, finishTimeInput: finishTimeInput, dnfWrap: dnfWrap
@@ -853,7 +1161,15 @@ tbody tr.dnf td { color: var(--muted); }
       var isSelf = b.id === race.selfBoatId;
       row.selfBtn.textContent = isSelf ? '★' : '☆';
       row.selfBtn.classList.toggle('active', isSelf);
+      if (document.activeElement !== row.sailNumberInput) row.sailNumberInput.value = b.sailNumber || '';
       if (document.activeElement !== row.tcfInput) row.tcfInput.value = b.tcf;
+      if (race.vetEnabled) {
+        if (row.vetHandicapVersion !== handicapVersion && document.activeElement !== row.vetSelect) {
+          refreshVetAlternatives(row, b.name);
+          row.vetHandicapVersion = handicapVersion;
+        }
+        syncVetSelectValue(row, b.tcf);
+      }
       if (document.activeElement !== row.startTimeInput) {
         row.startTimeInput.value = race.multiDay ? tsToDateTimeInputValue(b.startTime) : tsToTimeInputValue(b.startTime);
       }
@@ -905,7 +1221,7 @@ tbody tr.dnf td { color: var(--muted); }
     if (!name) { setStatus('Enter a boat name to add.', true); addBoatName.focus(); return; }
     var tcf = parseFloat(addBoatTcf.value);
     if (!isFinite(tcf) || tcf <= 0) tcf = race.defaultTcf || 1.0;
-    race.boats.push({ id: genId(), name: name, tcf: tcf, startTime: null, finishTime: null, dnf: false });
+    race.boats.push({ id: genId(), name: name, sailNumber: null, tcf: tcf, startTime: null, finishTime: null, dnf: false });
     save();
     addBoatName.value = '';
     addBoatName.focus();
@@ -919,13 +1235,13 @@ tbody tr.dnf td { color: var(--muted); }
 
   downloadCsvBtn.addEventListener('click', function () {
     var fmtWhen = race.multiDay ? tsToDateTimeInputValue : tsToTimeInputValue;
-    var rows = [['Rank', 'Boat', 'TCF', 'Start Time', 'Elapsed', 'Corrected', 'Finish Time', 'Status']];
+    var rows = [['Rank', 'Boat', 'Sail Number', 'TCF', 'Start Time', 'Elapsed', 'Corrected', 'Finish Time', 'Status']];
     rankedList().forEach(function (r, i) {
       var status = r.boat.dnf ? 'DNF' : r.boat.finishTime ? 'Finished' : race.startTime ? 'Racing' : 'Not started';
       var rankLabel = r.boat.dnf ? 'DNF' : r.rankMs != null ? String(i + 1) : '';
       var start = effectiveStart(r.boat);
       rows.push([
-        rankLabel, r.boat.name, r.boat.tcf, start ? fmtWhen(start) : '', fmtDuration(r.elapsedMs), fmtDuration(r.correctedMs),
+        rankLabel, r.boat.name, r.boat.sailNumber || '', r.boat.tcf, start ? fmtWhen(start) : '', fmtDuration(r.elapsedMs), fmtDuration(r.correctedMs),
         r.boat.finishTime ? fmtWhen(r.boat.finishTime) : '', status
       ]);
     });
@@ -946,6 +1262,17 @@ tbody tr.dnf td { color: var(--muted); }
     setTimeout(function () { URL.revokeObjectURL(url); }, 1000);
   });
 
+  vetStatusLine.hidden = !race.vetEnabled;
+  vetAlternativesTh.hidden = !race.vetEnabled;
+  vetRefreshBtn.addEventListener('click', function () { loadHandicapRegister(true); });
+  if (race.vetEnabled) {
+    rebuildAddBoatSuggestions();
+    if (race.handicapBoats.length) {
+      setVetStatus('VET register: ' + race.handicapBoats.length + ' boats loaded (from last download/refresh).');
+    }
+    loadHandicapRegister();
+  }
+
   render();
   setInterval(render, 1000);
 })();
@@ -982,6 +1309,12 @@ module.exports = function (app) {
         title:
           'Use the VET-tall register for autocomplete and per-boat handicap alternatives. When off, every boat is treated as outside VET: TCF is remembered per boat name across races instead.',
         default: false
+      },
+      raceImportEnabled: {
+        type: 'boolean',
+        title:
+          'Allow importing a complete fleet (every boat, with TCF) into a race from an external regatta system — currently Manage2Sail. Off by default, since it fetches from a third-party site and bulk-adds boats.',
+        default: false
       }
     }
   };
@@ -1042,6 +1375,12 @@ module.exports = function (app) {
     return !!(plugin.options && plugin.options.vetEnabled === true);
   }
 
+  // Plugin config setting, same pattern as vetEnabled — off by default, not
+  // per-race, not writable from the webapp itself.
+  function isRaceImportEnabled() {
+    return !!(plugin.options && plugin.options.raceImportEnabled === true);
+  }
+
   // A boat only counts as "in VET" for registry-TCF purposes while the
   // config setting has VET enabled and the register (whatever's currently
   // cached) actually has a matching name — disabling VET makes every boat
@@ -1386,6 +1725,25 @@ module.exports = function (app) {
     return handicapCache;
   }
 
+  async function fetchManage2SailClasses(eventUrl) {
+    const res = await fetch(eventUrl);
+    if (!res.ok) {
+      throw new Error(`Could not load ${eventUrl}: HTTP ${res.status}`);
+    }
+    const html = await res.text();
+    return parseManage2SailEventPage(html);
+  }
+
+  async function fetchManage2SailEntries(eventId, regattaId) {
+    const url = `https://www.manage2sail.com/api/event/${encodeURIComponent(eventId)}/regattaentry?regattaId=${encodeURIComponent(regattaId)}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Manage2Sail entries request failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    return parseManage2SailEntries(json);
+  }
+
   let trackTimer = null;
 
   plugin.start = function (options) {
@@ -1471,7 +1829,7 @@ module.exports = function (app) {
       // calendar days, so the date is included alongside the time —
       // otherwise just the time-of-day, matching how they're entered.
       const fmtWhen = race.multiDay ? formatLocalDateTime : formatLocalTime;
-      const headers = ['Rank', 'Boat', 'MMSI', 'TCF', 'Start Time', 'Elapsed', 'Corrected', 'Finish Time', 'Status'];
+      const headers = ['Rank', 'Boat', 'Sail Number', 'MMSI', 'TCF', 'Start Time', 'Elapsed', 'Corrected', 'Finish Time', 'Status'];
 
       const workbook = new ExcelJS.Workbook();
       workbook.creator = 'Race Control';
@@ -1506,6 +1864,7 @@ module.exports = function (app) {
         sheet.addRow([
           rankLabel,
           r.boat.name,
+          r.boat.sailNumber || '',
           r.boat.mmsi || '',
           r.boat.tcf,
           start ? fmtWhen(start, tz) : '',
@@ -1516,7 +1875,7 @@ module.exports = function (app) {
         ]);
       });
 
-      const widths = [7, 24, 12, 8, race.multiDay ? 17 : 12, 12, 12, race.multiDay ? 17 : 12, 12];
+      const widths = [7, 24, 12, 12, 8, race.multiDay ? 17 : 12, 12, 12, race.multiDay ? 17 : 12, 12];
       widths.forEach((w, i) => {
         sheet.getColumn(i + 1).width = w;
       });
@@ -1536,12 +1895,38 @@ module.exports = function (app) {
     // A standalone, self-contained backup timer: current boats/TCF/progress
     // baked in, everything else (start/stop, finishes, DNF, self-compare)
     // runs entirely client-side with no server — see buildOfflineTimerHtml.
-    router.get('/races/:id/export-offline.html', (req, res) => {
+    router.get('/races/:id/export-offline.html', async (req, res) => {
       const race = getRace(req.params.id);
       if (!race) return res.status(404).json({ error: 'No such race' });
       ensureRaceShape(race);
       const defaultTcf = (plugin.options && plugin.options.defaultTcf) || 1.0;
-      const html = buildOfflineTimerHtml(race, defaultTcf);
+      // The offline page can fetch a fresh VET-tall register on its own later
+      // (the CSV export is CORS-friendly, unlike the SSCA page or
+      // Manage2Sail), but it's seeded with whatever we can get right now so
+      // it's useful before the first live refresh too.
+      let handicapCsvUrl = null;
+      let handicapBoats = [];
+      if (isVetEnabled()) {
+        try {
+          const data = await fetchHandicapBoats();
+          handicapCsvUrl = data.csvUrl;
+          handicapBoats = data.boats;
+        } catch (e) {
+          try {
+            const sourceUrl = (plugin.options && plugin.options.handicapSourceUrl) || DEFAULT_HANDICAP_SOURCE_PAGE;
+            handicapCsvUrl = await resolveHandicapCsvUrl(sourceUrl);
+          } catch (e2) {
+            // Leave handicapCsvUrl null — the offline page's own refresh will
+            // report a clear error until it's tried again with a working
+            // connection.
+          }
+        }
+      }
+      const html = buildOfflineTimerHtml(race, defaultTcf, {
+        vetEnabled: isVetEnabled(),
+        handicapCsvUrl,
+        handicapBoats
+      });
       const safeName = (race.name || 'race').replace(/[^a-z0-9\-_]+/gi, '_').slice(0, 60) || 'race';
       res.setHeader('Content-Type', 'text/html; charset=utf-8');
       res.setHeader('Content-Disposition', `attachment; filename="${safeName}-offline-timer.html"`);
@@ -1782,6 +2167,7 @@ module.exports = function (app) {
         id: makeBoatId(),
         name,
         mmsi: mmsi || null,
+        sailNumber: null,
         tcf,
         finishTime: null,
         startTime: null,
@@ -1885,6 +2271,17 @@ module.exports = function (app) {
       res.json(boat);
     });
 
+    router.put('/races/:id/boats/:boatId/sailNumber', (req, res) => {
+      const race = getRace(req.params.id);
+      if (!race) return res.status(404).json({ error: 'No such race' });
+      const boat = getBoat(race, req.params.boatId);
+      if (!boat) return res.status(404).json({ error: 'No such boat' });
+      const sailNumber = ((req.body && req.body.sailNumber) || '').toString().trim();
+      boat.sailNumber = sailNumber || null;
+      saveState();
+      res.json(boat);
+    });
+
     router.get('/boat-registry', (req, res) => {
       res.json({ boats: Object.values(state.boatRegistry) });
     });
@@ -1922,6 +2319,113 @@ module.exports = function (app) {
         res.status(502).json({ error: 'Could not load handicap register: ' + e.message });
       }
     });
+
+    // Plugin config setting (Server -> Plugin Config), same pattern as
+    // vet-enabled — the webapp only reads it to know whether to show the
+    // import section at all.
+    router.get('/race-import-enabled', (req, res) => {
+      res.json({ enabled: isRaceImportEnabled() });
+    });
+
+    // Resolves a Manage2Sail event URL to its classes, so the webapp can
+    // offer a picker before importing anything.
+    router.get('/import/manage2sail/classes', async (req, res) => {
+      if (!isRaceImportEnabled()) return res.status(403).json({ error: 'Race import is disabled in the plugin settings' });
+      const eventUrl = ((req.query.eventUrl || '') + '').trim();
+      if (!eventUrl) return res.status(400).json({ error: 'eventUrl is required' });
+      try {
+        const { eventId, classes } = await fetchManage2SailClasses(eventUrl);
+        res.json({ eventId, classes });
+      } catch (e) {
+        res.status(502).json({ error: 'Could not read classes from Manage2Sail: ' + e.message });
+      }
+    });
+
+    // The handicap systems this plugin can convert to a usable TCF — the
+    // webapp uses this to label the disambiguation picker when a class's
+    // system can't be resolved automatically (see resolveHandicapSystem).
+    router.get('/import/manage2sail/handicap-systems', (req, res) => {
+      if (!isRaceImportEnabled()) return res.status(403).json({ error: 'Race import is disabled in the plugin settings' });
+      res.json({ systems: HANDICAP_SYSTEMS.map((s) => ({ key: s.key, label: s.label })) });
+    });
+
+    // Imports every entry from the given class(es) of a Manage2Sail event as
+    // boats in this race — a new boat per entry (name falls back from
+    // BoatName to TeamName/SkipperName). The published Hcp number is
+    // converted to TCF via whichever handicap system the class turns out to
+    // use (see resolveHandicapSystem) — pass systemOverrides: {classId: key}
+    // to pick one explicitly for a class flagged in needsSystemChoice on a
+    // prior call, rather than re-guessing. Re-importing updates TCF on
+    // boats already added by name rather than duplicating them.
+    router.post('/races/:id/import/manage2sail', async (req, res) => {
+      if (!isRaceImportEnabled()) return res.status(403).json({ error: 'Race import is disabled in the plugin settings' });
+      const race = getRace(req.params.id);
+      if (!race) return res.status(404).json({ error: 'No such race' });
+      const eventId = ((req.body && req.body.eventId) || '').toString().trim();
+      const classIds = Array.isArray(req.body && req.body.classIds) ? req.body.classIds : [];
+      const systemOverrides = (req.body && req.body.systemOverrides) || {};
+      if (!eventId || !classIds.length) {
+        return res.status(400).json({ error: 'eventId and at least one classId are required' });
+      }
+      const existingByName = new Map(Object.values(race.boats).map((b) => [b.name.trim().toLowerCase(), b]));
+      let added = 0;
+      let updated = 0;
+      let skipped = 0;
+      const conversions = [];
+      const needsSystemChoice = [];
+      try {
+        for (const regattaId of classIds) {
+          const { hcpName, entries, skipped: classSkipped } = await fetchManage2SailEntries(eventId, regattaId);
+          skipped += classSkipped;
+          if (!entries.length) continue;
+          const overrideKey = systemOverrides[regattaId];
+          let systemKey = overrideKey && findHandicapSystem(overrideKey) ? overrideKey : null;
+          if (!systemKey) {
+            const resolution = resolveHandicapSystem(
+              hcpName,
+              entries.map((e) => e.hcp)
+            );
+            if (!resolution.resolved) {
+              needsSystemChoice.push({ classId: regattaId, hcpName, candidates: resolution.candidates });
+              continue;
+            }
+            systemKey = resolution.resolved;
+          }
+          const system = findHandicapSystem(systemKey);
+          conversions.push({ classId: regattaId, hcpName, system: systemKey });
+          entries.forEach((entry) => {
+            const tcf = Math.round(system.convert(entry.hcp) * 1000) / 1000;
+            const key = entry.name.toLowerCase();
+            const existing = existingByName.get(key);
+            if (existing) {
+              existing.tcf = tcf;
+              existing.sailNumber = entry.sailNumber || existing.sailNumber;
+              updated++;
+            } else {
+              const boat = {
+                id: makeBoatId(),
+                name: entry.name,
+                mmsi: null,
+                sailNumber: entry.sailNumber || null,
+                tcf,
+                finishTime: null,
+                startTime: null,
+                track: [],
+                dnf: false,
+                dnfPosition: null
+              };
+              race.boats[boat.id] = boat;
+              existingByName.set(key, boat);
+              added++;
+            }
+          });
+        }
+      } catch (e) {
+        return res.status(502).json({ error: 'Could not import from Manage2Sail: ' + e.message });
+      }
+      saveState();
+      res.json({ race: raceWithEstimates(race), added, updated, skipped, conversions, needsSystemChoice });
+    });
   };
 
   return plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-race-control",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "SignalK plugin and webapp for tracking elapsed and handicap-corrected (Time-on-Time) race time, with a per-boat editable TCF and boat names pulled from AIS when available.",
   "main": "index.js",
   "keywords": [

package/public/app.js

@@ -13,6 +13,11 @@
   let handicapBoats = [];
   let handicapVersion = 0; // bumped each successful VET-register load
   let vetEnabled = false; // plugin config setting (Server -> Plugin Config), read-only here; off by default
+  let raceImportEnabled = false; // plugin config setting, same pattern as vetEnabled
+  let importEventId = null; // Manage2Sail event id from the last successful "Find Classes" lookup
+  let importClasses = []; // [{id, name}] from that same lookup
+  let importSystemOverrides = {}; // classId -> handicap system key, from the disambiguation picker
+  let importHandicapSystems = null; // [{key, label}], fetched lazily on first ambiguity
   let startLineRefs = null; // [pointRefs, pointRefs] or null
   let finishLineRefs = null;
   let markRefs = []; // [pointRefs, ...]
@@ -72,6 +77,15 @@
   const replaySlider = document.getElementById('replaySlider');
   const replayTimeLabel = document.getElementById('replayTimeLabel');
   const replayLiveBtn = document.getElementById('replayLiveBtn');
+  const raceImportSection = document.getElementById('raceImportSection');
+  const raceImportToggleBtn = document.getElementById('raceImportToggleBtn');
+  const raceImportBody = document.getElementById('raceImportBody');
+  const importEventUrl = document.getElementById('importEventUrl');
+  const importFindClassesBtn = document.getElementById('importFindClassesBtn');
+  const importClassesList = document.getElementById('importClassesList');
+  const importSystemChoices = document.getElementById('importSystemChoices');
+  const importBoatsBtn = document.getElementById('importBoatsBtn');
+  const importStatusText = document.getElementById('importStatusText');
 
   function unwrapValue(x) {
     if (x && typeof x === 'object' && 'value' in x) return x.value;
@@ -338,6 +352,17 @@
     vetAlternativesTh.hidden = !vetEnabled;
   }
 
+  // Same pattern as loadVetEnabled — when disabled, the whole import
+  // section is removed rather than shown disabled.
+  async function loadRaceImportEnabled() {
+    try {
+      const data = await fetchJSON(`${API}/race-import-enabled`);
+      raceImportEnabled = data.enabled === true;
+    } catch (e) {
+      raceImportEnabled = false;
+    }
+  }
+
   async function loadHandicapRegister(force) {
     if (!vetEnabled) return;
     try {
@@ -750,6 +775,23 @@
     }
   }
 
+  async function setSailNumber(boatId, sailNumber) {
+    if (!activeRaceId) return;
+    try {
+      const boat = await fetchJSON(
+        `${API}/races/${encodeURIComponent(activeRaceId)}/boats/${encodeURIComponent(boatId)}/sailNumber`,
+        {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ sailNumber })
+        }
+      );
+      raceState.boats[boatId] = boat;
+    } catch (e) {
+      setStatus(e.message, true);
+    }
+  }
+
   async function setTcf(boatId, tcf) {
     if (!activeRaceId) return;
     try {
@@ -952,6 +994,143 @@
     }
   }
 
+  // ---- Manage2Sail import ----------------------------------------------
+
+  function setImportStatus(msg, isError) {
+    importStatusText.textContent = msg || '';
+    importStatusText.classList.toggle('error', !!isError);
+  }
+
+  async function findImportClasses() {
+    const url = importEventUrl.value.trim();
+    if (!url) {
+      setImportStatus('Paste a Manage2Sail event URL first.', true);
+      return;
+    }
+    importBoatsBtn.hidden = true;
+    importClassesList.innerHTML = '';
+    importSystemChoices.innerHTML = '';
+    importSystemOverrides = {};
+    importEventId = null;
+    importClasses = [];
+    setImportStatus('Looking up classes…');
+    try {
+      const data = await fetchJSON(`${API}/import/manage2sail/classes?eventUrl=${encodeURIComponent(url)}`);
+      importEventId = data.eventId;
+      importClasses = data.classes || [];
+      if (!importClasses.length) {
+        setImportStatus('No classes found on that event.', true);
+        return;
+      }
+      importClassesList.innerHTML = '';
+      importClasses.forEach((c) => {
+        const label = document.createElement('label');
+        const cb = document.createElement('input');
+        cb.type = 'checkbox';
+        cb.value = c.id;
+        label.append(cb, document.createTextNode(c.name));
+        importClassesList.appendChild(label);
+      });
+      importBoatsBtn.hidden = false;
+      setImportStatus(`Found ${importClasses.length} class${importClasses.length === 1 ? '' : 'es'} — pick which to import.`);
+    } catch (e) {
+      setImportStatus(e.message, true);
+    }
+  }
+
+  async function loadImportHandicapSystems() {
+    if (importHandicapSystems) return importHandicapSystems;
+    try {
+      const data = await fetchJSON(`${API}/import/manage2sail/handicap-systems`);
+      importHandicapSystems = data.systems || [];
+    } catch (e) {
+      importHandicapSystems = [];
+    }
+    return importHandicapSystems;
+  }
+
+  function importClassName(classId) {
+    const c = importClasses.find((cl) => cl.id === classId);
+    return c ? c.name : classId;
+  }
+
+  function importSystemLabel(key) {
+    const s = (importHandicapSystems || []).find((sys) => sys.key === key);
+    return s ? s.label : key;
+  }
+
+  // A class ends up here only when its handicap system couldn't be resolved
+  // automatically (e.g. "YS" whose values don't clearly match either the
+  // German or RYA Yardstick scale) — one picker per such class, defaulting
+  // to its first candidate so a re-click of Import works even if the user
+  // doesn't touch the dropdown, but they should actually check it's right.
+  async function renderSystemChoices(needsSystemChoice) {
+    importSystemChoices.innerHTML = '';
+    if (!needsSystemChoice.length) return;
+    await loadImportHandicapSystems();
+    needsSystemChoice.forEach((item) => {
+      if (importSystemOverrides[item.classId] == null) {
+        importSystemOverrides[item.classId] = item.candidates[0];
+      }
+      const row = document.createElement('div');
+      row.className = 'import-system-choice-row';
+      const label = document.createElement('span');
+      label.textContent = `${importClassName(item.classId)} (published as "${item.hcpName}") — which handicap system is this?`;
+      const select = document.createElement('select');
+      item.candidates.forEach((key) => {
+        const opt = document.createElement('option');
+        opt.value = key;
+        opt.textContent = importSystemLabel(key);
+        select.appendChild(opt);
+      });
+      select.value = importSystemOverrides[item.classId];
+      select.addEventListener('change', () => {
+        importSystemOverrides[item.classId] = select.value;
+      });
+      row.append(label, select);
+      importSystemChoices.appendChild(row);
+    });
+  }
+
+  async function importSelectedBoats() {
+    if (!activeRaceId || !importEventId) return;
+    const classIds = Array.from(importClassesList.querySelectorAll('input[type=checkbox]:checked')).map((cb) => cb.value);
+    if (!classIds.length) {
+      setImportStatus('Select at least one class to import.', true);
+      return;
+    }
+    setImportStatus('Importing…');
+    try {
+      const data = await fetchJSON(`${API}/races/${encodeURIComponent(activeRaceId)}/import/manage2sail`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ eventId: importEventId, classIds, systemOverrides: importSystemOverrides })
+      });
+      raceState = data.race;
+      render();
+      const needsChoice = data.needsSystemChoice || [];
+      if (needsChoice.length) {
+        await renderSystemChoices(needsChoice);
+        const names = needsChoice.map((c) => importClassName(c.classId)).join(', ');
+        setImportStatus(
+          `Added ${data.added}, updated ${data.updated}. Pick a handicap system below for ${names}, then click Import again.`,
+          true
+        );
+        return;
+      }
+      importSystemChoices.innerHTML = '';
+      importSystemOverrides = {};
+      const skippedNote = data.skipped ? `, skipped ${data.skipped}` : '';
+      await loadImportHandicapSystems();
+      const conversionNote = (data.conversions || [])
+        .map((c) => `${importClassName(c.classId)}: ${importSystemLabel(c.system)}`)
+        .join('; ');
+      setImportStatus(`Added ${data.added}, updated ${data.updated}${skippedNote}.${conversionNote ? ' ' + conversionNote : ''}`);
+    } catch (e) {
+      setImportStatus(e.message, true);
+    }
+  }
+
   // ---- Course / track chart -------------------------------------------
 
   const CHART_PALETTE = ['#38bdf8', '#fbbf24', '#f472b6', '#a78bfa', '#34d399', '#fb923c', '#60a5fa', '#facc15'];
@@ -1092,6 +1271,7 @@
         return {
           boatId: b.id,
           name: b.name,
+          sailNumber: b.sailNumber || '',
           mmsi: b.mmsi || '',
           tcf,
           startTime: b.startTime,
@@ -1185,6 +1365,14 @@
     const tdName = document.createElement('td');
     tdName.append(selfBtn, nameSpan);
 
+    const sailNumberInput = document.createElement('input');
+    sailNumberInput.type = 'text';
+    sailNumberInput.className = 'sail-number-input';
+    sailNumberInput.placeholder = 'Sail #';
+    sailNumberInput.addEventListener('change', () => setSailNumber(boatId, sailNumberInput.value.trim()));
+    const tdSailNumber = document.createElement('td');
+    tdSailNumber.appendChild(sailNumberInput);
+
     const mmsiInput = document.createElement('input');
     mmsiInput.type = 'text';
     mmsiInput.className = 'mmsi-input';
@@ -1351,7 +1539,7 @@
     const tdRemove = document.createElement('td');
     tdRemove.appendChild(removeBtn);
 
-    tr.append(tdName, tdMmsi, tdTcf, tdVet, tdStart, tdElapsed, tdCorrected, tdEstFinish, tdVsSelf, tdFinish, tdRemove);
+    tr.append(tdName, tdSailNumber, tdMmsi, tdTcf, tdVet, tdStart, tdElapsed, tdCorrected, tdEstFinish, tdVsSelf, tdFinish, tdRemove);
 
     return {
       tr,
@@ -1359,6 +1547,7 @@
       nameSpan,
       tdEstFinish,
       tdVsSelf,
+      sailNumberInput,
       mmsiInput,
       tcfInput,
       vetSelect,
@@ -1448,6 +1637,7 @@
     exportBtn.hidden = !raceState;
     exportOfflineBtn.hidden = !raceState;
     courseSection.hidden = !raceState;
+    raceImportSection.hidden = !raceState || !raceImportEnabled;
 
     if (!raceState) {
       emptyMsg.hidden = true;
@@ -1530,6 +1720,9 @@
       const isSelf = b.boatId === raceState.selfBoatId;
       row.selfBtn.textContent = isSelf ? '★' : '☆';
       row.selfBtn.classList.toggle('active', isSelf);
+      if (document.activeElement !== row.sailNumberInput) {
+        row.sailNumberInput.value = b.sailNumber || '';
+      }
       if (document.activeElement !== row.mmsiInput) {
         row.mmsiInput.value = b.mmsi;
       }
@@ -1687,6 +1880,12 @@
     courseToggleBtn.textContent = (courseBody.hidden ? '▸' : '▾') + ' Course & chart';
     if (!courseBody.hidden) renderChart();
   });
+  raceImportToggleBtn.addEventListener('click', () => {
+    raceImportBody.hidden = !raceImportBody.hidden;
+    raceImportToggleBtn.textContent = (raceImportBody.hidden ? '▸' : '▾') + ' Import boats from Manage2Sail';
+  });
+  importFindClassesBtn.addEventListener('click', findImportClasses);
+  importBoatsBtn.addEventListener('click', importSelectedBoats);
   addMarkBtn.addEventListener('click', () => {
     markRefs.push(buildMarkRow(null));
     renderMarkRows();
@@ -1705,6 +1904,7 @@
 
   async function init() {
     await loadVetEnabled();
+    await loadRaceImportEnabled();
     await Promise.all([loadVessels(), loadBoatRegistry(), loadHandicapRegister(false), loadRacesList()]);
     await loadRaceState();
     render();

package/public/index.html

@@ -92,6 +92,22 @@
       </div>
     </div>
 
+    <div id="raceImportSection" class="course-section" hidden>
+      <button id="raceImportToggleBtn" type="button" class="link-btn">▸ Import boats from Manage2Sail</button>
+      <div id="raceImportBody" hidden>
+        <div class="import-row">
+          <input type="text" id="importEventUrl" placeholder="Manage2Sail event URL, e.g. https://www.manage2sail.com/en-US/event/SCER23" autocomplete="off" />
+          <button id="importFindClassesBtn" type="button" class="secondary">Find Classes</button>
+        </div>
+        <div id="importClassesList" class="import-classes-list"></div>
+        <div id="importSystemChoices" class="import-system-choices"></div>
+        <div class="import-row">
+          <button id="importBoatsBtn" type="button" hidden>Import Selected Boats</button>
+          <span id="importStatusText" class="status"></span>
+        </div>
+      </div>
+    </div>
+
     <div id="addBoatRow" class="add-boat-row" hidden>
       <div class="autocomplete">
         <input type="text" id="addBoatName" placeholder="Add boat by name…" autocomplete="off" />
@@ -104,6 +120,7 @@
         <thead>
           <tr>
             <th>Boat</th>
+            <th>Sail #</th>
             <th>MMSI</th>
             <th>TCF</th>
             <th id="vetAlternativesTh">VET alternatives</th>

package/public/style.css

@@ -289,6 +289,65 @@ main {
   gap: 0.75rem;
 }
 
+.import-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+  margin-top: 0.75rem;
+}
+
+.import-row input[type='text'] {
+  flex: 1;
+  min-width: 18rem;
+  padding: 0.4rem 0.5rem;
+  background: var(--panel);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  font-size: 0.85rem;
+}
+
+.import-classes-list {
+  margin-top: 0.6rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+}
+
+.import-classes-list label {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.85rem;
+  cursor: pointer;
+}
+
+.import-system-choices {
+  margin-top: 0.6rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+
+.import-system-choice-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+  font-size: 0.85rem;
+  color: var(--muted);
+}
+
+.import-system-choice-row select {
+  padding: 0.3rem 0.4rem;
+  background: var(--panel);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-size: 0.85rem;
+}
+
 .chart-wrap {
   margin-top: 1rem;
 }
@@ -467,7 +526,8 @@ tbody tr.dnf td {
   color: var(--muted);
 }
 
-.mmsi-input {
+.mmsi-input,
+.sail-number-input {
   width: 7rem;
   padding: 0.3rem 0.4rem;
   background: var(--panel);