signalk-chiplog 2.15.0 → 2.16.0

package/CHANGELOG.md

@@ -6,6 +6,30 @@ All notable changes to Chiplog are documented here. The format follows
 
 ## [Unreleased]
 
+## [2.16.0] - 2026-11-02
+
+### Added
+
+- **An API for companion apps**, such as Chiplog Skipper, described in [docs/API.md](docs/API.md):
+  - **Versioned**: the public routes are also served under `/plugins/signalk-chiplog/api/v1`, described by an OpenAPI
+    document (`GET /api/v1/openapi.json`, also listed by the Signal K server). `GET /state` now says `apiVersions`,
+    `pluginVersion`, `features` and the `logbookId`.
+  - **Planned passages** (`/plans`): departure, arrival, Signal K route and fallback points, criteria, crew and watches;
+    linking a plan to the passage that opens puts the planned crew aboard.
+  - **Defects** (`/defects`), with severity, status and links to the passage, plan or journal line they came from.
+  - **Tanks at arrival** (`endTanks`): noted as a passage closes, by detection or by the crew, beside those noted at
+    departure; both can be set by hand with `PATCH /entries/:id`, and imported with `POST /entries`.
+  - **A changes feed** (`GET /changes?since=`), listing the passages, events, crew, plans and defects changed since a
+    cursor, deletions included.
+  - Every new route is open to read/write users; none needs admin.
+- **Plans and defects in the online backup**, sent whole like the places to a service that keeps them, and brought back
+  by a restore.
+
+### Changed
+
+- The first backup run after the update sends every passage's content again, without its track: a passage now carries
+  its tanks at arrival.
+
 ## [2.15.0] - 2026-10-30
 
 ### Added
@@ -535,7 +559,8 @@ First release.
 - REST API under `/plugins/signalk-chiplog/api`, documented in [docs/API.md](docs/API.md).
 - Single SQLite database through Node's built-in `node:sqlite`: no native module to build.
 
-[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.15.0...HEAD
+[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.16.0...HEAD
+[2.16.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.15.0...v2.16.0
 [2.15.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.14.0...v2.15.0
 [2.14.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.13.0...v2.14.0
 [2.13.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.12.0...v2.13.0

package/README.md

@@ -33,6 +33,7 @@ English and French, chosen from the browser's language.
 - [Passage summary emails](#passage-summary-emails-)
 - [Retrospective analysis](#retrospective-analysis-)
 - [Importing from PostgSail](#importing-from-postgsail-)
+- [Companion apps](#companion-apps-)
 - [Privacy and online services](#privacy-and-online-services-)
 - [Troubleshooting](#troubleshooting-)
 - [Limitations](#limitations-)
@@ -682,6 +683,23 @@ node scripts/import-postgsail.js PostgSail_Trip.geojson --url http://boat.local:
   and landmarks are then looked up in the background, like for any passage. Tide and weather forecasts are not fetched
   for passages this old.
 
+## Companion apps 🧭
+
+Chiplog keeps what happened. A companion app, such as Chiplog Skipper on a tablet, can add what was planned and decided
+around it, through the plugin's REST API — nothing to set up in the plugin:
+
+- **Planned passages**: departure, arrival, the Signal K route and fallback points, the crew and the watches. Once the
+  passage opens, the planned crew is the one recorded aboard.
+- **Defects** noticed under way or after, with their severity and whether they are fixed.
+- **Tanks at arrival**, noted as a passage ends next to those noted at departure, so that what a passage used can be
+  worked out. A boat without tank sensors can have them typed in.
+- **Decisions, check-lists, briefings and signatures** appear in the passage's journal as notes.
+
+The app connects with a Signal K device access request, like the tablet entry app, and needs read/write access, never
+admin. Plans and defects go to the [online backup](#online-backup-) with the rest of the logbook, when the service keeps
+them. For developers: the API is versioned (`/plugins/signalk-chiplog/api/v1`) and described by an OpenAPI document,
+listed in the Signal K admin under **Documentation**, and in [docs/API.md](docs/API.md).
+
 ## Privacy and online services 🔒
 
 - **Place names.** With geocoding on, the position of each departure and arrival that matches no known place is sent to

package/index.js

@@ -1,4 +1,5 @@
 const { registerRoutes } = require('./lib/api');
+const { getOpenApi } = require('./lib/openapi');
 const { openDatabase } = require('./lib/database');
 const { createPassageDetector, DETECTION_DEFAULTS, TICK_INTERVAL_MS } = require('./lib/detection');
 const { ApiError } = require('./lib/errors');
@@ -894,6 +895,10 @@ module.exports = function (app) {
     }
   };
 
+  // The versioned API's description, which the server lists with its own (Signal K admin,
+  // Documentation > OpenAPI).
+  plugin.getOpenApi = () => getOpenApi();
+
   // The server registers routes once, before start() and even while the plugin
   // is disabled, and never removes them: every request must check the database.
   plugin.registerWithRouter = function (router) {
@@ -913,6 +918,7 @@ module.exports = function (app) {
           vesselPosition: () => readVesselPosition(app),
           observeEvent: (entryId, time) => detector.observeEvent(entryId, time),
           noteDeparture: (entryId) => detector.noteDeparture(entryId),
+          noteArrival: (entryId) => detector.noteArrival(entryId),
           usbExport,
           summaryMailer,
           cloudSync,

package/lib/api.js

@@ -1,5 +1,9 @@
+const { version: pluginVersion } = require('../package.json');
+const changes = require('./changes');
+const { getLogbookId } = require('./cloud-sync');
 const { getSchemaVersion } = require('./database');
 const crew = require('./crew');
+const defects = require('./defects');
 const { ApiError, badRequest, conflict, notFound } = require('./errors');
 const entries = require('./entries');
 const events = require('./events');
@@ -9,7 +13,9 @@ const { isTimeZone, PDF_LANGUAGES } = require('./logbook-pdf');
 const { toGeoJson, toGpx } = require('./formats');
 const manoeuvreTypes = require('./manoeuvre-types');
 const { importPassage, TRACK_READINGS, OBSERVATION_READINGS } = require('./passage-import');
+const { getOpenApi } = require('./openapi');
 const places = require('./places');
+const plans = require('./plans');
 const propulsion = require('./propulsion');
 const { getTideForecast } = require('./tide-forecaster');
 const { getWeatherForecast } = require('./weather-forecaster');
@@ -19,6 +25,14 @@ const v = require('./validation');
 
 const SQLITE_CONSTRAINT = 19;
 
+// The versioned contract (docs/API.md, Versioning). A field or route added stays in v1; a
+// breaking change is v2, with v1 kept alongside for a while.
+const V1_PREFIX = '/api/v1';
+const API_VERSIONS = [1];
+// What a client may rely on beyond what v1 first described: it sends a field or calls a route
+// that belongs to a feature only once this list names it, since unknown fields are refused.
+const FEATURES = ['plans', 'defects', 'changes', 'endTanks'];
+
 // Servers predating router.access() only support admin-only plugin routes.
 // Falling back keeps the plugin usable there, at the cost of an admin login.
 function scoped(router, level) {
@@ -151,6 +165,17 @@ function parseTank(item, name) {
   };
 }
 
+// A list of tanks, or null to clear them.
+function parseTanks(value, name) {
+  if (value === null) {
+    return null;
+  }
+  if (!Array.isArray(value)) {
+    throw badRequest(`${name} must be an array or null`);
+  }
+  return value.map((item, index) => parseTank(item, `${name}[${index}]`));
+}
+
 // A battery as noted at departure: volts, amps (negative discharging), state of
 // charge as a ratio, kelvin.
 function parseBattery(item, name) {
@@ -188,10 +213,187 @@ function parsePropulsionPeriod(item, name) {
   };
 }
 
+const nullableTimestamp = (value, name) => (value === null ? null : v.parseTimestamp(value, name));
+const nullableId = (value, name) => (value === null ? null : v.parseId(value, name));
+
+// The changes feed's cursor: the `cursor` of the previous page, 0 for everything.
+function parseCursor(value) {
+  if (value === undefined) {
+    return 0;
+  }
+  if (!/^(0|[1-9]\d*)$/.test(String(value))) {
+    throw badRequest('since must be a non-negative integer');
+  }
+  return Number(value);
+}
+
+function parseChangesLimit(value) {
+  const limit = value === undefined ? changes.DEFAULT_CHANGES_LIMIT : Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > changes.MAX_CHANGES_LIMIT) {
+    throw badRequest(`limit must be an integer between 1 and ${changes.MAX_CHANGES_LIMIT}`);
+  }
+  return limit;
+}
+
+// A Signal K resource, by the href its API gives it: /resources/<type>/<id>.
+const resourceRef = (type) => (value, name) => {
+  const pattern = new RegExp(`^/resources/${type}/[^/\\s]{1,200}$`);
+  if (typeof value !== 'string' || !pattern.test(value)) {
+    throw badRequest(`${name} must be a Signal K resource reference: /resources/${type}/<id>`);
+  }
+  return value;
+};
+
+const MAX_PLAN_LIST = 100;
+
+function parseArray(value, name, parseItem) {
+  if (!Array.isArray(value) || value.length > MAX_PLAN_LIST) {
+    throw badRequest(`${name} must be an array of at most ${MAX_PLAN_LIST} items`);
+  }
+  return value.map((item, index) => parseItem(item, `${name}[${index}]`));
+}
+
+// A crew member a plan names: a roster member by id, or a name for this plan alone.
+function parseMember(item, name, extraFields = []) {
+  if (!v.isPlainObject(item)) {
+    throw badRequest(`${name} must be an object`);
+  }
+  if ('crewMemberId' in item) {
+    const member = v.requireBody(item, ['crewMemberId', 'role', ...extraFields]);
+    return {
+      crewMemberId: v.parseId(member.crewMemberId, `${name}.crewMemberId`),
+      role: optional(member, 'role', nullableString(100))
+    };
+  }
+  const member = v.requireBody(item, ['name', 'role', ...extraFields]);
+  return {
+    name: v.parseString(member.name, `${name}.name`, { maxLength: 100 }),
+    role: optional(member, 'role', nullableString(100))
+  };
+}
+
+function parseWatch(item, name) {
+  const member = parseMember(item, name, ['start', 'end']);
+  const start = v.parseTimestamp(item.start, `${name}.start`);
+  const end = v.parseTimestamp(item.end, `${name}.end`);
+  if (end <= start) {
+    throw badRequest(`${name}.end must be after its start`);
+  }
+  return { start, end, ...member };
+}
+
+const PLAN_FIELDS = [
+  'clientRef',
+  'title',
+  'status',
+  'departureTime',
+  'departurePlaceName',
+  'departurePosition',
+  'arrivalTime',
+  'arrivalPlaceName',
+  'arrivalPosition',
+  'routeRef',
+  'fallbackRefs',
+  'criteria',
+  'crew',
+  'watches',
+  'entryId'
+];
+
+function parsePlanInput(body, { creating }) {
+  return withoutUndefined({
+    clientRef: creating ? optional(body, 'clientRef', requiredString(100)) : undefined,
+    title: creating
+      ? v.parseString(body.title, 'title', { maxLength: 200 })
+      : optional(body, 'title', requiredString(200)),
+    status: optional(body, 'status', (value, name) =>
+      v.parseEnum(value, name, plans.PLAN_STATUSES)
+    ),
+    departureTime: optional(body, 'departureTime', nullableTimestamp),
+    departurePlaceName: optional(body, 'departurePlaceName', nullableString(200)),
+    departurePosition: optional(body, 'departurePosition', v.parsePosition),
+    arrivalTime: optional(body, 'arrivalTime', nullableTimestamp),
+    arrivalPlaceName: optional(body, 'arrivalPlaceName', nullableString(200)),
+    arrivalPosition: optional(body, 'arrivalPosition', v.parsePosition),
+    routeRef: optional(body, 'routeRef', (value, name) =>
+      value === null ? null : resourceRef('routes')(value, name)
+    ),
+    fallbackRefs: optional(body, 'fallbackRefs', (value, name) =>
+      parseArray(value, name, resourceRef('waypoints'))
+    ),
+    criteria: optional(body, 'criteria', parsePayload),
+    crew: optional(body, 'crew', (value, name) => parseArray(value, name, parseMember)),
+    watches: optional(body, 'watches', (value, name) => parseArray(value, name, parseWatch)),
+    entryId: optional(body, 'entryId', nullableId)
+  });
+}
+
+const DEFECT_FIELDS = [
+  'clientRef',
+  'title',
+  'description',
+  'severity',
+  'status',
+  'time',
+  'fixedAt',
+  'entryId',
+  'planId',
+  'eventId'
+];
+
+function parseDefectInput(body, { creating }) {
+  return withoutUndefined({
+    clientRef: creating ? optional(body, 'clientRef', requiredString(100)) : undefined,
+    title: creating
+      ? v.parseString(body.title, 'title', { maxLength: 200 })
+      : optional(body, 'title', requiredString(200)),
+    description: optional(body, 'description', nullableString(10000)),
+    severity: optional(body, 'severity', (value, name) =>
+      v.parseEnum(value, name, defects.DEFECT_SEVERITIES)
+    ),
+    status: optional(body, 'status', (value, name) =>
+      v.parseEnum(value, name, defects.DEFECT_STATUSES)
+    ),
+    time: optional(body, 'time', v.parseTimestamp),
+    fixedAt: optional(body, 'fixedAt', nullableTimestamp),
+    entryId: optional(body, 'entryId', nullableId),
+    planId: optional(body, 'planId', nullableId),
+    eventId: optional(body, 'eventId', nullableId)
+  });
+}
+
+const optionalQuery = (query, field, parse) =>
+  query[field] === undefined ? undefined : parse(query[field], field);
+
+const ROUTE_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+
+// A public route is mounted twice: under /api, which the webapp uses and which may change
+// freely, and under /api/v1, the versioned contract the OpenAPI document describes (see
+// docs/API.md, Versioning). Each one is recorded, for the OpenAPI document to be checked
+// against.
+function versioned(registrar, level, routes) {
+  const twice = {};
+  for (const method of ROUTE_METHODS) {
+    twice[method] = (routePath, ...handlers) => {
+      registrar[method](routePath, ...handlers);
+      const v1Path = routePath.replace(/^\/api\//, `${V1_PREFIX}/`);
+      registrar[method](v1Path, ...handlers);
+      routes.push({ method: method.toUpperCase(), path: v1Path.slice(V1_PREFIX.length), level });
+      return twice;
+    };
+  }
+  return twice;
+}
+
+// Returns the public routes as { method, path, level }, path relative to /api/v1.
 function registerRoutes(router, { getContext, logError }) {
-  const readonly = scoped(router, 'readonly');
-  const readwrite = scoped(router, 'readwrite');
-  const admin = router;
+  const publicRoutes = [];
+  const readonly = versioned(scoped(router, 'readonly'), 'readonly', publicRoutes);
+  const readwrite = versioned(scoped(router, 'readwrite'), 'readwrite', publicRoutes);
+  const admin = versioned(router, 'admin', publicRoutes);
+  // The webapp's own configuration and maintenance screens: never part of the contract.
+  const internalReadonly = scoped(router, 'readonly');
+  const internalAdmin = router;
 
   const handle = (fn) => async (req, res) => {
     try {
@@ -221,11 +423,31 @@ function registerRoutes(router, { getContext, logError }) {
         motion,
         propulsion: under,
         stateIssue,
-        schemaVersion: getSchemaVersion(db)
+        schemaVersion: getSchemaVersion(db),
+        logbookId: getLogbookId(db),
+        apiVersions: API_VERSIONS,
+        pluginVersion,
+        features: FEATURES
       };
     })
   );
 
+  readonly.get(
+    '/api/openapi.json',
+    handle(() => getOpenApi())
+  );
+
+  // Changes feed
+  readonly.get(
+    '/api/changes',
+    handle(({ db }, req) =>
+      changes.listChanges(db, {
+        since: parseCursor(req.query.since),
+        limit: parseChangesLimit(req.query.limit)
+      })
+    )
+  );
+
   // Entries
 
   readonly.get(
@@ -264,6 +486,7 @@ function registerRoutes(router, { getContext, logError }) {
         'distance',
         'startTanks',
         'startBatteries',
+        'endTanks',
         'trackPoints',
         'observations',
         'propulsion'
@@ -280,6 +503,7 @@ function registerRoutes(router, { getContext, logError }) {
           distance: optional(body, 'distance', v.parseNonNegativeNumber),
           startTanks: parseList(body, 'startTanks', parseTank),
           startBatteries: parseList(body, 'startBatteries', parseBattery),
+          endTanks: parseList(body, 'endTanks', parseTank),
           trackPoints: parseList(body, 'trackPoints', parseTrackPoint),
           observations: parseList(body, 'observations', parseObservation),
           propulsion: parseList(body, 'propulsion', parsePropulsionPeriod)
@@ -302,7 +526,9 @@ function registerRoutes(router, { getContext, logError }) {
         'endPosition',
         'startPlaceName',
         'endPlaceName',
-        'distance'
+        'distance',
+        'startTanks',
+        'endTanks'
       ]);
       const patch = {
         startTime: optional(body, 'startTime', v.parseTimestamp),
@@ -311,7 +537,9 @@ function registerRoutes(router, { getContext, logError }) {
         endPosition: optional(body, 'endPosition', v.parsePosition),
         startPlaceName: optional(body, 'startPlaceName', nullableString(200)),
         endPlaceName: optional(body, 'endPlaceName', nullableString(200)),
-        distance: optional(body, 'distance', v.parseNonNegativeNumber)
+        distance: optional(body, 'distance', v.parseNonNegativeNumber),
+        startTanks: optional(body, 'startTanks', parseTanks),
+        endTanks: optional(body, 'endTanks', parseTanks)
       };
       return entries.updateEntry(db, id, patch, {
         placeMatchRadius: config.placeMatchRadius,
@@ -322,13 +550,16 @@ function registerRoutes(router, { getContext, logError }) {
 
   readwrite.post(
     '/api/entries/:id/close',
-    handle(({ db, config, now, vesselPosition }, req) =>
-      entries.closeEntry(db, entryId(req), {
+    handle(({ db, config, now, vesselPosition, noteArrival }, req) => {
+      const id = entryId(req);
+      entries.closeEntry(db, id, {
         now: now(),
         position: vesselPosition(),
         placeMatchRadius: config.placeMatchRadius
-      })
-    )
+      });
+      noteArrival(id);
+      return entries.getEntry(db, id);
+    })
   );
 
   readwrite.post(
@@ -674,6 +905,98 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
+  // Plans
+
+  readonly.get(
+    '/api/plans',
+    handle(({ db }, req) =>
+      plans.listPlans(db, {
+        status: optionalQuery(req.query, 'status', (value, name) =>
+          v.parseEnum(value, name, plans.PLAN_STATUSES)
+        ),
+        entryId: optionalQuery(req.query, 'entryId', v.parseId),
+        ...v.parsePagination(req.query)
+      })
+    )
+  );
+
+  readonly.get(
+    '/api/plans/:id',
+    handle(({ db }, req) => plans.getPlan(db, v.parseId(req.params.id)))
+  );
+
+  readwrite.post(
+    '/api/plans',
+    handle(({ db, now }, req, res) => {
+      const input = parsePlanInput(v.requireBody(req.body, PLAN_FIELDS), { creating: true });
+      const { plan, created } = plans.createPlan(db, input, now());
+      res.status(created ? 201 : 200);
+      return plan;
+    })
+  );
+
+  readwrite.patch(
+    '/api/plans/:id',
+    handle(({ db, now }, req) => {
+      const id = v.parseId(req.params.id);
+      const body = v.requireBody(
+        req.body,
+        PLAN_FIELDS.filter((field) => field !== 'clientRef')
+      );
+      return plans.updatePlan(db, id, parsePlanInput(body, { creating: false }), now());
+    })
+  );
+
+  readwrite.delete(
+    '/api/plans/:id',
+    handle(({ db }, req) => {
+      plans.deletePlan(db, v.parseId(req.params.id));
+    })
+  );
+
+  // Defects
+
+  readonly.get(
+    '/api/defects',
+    handle(({ db }, req) =>
+      defects.listDefects(db, {
+        status: optionalQuery(req.query, 'status', (value, name) =>
+          v.parseEnum(value, name, defects.DEFECT_STATUSES)
+        ),
+        entryId: optionalQuery(req.query, 'entryId', v.parseId),
+        planId: optionalQuery(req.query, 'planId', v.parseId),
+        ...v.parsePagination(req.query)
+      })
+    )
+  );
+
+  readonly.get(
+    '/api/defects/:id',
+    handle(({ db }, req) => defects.getDefect(db, v.parseId(req.params.id)))
+  );
+
+  readwrite.post(
+    '/api/defects',
+    handle(({ db, now }, req, res) => {
+      const input = parseDefectInput(v.requireBody(req.body, DEFECT_FIELDS), { creating: true });
+      const { defect, created } = defects.createDefect(db, input, now());
+      res.status(created ? 201 : 200);
+      return defect;
+    })
+  );
+
+  readwrite.patch(
+    '/api/defects/:id',
+    handle(({ db, now }, req) => {
+      const id = v.parseId(req.params.id);
+      const body = v.requireBody(
+        req.body,
+        DEFECT_FIELDS.filter((field) => field !== 'clientRef')
+      );
+      return defects.updateDefect(db, id, parseDefectInput(body, { creating: false }), now());
+    })
+  );
+
   // Export
 
   readonly.get(
@@ -707,13 +1030,13 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  readonly.get(
+  internalReadonly.get(
     '/api/export/usb',
     handle(({ config, usbExport }) => ({ directory: config.usbExportPath, ...usbExport.status() }))
   );
 
   // Goes through the scheduler, so it never overlaps an automatic copy.
-  admin.post(
+  internalAdmin.post(
     '/api/export/usb',
     handle(({ config, usbExport }) => {
       if (!config.usbExportPath) {
@@ -726,14 +1049,14 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  readonly.get(
+  internalReadonly.get(
     '/api/summary-mail',
     handle(({ summaryMailer }) => summaryMailer.status())
   );
 
   // Sends one passage's summary now, whether or not it already went out: how
   // the SMTP settings are tried without waiting for the next arrival.
-  admin.post(
+  internalAdmin.post(
     '/api/entries/:id/summary-mail',
     handle(async ({ db, summaryMailer }, req) => {
       const id = entryId(req);
@@ -746,7 +1069,7 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  readonly.get(
+  internalReadonly.get(
     '/api/cloud-sync',
     handle(({ cloudSync, cloudPairing, cloudRestore }) => ({
       ...cloudSync.status(),
@@ -756,7 +1079,7 @@ function registerRoutes(router, { getContext, logError }) {
   );
 
   // The earlier logbooks of this boat the service can give back, asked of the service now.
-  readonly.get(
+  internalReadonly.get(
     '/api/cloud-sync/restore',
     handle(async ({ cloudRestore }) => {
       try {
@@ -769,7 +1092,7 @@ function registerRoutes(router, { getContext, logError }) {
 
   // Starts bringing one of them back into this logbook, which must be empty; the restore
   // goes on in the background and GET /cloud-sync follows it.
-  admin.post(
+  internalAdmin.post(
     '/api/cloud-sync/restore',
     handle(({ cloudRestore }, req) => {
       const logbookId = req.body?.logbookId;
@@ -787,7 +1110,7 @@ function registerRoutes(router, { getContext, logError }) {
 
   // Forgets the pairing: the device token is removed from the plugin configuration and the
   // backup turns off. The service keeps what it holds, and the device until revoked there.
-  admin.delete(
+  internalAdmin.delete(
     '/api/cloud-sync/token',
     handle(async ({ cloudSync, cloudPairing, cloudRestore, removePairing }) => {
       try {
@@ -806,7 +1129,7 @@ function registerRoutes(router, { getContext, logError }) {
   // Asks the service for a pairing code, then waits in the background for someone to claim
   // it; GET /cloud-sync follows the pairing. The service is the configured one unless `url`
   // names another.
-  admin.post(
+  internalAdmin.post(
     '/api/cloud-sync/pairing',
     handle(async ({ cloudPairing }, req) => {
       const url = req.body?.url;
@@ -824,7 +1147,7 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  admin.delete(
+  internalAdmin.delete(
     '/api/cloud-sync/pairing',
     handle(({ cloudPairing }) => {
       cloudPairing.cancel();
@@ -834,7 +1157,7 @@ function registerRoutes(router, { getContext, logError }) {
 
   // Starts a backup run now rather than at the next interval; the run itself
   // goes on in the background, through its schedule, never alongside another.
-  admin.post(
+  internalAdmin.post(
     '/api/cloud-sync',
     handle(({ cloudSync, nudgeCloudSync }) => {
       const status = cloudSync.status();
@@ -852,7 +1175,7 @@ function registerRoutes(router, { getContext, logError }) {
   );
 
   // Declares the link costly, or cheap again (SPEC §4.17).
-  admin.post(
+  internalAdmin.post(
     '/api/cloud-sync/costly-link',
     handle(async ({ cloudSync, saveCostlyLink }, req) => {
       if (typeof req.body?.costly !== 'boolean') {
@@ -867,12 +1190,12 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  readonly.get(
+  internalReadonly.get(
     '/api/replay',
     handle(({ replayJob }) => replayJob.status())
   );
 
-  admin.post(
+  internalAdmin.post(
     '/api/replay',
     handle(({ replayJob }, req) => {
       const from = v.parseTimestamp(req.body.from, 'from');
@@ -884,7 +1207,7 @@ function registerRoutes(router, { getContext, logError }) {
     })
   );
 
-  admin.post(
+  internalAdmin.post(
     '/api/replay/cancel',
     handle(({ replayJob }) => {
       if (!replayJob.cancel()) {
@@ -892,6 +1215,8 @@ function registerRoutes(router, { getContext, logError }) {
       }
     })
   );
+
+  return publicRoutes;
 }
 
-module.exports = { registerRoutes };
+module.exports = { registerRoutes, API_VERSIONS, FEATURES, V1_PREFIX };