signalk-race-control 0.12.8 → 0.12.10

package/CHANGELOG.md

@@ -0,0 +1,123 @@
+# Changelog
+
+All notable changes to `signalk-race-control`, newest first.
+
+## 0.12.10 (2026-10-14)
+- Drop the `exceljs` dependency: the Excel export now uses a small built-in `.xlsx` writer, so the plugin has no runtime dependencies (and no `npm audit` findings for installers). `overrides` only apply to the project that declares them, so the earlier `uuid` override never protected installed copies
+
+## 0.12.9 (2026-10-13)
+- Patch `brace-expansion` (via `exceljs`) to fix the npm audit finding
+- Fix the MFD tile showing "No active race" over a live race (its stylesheet ignored the `hidden` attribute)
+- Add this changelog and App Store screenshots
+
+## 0.12.8 (2026-10-12)
+- Split the Excel export by class
+
+## 0.12.7 (2026-10-11)
+- Allow editing class start times before the race starts
+
+## 0.12.6 (2026-09-20)
+- Add read-only MFD tile webapp for signalk-mfd-plugin
+
+## 0.12.5 (2026-09-20)
+- Add optional buddy-list registration when adding a boat
+
+## 0.12.4 (2026-09-20)
+- Fix webapp icon resolution via signalk.appIcon
+
+## 0.12.3 (2026-09-20)
+- Add a favicon: a racing mark with a clock hand
+
+## 0.12.2 (2026-09-19)
+- Repopulate the schedule input/button from the actual saved schedule
+
+## 0.12.1 (2026-09-18)
+- Fix App Store audit warnings: repository field, uuid override
+- Add a plugin-level test suite
+
+## 0.12.0 (2026-09-16)
+- Auto-activate the course as a SignalK route on start-line crossing
+- Add 10-minute laylines for self on the course chart
+- Add a lift/header wind-shift instrument for self
+
+## 0.11.1 (2026-09-16)
+- Fix OpenSeaMap autosuggest/snap never finding real data
+
+## 0.11.0 (2026-09-16)
+- Let the chart fill the page width, without trapping page scroll
+- Add a recenter button to the chart
+- Reuse a chosen OpenSeaMap mark instantly in other course-point rows
+- Scope the recenter button to just the race's own course
+- Fall back to self position when recentering with no course set
+- Schedule Start/Call-off only need a date on multi-day races
+- Revert Schedule Start to always need a date
+- Add classes for staggered/pursuit starts
+- Fix buoy name suggestion losing to a generic reverse-geocode guess
+- Fix map-pick feedback stalling on a slow Overpass lookup
+- Cache OpenSeaMap nav marks per chart area
+- Reorder course sections and turn course points into tables
+- Collapse course positions once a course is saved
+
+## 0.10.1 (2026-09-15)
+- Fix scheduled start/call-off firing immediately when set far enough ahead
+
+## 0.10.0 (2026-09-15)
+- Fix multiple registered charts stacking instead of switching
+- Show a boat's inherited start time instead of blank
+- Autosuggest course point names from the chart area, not just waypoints
+- Source the course-point name autosuggest from OpenSeaMap, not general OSM
+- Try multiple Overpass mirrors, and ask to snap a map click to a nearby mark
+- Default the chart to Eniro's plain map, not whichever loaded first
+
+## 0.9.0 (2026-09-13)
+- Add click-to-place course points on the map, fix unreadable mark dropdown
+- Merge course-point buttons into one, suggest names from OpenStreetMap
+
+## 0.8.0 (2026-09-13)
+- Fix Add Boat not responding to Enter in the offline export
+- Mark speed pickups on the course chart
+- Draw speed-pickup rings in each boat's own trace color
+- Add a real background chart to the course/replay map
+
+## 0.7.0 (2026-09-08)
+- Auto-stop a complete race, and add a DNS status
+- Make Excel export use live formulas, reorder time columns
+- Sort DNS boats to the end and allow marking DNS before race start
+- Sort DNS boats last in the offline export template too
+
+## 0.6.0 (2026-09-07)
+- Add KTK's KLR handicap register alongside VET-tall
+
+## 0.5.1 (2026-09-04)
+- Stop the boats table from resizing/reshuffling confusingly
+
+## 0.5.0 (2026-09-03)
+- Add a start timer view with distance/ETA/burn time to the line
+
+## 0.4.3 (2026-09-03)
+- Let course points autocomplete against existing SignalK waypoints
+- Make mark-rounding radius configurable and add manual mark rounding
+- Record positions for manual mark roundings and improve chart replay
+- Add author to package.json
+
+## 0.4.2 (2026-09-02)
+- Remember sail number across races, like MMSI
+
+## 0.4.1 (2026-08-30)
+- Make the offline export installable as a standalone iOS app
+
+## 0.4.0 (2026-08-30)
+- Fetch VET-tall handicaps live in the offline export
+
+## 0.3.0 (2026-08-20)
+- Add Manage2Sail fleet import with handicap-system conversion
+
+## 0.2.0 (2026-08-20)
+- Add signalk-race-control plugin: race timing, handicaps, course/chart, VET import
+- Add MIT LICENSE file and drop empty repository field
+- Add offline export: standalone backup race timer
+- Add multi-day races and individual per-boat start times
+- Fix ghost row left in the boat table after removing a boat
+- Fall back to the leader when no boat is marked self
+- Clarify the multi-day toggle isn't needed for ordinary overnight races
+- Fix scheduled call-off loss, stale offline exports, and add race-start correction

package/README.md

@@ -265,11 +265,11 @@ and a live projected finishing order — during and after the race.
 
 ## Install
 
-Install this directory's dependencies once (needed for the Excel export), then copy
-(or symlink) it into your SignalK server's `node_modules`, e.g.:
+The easiest way is the SignalK **App Store** (or `npm install signalk-race-control`).
+The plugin has no runtime dependencies, so a checkout also works as-is — copy (or
+symlink) it into your SignalK server's `node_modules`, e.g.:
 
 ```bash
-cd /path/to/race-control && npm install
 cd ~/.signalk/node_modules
 ln -s /path/to/race-control signalk-race-control
 ```

package/index.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const ExcelJS = require('exceljs');
+const xlsx = require('./xlsx');
 
 const DEFAULT_HANDICAP_SOURCE_PAGE = 'https://ssca.no/aktiviteter/vet-tall';
 const HANDICAP_CACHE_TTL_MS = 60 * 60 * 1000;
@@ -2397,9 +2397,7 @@ module.exports = function (app) {
       const ranked = rankedBoatList(race);
       const headers = ['Rank', 'Boat', 'Sail Number', 'MMSI', 'TCF', 'Start Time', 'Finish Time', 'Elapsed', 'Corrected', 'Status'];
 
-      const workbook = new ExcelJS.Workbook();
-      workbook.creator = 'Race Control';
-      workbook.created = new Date();
+      const workbook = xlsx.createWorkbook();
 
       const statusLine = race.stopTime
         ? `Called off ${formatLocalDateTime(race.stopTime, tz)}`
@@ -2437,24 +2435,19 @@ module.exports = function (app) {
         return name;
       };
 
+      const DAY_MS = 86400000;
       const addResultsSheet = (sheetName, title, entries) => {
         const sheet = workbook.addWorksheet(uniqueSheetName(sheetName));
 
-        const titleRow = sheet.addRow([title]);
-        sheet.mergeCells(titleRow.number, 1, titleRow.number, headers.length);
-        titleRow.getCell(1).font = { bold: true, size: 14 };
+        const titleRow = sheet.addRow([{ value: title, font: { bold: true, size: 14 } }]);
+        sheet.mergeCells(titleRow, 1, titleRow, headers.length);
 
-        const infoRow = sheet.addRow([statusLine]);
-        sheet.mergeCells(infoRow.number, 1, infoRow.number, headers.length);
-        infoRow.getCell(1).font = { italic: true, color: { argb: 'FF64748B' } };
+        const infoRow = sheet.addRow([{ value: statusLine, font: { italic: true, color: 'FF64748B' } }]);
+        sheet.mergeCells(infoRow, 1, infoRow, headers.length);
 
         sheet.addRow([]);
 
-        const headerRow = sheet.addRow(headers);
-        headerRow.font = { bold: true };
-        headerRow.eachCell((cell) => {
-          cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFE2E8F0' } };
-        });
+        const headerRow = sheet.addRow(headers, { font: { bold: true }, fill: 'FFE2E8F0' });
 
         entries.forEach((r, i) => {
           const status = r.boat.dns
@@ -2470,29 +2463,26 @@ module.exports = function (app) {
           const start = effectiveStartTime(race, r.boat);
           const startDate = start != null ? new Date(start - tz * 60000) : null;
           const finishDate = r.boat.finishTime != null ? new Date(r.boat.finishTime - tz * 60000) : null;
-          const rowNum = headerRow.number + 1 + i;
-          const row = sheet.addRow([
+          const rowNum = headerRow + 1 + i;
+          // Cached results alongside the formulas, for viewers that don't
+          // recalculate on open.
+          const elapsedDays = start != null && r.boat.finishTime != null ? (r.boat.finishTime - start) / DAY_MS : null;
+          sheet.addRow([
             rankLabel,
             r.boat.name,
             r.boat.sailNumber || '',
             r.boat.mmsi || '',
             r.boat.tcf,
-            startDate,
-            finishDate,
-            { formula: `IF(OR(F${rowNum}="",G${rowNum}=""),"",G${rowNum}-F${rowNum})` },
-            { formula: `IF(H${rowNum}="","",H${rowNum}*E${rowNum})` },
+            { value: startDate, numFmt: dateNumFmt },
+            { value: finishDate, numFmt: dateNumFmt },
+            { formula: `IF(OR(F${rowNum}="",G${rowNum}=""),"",G${rowNum}-F${rowNum})`, value: elapsedDays == null ? '' : elapsedDays, numFmt: durationNumFmt },
+            { formula: `IF(H${rowNum}="","",H${rowNum}*E${rowNum})`, value: elapsedDays == null ? "" : elapsedDays * (r.boat.tcf != null ? r.boat.tcf : 1), numFmt: durationNumFmt },
             status
           ]);
-          row.getCell(6).numFmt = dateNumFmt;
-          row.getCell(7).numFmt = dateNumFmt;
-          row.getCell(8).numFmt = durationNumFmt;
-          row.getCell(9).numFmt = durationNumFmt;
         });
 
         const widths = [7, 24, 12, 12, 8, race.multiDay ? 17 : 12, race.multiDay ? 17 : 12, 12, 12, 12];
-        widths.forEach((w, i) => {
-          sheet.getColumn(i + 1).width = w;
-        });
+        widths.forEach((w, i) => sheet.setColumnWidth(i + 1, w));
       };
 
       const classes = race.classes || [];
@@ -2510,8 +2500,7 @@ module.exports = function (app) {
       res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
       res.setHeader('Content-Disposition', `attachment; filename="${safeName}-results.xlsx"`);
       try {
-        await workbook.xlsx.write(res);
-        res.end();
+        res.end(workbook.toBuffer());
       } catch (e) {
         app.error('race-control: failed to generate xlsx export: ' + e.message);
         if (!res.headersSent) res.status(500).json({ error: 'Could not generate export' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-race-control",
-  "version": "0.12.8",
+  "version": "0.12.10",
   "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",
   "author": "Joachim Bakke <github@heiamoss.com>",
@@ -9,7 +9,15 @@
     "url": "https://github.com/joabakk/signalk-race-control.git"
   },
   "signalk": {
-    "appIcon": "favicon.svg"
+    "appIcon": "favicon.svg",
+    "displayName": "Race Control",
+    "screenshots": [
+      "screenshots/results.png",
+      "screenshots/course-chart.png",
+      "screenshots/start-timer.png",
+      "screenshots/mfd-leaderboard.png",
+      "screenshots/mfd-countdown.png"
+    ]
   },
   "keywords": [
     "signalk-node-server-plugin",
@@ -23,10 +31,16 @@
   "scripts": {
     "test": "node --test"
   },
-  "dependencies": {
-    "exceljs": "^4.4.0"
-  },
   "overrides": {
-    "uuid": "^11.1.1"
+    "uuid": "^11.1.1",
+    "glob": {
+      "brace-expansion": "^1.1.21"
+    },
+    "readdir-glob": {
+      "brace-expansion": "^2.1.7"
+    }
+  },
+  "devDependencies": {
+    "exceljs": "^4.4.0"
   }
 }

package/public/mfd-tile.html

@@ -17,6 +17,9 @@
     --bad: #f87171;
   }
   * { box-sizing: border-box; }
+  /* Elements that set their own `display` would otherwise override the
+     `hidden` attribute's UA-stylesheet `display: none`. */
+  [hidden] { display: none !important; }
   html, body {
     margin: 0;
     height: 100%;

package/test/xlsx.test.js

@@ -0,0 +1,109 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const zlib = require('node:zlib');
+
+const { createWorkbook, crc32, zip, columnLetters, excelSerial } = require('../xlsx.js');
+
+// Reads the entries back out of a ZIP via its central directory.
+function unzip(buf) {
+  const eocd = buf.lastIndexOf(Buffer.from([0x50, 0x4b, 0x05, 0x06]));
+  const count = buf.readUInt16LE(eocd + 10);
+  let p = buf.readUInt32LE(eocd + 16);
+  const files = {};
+  for (let i = 0; i < count; i++) {
+    const method = buf.readUInt16LE(p + 10);
+    const crc = buf.readUInt32LE(p + 16);
+    const csize = buf.readUInt32LE(p + 20);
+    const nameLen = buf.readUInt16LE(p + 28);
+    const extraLen = buf.readUInt16LE(p + 30);
+    const commentLen = buf.readUInt16LE(p + 32);
+    const localOffset = buf.readUInt32LE(p + 42);
+    const name = buf.toString('utf8', p + 46, p + 46 + nameLen);
+    const lNameLen = buf.readUInt16LE(localOffset + 26);
+    const lExtraLen = buf.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + lNameLen + lExtraLen;
+    const raw = method === 8 ? zlib.inflateRawSync(buf.subarray(dataStart, dataStart + csize)) : buf.subarray(dataStart, dataStart + csize);
+    assert.equal(crc32(raw), crc, `crc of ${name}`);
+    files[name] = raw.toString('utf8');
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  return files;
+}
+
+describe('xlsx helpers', () => {
+  test('crc32 matches the standard check value', () => {
+    assert.equal(crc32(Buffer.from('123456789')), 0xcbf43926);
+  });
+
+  test('columnLetters', () => {
+    assert.equal(columnLetters(1), 'A');
+    assert.equal(columnLetters(10), 'J');
+    assert.equal(columnLetters(26), 'Z');
+    assert.equal(columnLetters(27), 'AA');
+    assert.equal(columnLetters(52), 'AZ');
+    assert.equal(columnLetters(703), 'AAA');
+  });
+
+  test('excelSerial: 1900-01-01 is 2 and the Unix epoch is 25569', () => {
+    assert.equal(excelSerial(new Date(Date.UTC(1970, 0, 1))), 25569);
+    assert.equal(excelSerial(new Date(Date.UTC(1900, 0, 1))), 2);
+    assert.equal(excelSerial(new Date(Date.UTC(1970, 0, 1, 12))), 25569.5);
+  });
+
+  test('zip round-trips entries with valid CRCs', () => {
+    const files = unzip(zip([{ name: 'a.txt', data: 'hello' }, { name: 'dir/b.txt', data: 'x'.repeat(5000) }]));
+    assert.equal(files['a.txt'], 'hello');
+    assert.equal(files['dir/b.txt'], 'x'.repeat(5000));
+  });
+});
+
+describe('createWorkbook', () => {
+  const build = () => {
+    const wb = createWorkbook();
+    const sh = wb.addWorksheet('Results & <more>');
+    const title = sh.addRow([{ value: 'Title "q" & <b>', font: { bold: true, size: 14 } }]);
+    sh.mergeCells(title, 1, title, 3);
+    sh.addRow([]);
+    sh.addRow(['Boat', 'TCF', 'Start', 'Elapsed'], { font: { bold: true }, fill: 'FFE2E8F0' });
+    sh.addRow(['Alpha', 0.97, { value: new Date(Date.UTC(2026, 9, 13, 18, 5, 0)), numFmt: 'hh:mm:ss' }, { formula: 'B4*2', value: 1.94, numFmt: '[h]:mm:ss' }]);
+    sh.addRow(['Beta', null, null, { formula: 'IF(1=1,"","x")', value: '', numFmt: '[h]:mm:ss' }]);
+    sh.setColumnWidth(1, 24);
+    return unzip(wb.toBuffer());
+  };
+
+  test('emits the expected package parts', () => {
+    const files = build();
+    assert.deepEqual(Object.keys(files).sort(), [
+      '[Content_Types].xml',
+      '_rels/.rels',
+      'xl/_rels/workbook.xml.rels',
+      'xl/styles.xml',
+      'xl/workbook.xml',
+      'xl/worksheets/sheet1.xml'
+    ]);
+  });
+
+  test('escapes sheet names and strings, and writes merges, widths, values and formulas', () => {
+    const files = build();
+    assert.match(files['xl/workbook.xml'], /name="Results &amp; &lt;more&gt;"/);
+    const sheet = files['xl/worksheets/sheet1.xml'];
+    assert.match(sheet, /Title &quot;q&quot; &amp; &lt;b&gt;/);
+    assert.match(sheet, /<mergeCell ref="A1:C1"\/>/);
+    assert.match(sheet, /<col min="1" max="1" width="24" customWidth="1"\/>/);
+    assert.match(sheet, /<c r="B4"[^>]*><v>0\.97<\/v><\/c>/);
+    assert.match(sheet, /<c r="D4"[^>]*><f>B4\*2<\/f><v>1\.94<\/v><\/c>/);
+    assert.match(sheet, /<c r="D5"[^>]*t="str"><f>IF\(1=1,&quot;&quot;,&quot;x&quot;\)<\/f><v><\/v><\/c>/);
+    assert.match(sheet, new RegExp(`<c r="C4"[^>]*><v>${excelSerial(new Date(Date.UTC(2026, 9, 13, 18, 5, 0)))}</v></c>`));
+    // Null cells are simply absent.
+    assert.doesNotMatch(sheet, /r="B5"/);
+  });
+
+  test('registers fonts, fills and number formats in styles.xml', () => {
+    const styles = build()['xl/styles.xml'];
+    assert.match(styles, /<numFmt numFmtId="164" formatCode="hh:mm:ss"\/>/);
+    assert.match(styles, /<numFmt numFmtId="165" formatCode="\[h\]:mm:ss"\/>/);
+    assert.match(styles, /<b\/>/);
+    assert.match(styles, /<sz val="14"\/>/);
+    assert.match(styles, /<fgColor rgb="FFE2E8F0"\/>/);
+  });
+});

package/xlsx.js

@@ -0,0 +1,308 @@
+'use strict';
+
+// A deliberately small, dependency-free .xlsx (Office Open XML) writer —
+// just what the results export needs: several worksheets, string / number /
+// date / formula cells, bold/italic/size/colour fonts, solid fills, custom
+// number formats, merged cells and column widths. It replaces a general
+// spreadsheet library whose (unmaintained) dependency tree kept tripping
+// npm audit for every installer of this plugin.
+
+const zlib = require('zlib');
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+// Minimal ZIP writer: deflated entries, UTF-8 names, no extras.
+function zip(entries, now = new Date()) {
+  const dosTime = (now.getHours() << 11) | (now.getMinutes() << 5) | (now.getSeconds() >> 1);
+  const dosDate = ((now.getFullYear() - 1980) << 9) | ((now.getMonth() + 1) << 5) | now.getDate();
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  entries.forEach(({ name, data }) => {
+    const nameBuf = Buffer.from(name, 'utf8');
+    const raw = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
+    const packed = zlib.deflateRawSync(raw);
+    const crc = crc32(raw);
+
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0x0800, 6);
+    local.writeUInt16LE(8, 8);
+    local.writeUInt16LE(dosTime, 10);
+    local.writeUInt16LE(dosDate, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(packed.length, 18);
+    local.writeUInt32LE(raw.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    locals.push(local, nameBuf, packed);
+
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(8, 10);
+    central.writeUInt16LE(dosTime, 12);
+    central.writeUInt16LE(dosDate, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(packed.length, 20);
+    central.writeUInt32LE(raw.length, 24);
+    central.writeUInt16LE(nameBuf.length, 28);
+    central.writeUInt32LE(offset, 42);
+    centrals.push(central, nameBuf);
+
+    offset += local.length + nameBuf.length + packed.length;
+  });
+  const centralBuf = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, centralBuf, end]);
+}
+
+// Control characters other than tab/newline/CR are illegal in XML 1.0.
+function xmlEscape(s) {
+  return String(s)
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function columnLetters(col) {
+  let s = '';
+  for (let n = col; n > 0; n = Math.floor((n - 1) / 26)) s = String.fromCharCode(65 + ((n - 1) % 26)) + s;
+  return s;
+}
+
+const cellRef = (row, col) => `${columnLetters(col)}${row}`;
+
+// Excel stores dates as days since 1899-12-30 (the 1900 leap-year bug folded
+// in). The caller passes a Date whose UTC fields hold the wall-clock to show.
+const excelSerial = (date) => date.getTime() / 86400000 + 25569;
+
+// Registers fonts / fills / number formats / cell formats as they're used,
+// and emits xl/styles.xml. Index 0 of each is the default.
+function createStyles() {
+  const fonts = ['<font><sz val="11"/><name val="Calibri"/></font>'];
+  const fills = ['<fill><patternFill patternType="none"/></fill>', '<fill><patternFill patternType="gray125"/></fill>'];
+  const numFmts = [];
+  const xfs = ['<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>'];
+  const cache = new Map();
+
+  const indexOf = (list, xml) => {
+    const i = list.indexOf(xml);
+    if (i >= 0) return i;
+    list.push(xml);
+    return list.length - 1;
+  };
+
+  function xfFor(style) {
+    if (!style) return 0;
+    const key = JSON.stringify(style);
+    if (cache.has(key)) return cache.get(key);
+    const f = style.font;
+    let fontId = 0;
+    if (f) {
+      fontId = indexOf(
+        fonts,
+        '<font>' +
+          (f.bold ? '<b/>' : '') +
+          (f.italic ? '<i/>' : '') +
+          `<sz val="${f.size || 11}"/>` +
+          (f.color ? `<color rgb="${xmlEscape(f.color)}"/>` : '') +
+          '<name val="Calibri"/></font>'
+      );
+    }
+    const fillId = style.fill
+      ? indexOf(fills, `<fill><patternFill patternType="solid"><fgColor rgb="${xmlEscape(style.fill)}"/><bgColor indexed="64"/></patternFill></fill>`)
+      : 0;
+    let numFmtId = 0;
+    if (style.numFmt) {
+      const idx = indexOf(numFmts, style.numFmt);
+      numFmtId = 164 + idx;
+    }
+    const xf = `<xf numFmtId="${numFmtId}" fontId="${fontId}" fillId="${fillId}" borderId="0" xfId="0"` +
+      (numFmtId ? ' applyNumberFormat="1"' : '') +
+      (fontId ? ' applyFont="1"' : '') +
+      (fillId ? ' applyFill="1"' : '') +
+      '/>';
+    const id = indexOf(xfs, xf);
+    cache.set(key, id);
+    return id;
+  }
+
+  function toXml() {
+    return (
+      '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+      '<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+      (numFmts.length
+        ? `<numFmts count="${numFmts.length}">` +
+          numFmts.map((code, i) => `<numFmt numFmtId="${164 + i}" formatCode="${xmlEscape(code)}"/>`).join('') +
+          '</numFmts>'
+        : '') +
+      `<fonts count="${fonts.length}">${fonts.join('')}</fonts>` +
+      `<fills count="${fills.length}">${fills.join('')}</fills>` +
+      '<borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>' +
+      '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>' +
+      `<cellXfs count="${xfs.length}">${xfs.join('')}</cellXfs>` +
+      '<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>' +
+      '</styleSheet>'
+    );
+  }
+
+  return { xfFor, toXml };
+}
+
+// A cell is a plain value (string, number, Date, null) or an object:
+//   { value, formula, numFmt, font: {bold, italic, size, color}, fill }
+// `formula` (without the leading "=") may come with a cached `value` so
+// viewers that don't recalculate still show a result.
+function createWorkbook() {
+  const styles = createStyles();
+  const sheets = [];
+
+  function addWorksheet(name) {
+    const rows = []; // rows[r-1] = [cell specs by column]
+    const merges = [];
+    const widths = [];
+    const sheet = {
+      name,
+      // Appends a row and returns its 1-based number. `rowStyle` is merged
+      // under each cell's own style (e.g. a bold, filled header row).
+      addRow(cells, rowStyle) {
+        rows.push(cells.map((c) => normalise(c, rowStyle)));
+        return rows.length;
+      },
+      mergeCells(row1, col1, row2, col2) {
+        merges.push(`${cellRef(row1, col1)}:${cellRef(row2, col2)}`);
+      },
+      setColumnWidth(col, width) {
+        widths[col - 1] = width;
+      },
+      toXml() {
+        const sheetData = rows
+          .map((cells, ri) => {
+            const r = ri + 1;
+            const cs = cells.map((spec, ci) => cellXml(spec, r, ci + 1)).join('');
+            return cs ? `<row r="${r}">${cs}</row>` : '';
+          })
+          .join('');
+        const cols = widths
+          .map((w, i) => (w ? `<col min="${i + 1}" max="${i + 1}" width="${w}" customWidth="1"/>` : ''))
+          .join('');
+        return (
+          '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+          '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+          (cols ? `<cols>${cols}</cols>` : '') +
+          `<sheetData>${sheetData}</sheetData>` +
+          (merges.length ? `<mergeCells count="${merges.length}">${merges.map((m) => `<mergeCell ref="${m}"/>`).join('')}</mergeCells>` : '') +
+          '</worksheet>'
+        );
+      }
+    };
+    sheets.push(sheet);
+    return sheet;
+  }
+
+  function normalise(c, rowStyle) {
+    const spec = c !== null && typeof c === 'object' && !(c instanceof Date) ? c : { value: c };
+    const style = {
+      font: spec.font || (rowStyle && rowStyle.font),
+      fill: spec.fill || (rowStyle && rowStyle.fill),
+      numFmt: spec.numFmt || (rowStyle && rowStyle.numFmt)
+    };
+    return { value: spec.value, formula: spec.formula, style: style.font || style.fill || style.numFmt ? style : null };
+  }
+
+  function cellXml(spec, row, col) {
+    const s = styles.xfFor(spec.style);
+    const attrs = `r="${cellRef(row, col)}"${s ? ` s="${s}"` : ''}`;
+    const v = spec.value;
+    if (spec.formula) {
+      const f = `<f>${xmlEscape(spec.formula)}</f>`;
+      if (typeof v === 'number') return `<c ${attrs}>${f}<v>${v}</v></c>`;
+      return `<c ${attrs} t="str">${f}<v>${v == null ? '' : xmlEscape(v)}</v></c>`;
+    }
+    if (v === null || v === undefined || v === '') return s ? `<c ${attrs}/>` : '';
+    if (v instanceof Date) return `<c ${attrs}><v>${excelSerial(v)}</v></c>`;
+    if (typeof v === 'number') return isFinite(v) ? `<c ${attrs}><v>${v}</v></c>` : '';
+    return `<c ${attrs} t="inlineStr"><is><t xml:space="preserve">${xmlEscape(v)}</t></is></c>`;
+  }
+
+  function toBuffer() {
+    const NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+    const sheetFiles = sheets.map((sh, i) => ({ name: `xl/worksheets/sheet${i + 1}.xml`, data: sh.toXml() }));
+    const entries = [
+      {
+        name: '[Content_Types].xml',
+        data:
+          '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+          '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">' +
+          '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>' +
+          '<Default Extension="xml" ContentType="application/xml"/>' +
+          '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>' +
+          sheets
+            .map((_, i) => `<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`)
+            .join('') +
+          '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>' +
+          '</Types>'
+      },
+      {
+        name: '_rels/.rels',
+        data:
+          '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+          '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+          `<Relationship Id="rId1" Type="${NS}/officeDocument" Target="xl/workbook.xml"/>` +
+          '</Relationships>'
+      },
+      {
+        name: 'xl/workbook.xml',
+        data:
+          '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+          `<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="${NS}">` +
+          '<sheets>' +
+          sheets.map((sh, i) => `<sheet name="${xmlEscape(sh.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`).join('') +
+          '</sheets><calcPr fullCalcOnLoad="1"/></workbook>'
+      },
+      {
+        name: 'xl/_rels/workbook.xml.rels',
+        data:
+          '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+          '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+          sheets.map((_, i) => `<Relationship Id="rId${i + 1}" Type="${NS}/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`).join('') +
+          `<Relationship Id="rId${sheets.length + 1}" Type="${NS}/styles" Target="styles.xml"/>` +
+          '</Relationships>'
+      },
+      ...sheetFiles,
+      // Styles are emitted last: building the sheets above is what
+      // registers the fonts/fills/formats they use.
+      { name: 'xl/styles.xml', data: styles.toXml() }
+    ];
+    return zip(entries);
+  }
+
+  return { addWorksheet, toBuffer };
+}
+
+module.exports = { createWorkbook, crc32, zip, columnLetters, excelSerial };