signalk-race-control 0.2.0 → 0.3.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,10 +105,10 @@ 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,

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;
   });
 }
 
@@ -269,6 +356,7 @@ function buildOfflineTimerHtml(race, defaultTcf) {
     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,
@@ -329,6 +417,7 @@ 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; }
 .self-btn { background: none; border: none; padding: 0 0.3rem 0 0; font-size: 1rem; color: var(--muted); cursor: pointer; vertical-align: middle; }
@@ -380,6 +469,7 @@ tbody tr.dnf td { color: var(--muted); }
       <thead>
         <tr>
           <th>Boat</th>
+          <th>Sail #</th>
           <th>TCF</th>
           <th>Start time</th>
           <th>Elapsed</th>
@@ -653,6 +743,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';
@@ -813,9 +917,9 @@ 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, 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,
       startTimeInput: startTimeInput, startNowBtn: startNowBtn, startClearBtn: startClearBtn,
       tdElapsed: tdElapsed, tdCorrected: tdCorrected, tdVsSelf: tdVsSelf,
       finishNormalWrap: finishNormalWrap, finishTimeInput: finishTimeInput, dnfWrap: dnfWrap
@@ -853,6 +957,7 @@ 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 (document.activeElement !== row.startTimeInput) {
         row.startTimeInput.value = race.multiDay ? tsToDateTimeInputValue(b.startTime) : tsToTimeInputValue(b.startTime);
@@ -905,7 +1010,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 +1024,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
       ]);
     });
@@ -982,6 +1087,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 +1153,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 +1503,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 +1607,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 +1642,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 +1653,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;
       });
@@ -1782,6 +1919,7 @@ module.exports = function (app) {
         id: makeBoatId(),
         name,
         mmsi: mmsi || null,
+        sailNumber: null,
         tcf,
         finishTime: null,
         startTime: null,
@@ -1885,6 +2023,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 +2071,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.3.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);