@7365admin1/layer-common 4.76.0 → 4.78.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.78.0
+
+### Minor Changes
+
+- 7050e64: Robot detail: virtual walls, safe and slow zones and the taught route drawn on the robot map (with a line naming them); records card adds status history, map details (walls, zones, versions, floor map history, obstacle picture), changes made in the maker's app and read-only robot settings; the 0-jobs state says the maker reports no finished cleaning jobs. Mobile robot-rules copy now carries the records rows.
+
+## 4.77.0
+
+### Minor Changes
+
+- e3682f3: Robot detail: an Ounitech robot shows its real floor map with its area layer, area names and live pin ("position approximate" until Ounitech confirms the map corner); Clean area picks the areas to clean; new records card: recent cleaning jobs, alert history, every robot and base-station reading, parts wear, timed switch on/off and lifts. The site mini-map shows cleaning robots on their own map.
+
 ## 4.76.0
 
 ### Minor Changes
@@ -1914,11 +1926,11 @@
   `utils/console-tier.ts` + `composables/useConsoleTier.ts` mirror the server's
   own rule from two endpoints the console already calls, unprojected:
 
-                                                                                                                                                                                                                                                                                                                                    GET /api/members/user/:user/app/admin    the Seven365 staff membership
-                                                                                                                                                                                                                                                                                                                                    GET /api/roles/id/:role                  that membership's role document
+                                                                                                                                                                                                                                                                                                                                        GET /api/members/user/:user/app/admin    the Seven365 staff membership
+                                                                                                                                                                                                                                                                                                                                        GET /api/roles/id/:role                  that membership's role document
 
-                                                                                                                                                                                                                                                                                                                                    owner  = member.type === "admin" && role.type === "admin" && role.default === true
-                                                                                                                                                                                                                                                                                                                                    staff  = member.type === "admin" && role.type === "admin"
+                                                                                                                                                                                                                                                                                                                                        owner  = member.type === "admin" && role.type === "admin" && role.default === true
+                                                                                                                                                                                                                                                                                                                                        staff  = member.type === "admin" && role.type === "admin"
 
   `role.default` is the marker because it is the only property of a platform
   staff role no API caller can set - `role.controller.ts` validates create and

package/assets/css/robot-hero.css

@@ -670,6 +670,22 @@
 .hero-mapsel__hint { font-size: 12px; opacity: 0.75; }
 .hero-plan__pt { position: absolute; width: 8px; height: 8px; margin: -4px 0 0 -4px; border-radius: 50%; background: var(--hero-accent); pointer-events: none; }
 .hero-plan__ptname { position: absolute; transform: translate(6px, -50%); font-size: 11px; white-space: nowrap; pointer-events: none; color: var(--hero-text); }
+.hero-plan__overlay { position: absolute; inset: 0; width: 100%; height: 100%; max-width: none; object-fit: fill; pointer-events: none; user-select: none; opacity: 0.35; }
+.hero-plan__zones { position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none; overflow: visible; }
+.hero-plan__zones polyline, .hero-plan__zones polygon { vector-effect: non-scaling-stroke; stroke-width: 2; stroke-linejoin: round; }
+.hero-plan__wall { fill: none; stroke: #e53935; }
+.hero-plan__safe { fill: rgba(67, 160, 71, 0.18); stroke: #43a047; }
+.hero-plan__slow { fill: rgba(251, 140, 0, 0.18); stroke: #fb8c00; }
+.hero-plan__taught { fill: none; stroke: #1e88e5; stroke-dasharray: 4 3; }
+.hero-rec__obstacles { display: block; max-width: 100%; max-height: 320px; margin-top: 4px; border: 1px solid var(--hero-line, rgba(127, 127, 127, 0.3)); image-rendering: pixelated; }
+.hero-plan__area { position: absolute; transform: translate(-50%, -50%); font-size: 11px; font-weight: 600; padding: 0 4px; white-space: nowrap; pointer-events: none; color: var(--hero-text); background: var(--hero-bg); border: 1px solid var(--hero-accent); }
+.hero-rec { margin-top: 16px; }
+.hero-rec__table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.hero-rec__table th { text-align: left; font-weight: 600; font-size: 12px; opacity: 0.75; padding: 4px 6px; border-bottom: 1px solid var(--hero-divider); }
+.hero-rec__table td { padding: 4px 6px; border-bottom: 1px solid var(--hero-divider); vertical-align: top; }
+.hero-rec__wrap { overflow-x: auto; }
+.hero-rec__grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 2px 16px; }
+.hero-rec__attn { color: var(--hero-accent); font-weight: 600; }
 .hero-plan:fullscreen { background-color: var(--hero-bg); }
 .hero-plan__corner { position: absolute; width: 14px; height: 14px; }
 .hero-plan__corner--tl { left: -1px; top: -1px; border-top: 2px solid var(--hero-accent); border-left: 2px solid var(--hero-accent); }

package/components/Robot/CleaningRecords.vue

@@ -0,0 +1,210 @@
+<template>
+  <!--
+    Robot detail's records (`/robots/:id/records`, read-only): recent cleaning
+    jobs, alert history, status history, then - folded - every reading the
+    robot sends, parts wear, the power schedule and lifts, map details (walls,
+    zones, versions, obstacles), changes made in the maker's app and the
+    robot's settings. A section shows only when the brand sends its part;
+    brands without records render nothing.
+    A part the maker refused is said in words, never left blank.
+  -->
+  <section v-if="records?.supported" class="hero-rec" aria-label="Cleaning records">
+    <div class="hero-aside__head">
+      <span class="hero-section__title">Recent cleaning jobs</span>
+      <span class="hero-aside__hint">last 14 days · from {{ makerApp }}</span>
+      <span class="hero-head__spacer" />
+      <v-btn variant="text" size="small" :loading="loading" @click="load(true)">Refresh</v-btn>
+    </div>
+    <div v-for="e in errors" :key="e" class="hero-notice hero-notice--error" role="status">{{ e }}</div>
+    <div v-if="!jobs.length && !records.tasks?.error" class="hero-sched__empty">
+      {{ noJobs }} {{ noJobsMore }}
+    </div>
+    <div v-else class="hero-rec__wrap">
+      <table class="hero-rec__table">
+        <thead>
+          <tr><th>Started</th><th>Area</th><th>Job</th><th>Took</th><th>Cleaned</th><th>Done</th><th>Result</th><th>Started by</th></tr>
+        </thead>
+        <tbody>
+          <tr v-for="j in shownJobs" :key="j.key">
+            <td>{{ j.when }}</td><td>{{ j.area }}</td><td>{{ j.job }}</td><td>{{ j.duration }}</td><td>{{ j.size }}</td><td>{{ j.done }}</td><td>{{ j.result }}</td><td>{{ j.by }}</td>
+          </tr>
+        </tbody>
+      </table>
+      <v-btn v-if="jobs.length > 5" variant="text" size="small" @click="allJobs = !allJobs">{{ allJobs ? "Show fewer" : `See all ${jobs.length}` }}</v-btn>
+    </div>
+
+    <div class="hero-section__title mt-4">Alert history</div>
+    <div class="hero-sched__note">What the robot reported in the last 30 days (open alerts are listed above).</div>
+    <div v-if="!alerts.length" class="hero-sched__empty">No alerts in the last 30 days.</div>
+    <div v-for="a in shownAlerts" :key="a.key" class="hero-sched__row hero-sched__row--alert" :title="a.vendorText">
+      <b class="hero-detail__alertcode">{{ a.code }}</b>
+      <span>{{ a.level ? `${a.level} · ` : "" }}{{ a.message }}</span>
+      <span>{{ a.when }} · {{ a.state }}</span>
+    </div>
+    <v-btn v-if="alerts.length > 5" variant="text" size="small" @click="allAlerts = !allAlerts">{{ allAlerts ? "Show fewer" : `See all ${alerts.length}` }}</v-btn>
+
+    <template v-if="has.has('statusLog')">
+      <div class="hero-section__title mt-4">Status history</div>
+      <div class="hero-sched__note">What the robot was doing in the last 7 days (cleaning, returning, charging and so on).</div>
+      <div v-if="!statusLog.length" class="hero-sched__empty">No status changes in the last 7 days.</div>
+      <div v-for="l in shownLog" :key="l.key" class="hero-sched__row"><b>{{ l.status }}</b><span>{{ l.when }}</span></div>
+      <v-btn v-if="statusLog.length > 5" variant="text" size="small" @click="allLog = !allLog">{{ allLog ? "Show fewer" : `See all ${statusLog.length}` }}</v-btn>
+    </template>
+
+    <details class="hero-can hero-can--fold" :open="attention.length > 0">
+      <summary class="hero-can__title">
+        Robot readings{{ attention.length ? ` · needs attention: ${attention.join(", ")}` : "" }}
+      </summary>
+      <div v-if="!groups.length" class="hero-sched__empty">The robot sent no readings.</div>
+      <div v-for="g in groups" :key="g.group" class="mb-2">
+        <div class="hero-sched__note">{{ g.group }}</div>
+        <div class="hero-rec__grid">
+          <div v-for="r in g.rows" :key="r.key" class="hero-can__row">
+            <span class="hero-can__label">{{ r.label }}</span>
+            <span :class="{ 'hero-rec__attn': r.attention }">{{ r.value }}</span>
+          </div>
+        </div>
+      </div>
+    </details>
+
+    <details class="hero-can hero-can--fold">
+      <summary class="hero-can__title">Parts wear, power schedule and lifts</summary>
+      <div class="hero-sched__note">Parts wear (hours worked since last reset in {{ makerApp }})</div>
+      <div v-if="!parts.length" class="hero-sched__empty">No parts reported.</div>
+      <div v-for="p in parts" :key="p.key" class="hero-sched__row"><b>{{ p.part }}</b><span>{{ p.worked }}</span><span>{{ p.days }}</span></div>
+      <div class="hero-sched__note mt-2">Timed switch on / off</div>
+      <div v-if="!power.length" class="hero-sched__empty">No timed switch on / off.</div>
+      <div v-for="p in power" :key="p.key" class="hero-sched__row">
+        <b>{{ p.days }}</b><span>{{ p.time }}</span><span>{{ p.action }}{{ p.enabled ? "" : " · off" }}</span>
+      </div>
+      <div class="hero-sched__note mt-2">Lifts linked in {{ makerApp }}</div>
+      <div v-if="!lifts.length" class="hero-sched__empty">No lifts linked to this robot's building.</div>
+      <div v-for="l in lifts" :key="l.key" class="hero-sched__row"><b>{{ l.name }}</b><span>{{ l.state }}</span></div>
+    </details>
+
+    <details v-if="has.has('mapVersions') || has.has('mapHistory') || has.has('mapLayers') || has.has('obstacles')" class="hero-can hero-can--fold">
+      <summary class="hero-can__title">Map details: walls, zones, versions and obstacles</summary>
+      <div class="hero-sched__note">Walls and zones on the robot's map (also drawn on the map above)</div>
+      <div v-if="!zones.length" class="hero-sched__empty">No virtual walls, safe zones or slow zones on this map.</div>
+      <div v-for="z in zones" :key="z.key" class="hero-sched__row"><b>{{ z.kind }}</b><span>{{ z.names }}</span></div>
+      <template v-if="has.has('mapVersions')">
+        <div class="hero-sched__note mt-2">Versions of this map (each re-scan or edit in {{ makerApp }})</div>
+        <div v-if="!versions.length" class="hero-sched__empty">No versions listed.</div>
+        <div v-for="v in versions" :key="v.key" class="hero-sched__row"><b>{{ v.version }}</b><span>{{ v.when }}</span><span>{{ v.state }}</span></div>
+      </template>
+      <template v-if="has.has('mapHistory')">
+        <div class="hero-sched__note mt-2">Every map made for this floor</div>
+        <div v-if="!history.length" class="hero-sched__empty">No maps listed for this floor.</div>
+        <div v-for="m in history" :key="m.key" class="hero-sched__row"><b>{{ m.name }}</b><span>{{ m.size }} · {{ m.when }}</span><span>{{ m.state }}</span></div>
+      </template>
+      <template v-if="has.has('obstacles')">
+        <div class="hero-sched__note mt-2">Obstacles the robot's sensors have marked (as {{ brand || "the maker" }} draws them)</div>
+        <img v-if="obstacles.image" class="hero-rec__obstacles" :src="obstacles.image" alt="Obstacles marked by the robot's sensors" />
+        <div v-else class="hero-sched__empty">{{ obstacles.note }}</div>
+      </template>
+    </details>
+
+    <details v-if="has.has('appActions')" class="hero-can hero-can--fold">
+      <summary class="hero-can__title">Changes made in {{ makerApp }} · last 30 days</summary>
+      <div v-if="!actions.length" class="hero-sched__empty">Nobody used {{ makerApp }} on this robot in the last 30 days.</div>
+      <div v-for="a in actions" :key="a.key" class="hero-sched__row"><b>{{ a.action }}</b><span>{{ a.when }}</span><span>{{ a.by }}</span></div>
+    </details>
+
+    <details v-if="has.has('settings')" class="hero-can hero-can--fold">
+      <summary class="hero-can__title">Robot settings (read-only)</summary>
+      <div class="hero-sched__note">As the robot reports them. Settings are changed in {{ makerApp }}.</div>
+      <div v-if="!settings.length" class="hero-sched__empty">The robot sent no settings.</div>
+      <div v-for="g in settings" :key="g.group" class="mb-2">
+        <div class="hero-sched__note">{{ g.group }}</div>
+        <div class="hero-rec__grid">
+          <div v-for="r in g.rows" :key="r.key" class="hero-can__row">
+            <span class="hero-can__label">{{ r.label }}</span>
+            <span>{{ r.value }}</span>
+          </div>
+        </div>
+      </div>
+    </details>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { robotErrorMessage } from "../../utils/robot-display";
+import {
+  alertHistoryRows,
+  appActionRows,
+  attentionReadings,
+  jobRows,
+  liftRows,
+  mapHistoryRows,
+  mapVersionRows,
+  noJobsHint,
+  noJobsText,
+  obstaclePicture,
+  partRows,
+  powerRows,
+  readingGroups,
+  recordErrors,
+  recordParts,
+  settingGroups,
+  statusLogRows,
+  zoneRows,
+} from "../../utils/robot-records";
+
+const props = defineProps<{ robotId: string; makerApp: string; brand?: string }>();
+const { getRobotRecords } = useRobots();
+
+const records = ref<Record<string, any> | null>(null);
+const loading = ref(false);
+const allJobs = ref(false);
+const allAlerts = ref(false);
+const allLog = ref(false);
+
+// ponytail: read on open and on Refresh only - the maker rate-limits these reads (the API caches 2 min).
+async function load(force = false) {
+  if (loading.value && !force) return;
+  loading.value = true;
+  try {
+    records.value = await getRobotRecords(props.robotId);
+  } catch (e: any) {
+    // An API without the records route (404) shows no card; any other failure is said.
+    const status = e?.statusCode ?? e?.status ?? e?.response?.status;
+    records.value = status === 404 ? null : { supported: true, error: `Couldn't read the records: ${robotErrorMessage(e)}` };
+  } finally {
+    loading.value = false;
+  }
+}
+watch(
+  () => props.robotId,
+  () => {
+    records.value = null;
+    allJobs.value = false;
+    allAlerts.value = false;
+    allLog.value = false;
+    load(true);
+  },
+  { immediate: true },
+);
+
+const jobs = computed(() => jobRows(records.value));
+const shownJobs = computed(() => (allJobs.value ? jobs.value : jobs.value.slice(0, 5)));
+const alerts = computed(() => alertHistoryRows(records.value));
+const shownAlerts = computed(() => (allAlerts.value ? alerts.value : alerts.value.slice(0, 5)));
+const groups = computed(() => readingGroups(records.value));
+const attention = computed(() => attentionReadings(records.value));
+const parts = computed(() => partRows(records.value));
+const power = computed(() => powerRows(records.value));
+const lifts = computed(() => liftRows(records.value));
+const errors = computed(() => recordErrors(records.value));
+const noJobs = computed(() => noJobsText(props.brand ?? ""));
+const noJobsMore = computed(() => noJobsHint(props.brand ?? ""));
+const has = computed(() => recordParts(records.value));
+const statusLog = computed(() => statusLogRows(records.value));
+const shownLog = computed(() => (allLog.value ? statusLog.value : statusLog.value.slice(0, 5)));
+const actions = computed(() => appActionRows(records.value));
+const settings = computed(() => settingGroups(records.value));
+const zones = computed(() => zoneRows(records.value));
+const versions = computed(() => mapVersionRows(records.value));
+const history = computed(() => mapHistoryRows(records.value));
+const obstacles = computed(() => obstaclePicture(records.value));
+</script>

package/components/Robot/Detail.vue

@@ -111,12 +111,20 @@
           :image="selectedMap?.imageUrl ?? null"
           :aspect="selectedMap?.width && selectedMap?.height ? selectedMap.width / selectedMap.height : null"
           :points="selectedMap?.points ?? []"
+          :overlay="selectedMap?.overlay ?? null"
+          :areas="selectedMap?.areas ?? []"
+          :zones="selectedMap?.zones ?? []"
+          :taught-route="selectedMap?.taughtRoute ?? []"
           :route-moving="statusMode === 'WORKING' && robotOnShownMap"
           :spot="spot"
           :pick="spotOn"
           :tick-ms="tickMs"
           @pick="(p) => spot.push(p)"
         />
+        <p v-if="mapLegend" class="hero-muted hero-detail__lag">{{ mapLegend }}</p>
+        <p v-if="selectedMap?.approximate" class="hero-muted hero-detail__lag">
+          Robot position is approximate: {{ brand }} has not yet confirmed which corner their map is measured from.
+        </p>
         <div v-if="spotOn" class="hero-spotbar">
           <v-btn color="primary" variant="flat" :disabled="!spot.length || busy === 'spot'" :loading="busy === 'spot'" @click="sendSpot">
             Send spot clean · {{ spot.length }} points
@@ -187,6 +195,9 @@
     </div>
   </section>
 
+  <!-- Cleaning robots: recent jobs, alert history, every reading, parts wear, power schedule, lifts (read-only). -->
+  <RobotCleaningRecords v-if="!noInterface && record && robotType !== 'security'" :robot-id="robotId" :maker-app="makerApp" :brand="brand" />
+
   <!-- What THIS robot (brand + model) can do, in our words; folded so it never pushes the camera down. -->
   <details v-if="abilities.length" class="hero-can hero-can--fold">
     <summary class="hero-can__title">What this robot can do</summary>
@@ -199,6 +210,19 @@
   <v-dialog v-model="confirmOpen" width="440">
     <div v-if="confirming" class="hero-dialog" role="alertdialog" aria-labelledby="hero-confirm-title">
       <div id="hero-confirm-title" class="hero-dialog__title">{{ confirming.text.title }}</div>
+      <v-select
+        v-if="confirming.zones?.length"
+        v-model="confirming.zoneNames"
+        :items="confirming.zones"
+        label="Areas to clean"
+        multiple
+        chips
+        closable-chips
+        density="compact"
+        hide-details
+        class="mb-2"
+        @update:model-value="pickZones"
+      />
       <v-select
         v-if="confirming.routes?.length"
         v-model="confirming.routeId"
@@ -214,7 +238,7 @@
       <div class="hero-dialog__body">{{ confirming.text.body }}</div>
       <div class="hero-dialog__actions">
         <v-btn variant="outlined" @click="confirmOpen = false">Don't send</v-btn>
-        <v-btn color="primary" variant="flat" @click="confirmSend">{{ confirming.text.action }}</v-btn>
+        <v-btn color="primary" variant="flat" :disabled="!!confirming.zones && !confirming.zoneNames?.length" @click="confirmSend">{{ confirming.text.action }}</v-btn>
       </div>
     </div>
   </v-dialog>
@@ -272,6 +296,7 @@ import RobotNoMonitoring from "./NoMonitoring.vue";
 import RobotCommandBar from "./CommandBar.vue";
 import RobotViewOnlyNotice from "./ViewOnlyNotice.vue";
 import RobotLivePlan from "./LivePlan.vue";
+import RobotCleaningRecords from "./CleaningRecords.vue";
 import RobotToast from "./Toast.vue";
 import RobotForm from "./Form.vue";
 import RobotPatrolHistory from "./PatrolHistory.vue";
@@ -279,7 +304,7 @@ import RobotLiveView from "./LiveView.vue";
 import RobotManualDrive from "./ManualDrive.vue";
 import RobotPointPicker from "./PointPicker.vue";
 import { faultPhotos } from "../../utils/robot-control";
-import { robotMapDefault, robotMapViews } from "../../utils/robot-maps";
+import { cleanAreaChoices, cleanAreaCommand, mapLayerLegend, robotMapDefault, robotMapViews } from "../../utils/robot-maps";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import {
   attentionText,
@@ -495,6 +520,10 @@ const planTitle = computed(() => {
 const planHint = computed(() => {
   if (spotOn.value) return "Click points on the plan, then send";
   if (noInterface.value) return "No position feed for this model";
+  if (selectedMap.value && robotType.value !== "security") {
+    const n = selectedMap.value.areas.length;
+    return `${n} cleaning area${n === 1 ? "" : "s"}`;
+  }
   if (selectedMap.value) return `${selectedMap.value.points.length} saved points · ${mapRoutes.value.length} routes`;
   if (route.value) return `${route.value.checkpoints.length} checkpoints · ${floorText.value}`;
   return ""; // the Floor cell above already says it
@@ -548,6 +577,7 @@ const mapItems = ref<Array<Record<string, any>>>([]);
 const mapViews = computed(() => robotMapViews(mapItems.value, live.value?.mapId ?? null, patrol.value?.routes ?? []));
 const selectedMapId = ref<string | null>(null);
 const selectedMap = computed(() => mapViews.value.find((m) => m.mapId === selectedMapId.value) ?? null);
+const mapLegend = computed(() => mapLayerLegend(selectedMap.value));
 watch(mapViews, (views) => {
   if (!views.some((m) => m.mapId === selectedMapId.value)) selectedMapId.value = robotMapDefault(mapItems.value, views);
 });
@@ -689,6 +719,18 @@ async function send(kind: TRobotCommandKind) {
       return;
     }
   }
+  // Clean area (cleaning robots): the API cleans named areas, so pick them from the robot's map.
+  if (kind === "area" && robotType.value !== "security") {
+    const { areas: zones, empty } = cleanAreaChoices(mapViews.value, selectedMapId.value, makerApp.value);
+    if (!zones.length) {
+      commandResult.value = { text: empty, warn: true };
+      return;
+    }
+    confirming.value = { kind: "area", body: {}, text: { title: "", body: "", action: "" }, zones, zoneNames: [zones[0]!] };
+    pickZones([zones[0]!]);
+    confirmOpen.value = true;
+    return;
+  }
   const body = commandBody(kind, live.value);
   if (!body) {
     toast.value = `${commandLabel(kind)}: the robot's position is not known yet.`;
@@ -705,8 +747,21 @@ const confirming = ref<{
   text: { title: string; body: string; action: string };
   routes?: TPatrolRouteView[];
   routeId?: string;
+  /** Clean area: the map's area names, and the ones picked. */
+  zones?: string[];
+  zoneNames?: string[];
   what?: string;
 } | null>(null);
+/** The areas picked in Clean area's confirm: the body names them and the sentence says them. */
+function pickZones(names: unknown) {
+  const c = confirming.value;
+  if (!c?.zones) return;
+  const cmd = cleanAreaCommand(record.value?.name, c.zones, names);
+  c.zoneNames = cmd.body.areas;
+  c.body = cmd.body;
+  c.what = cmd.what;
+  c.text = { ...commandConfirm("area", { type: robotType.value, name: record.value?.name }), body: cmd.sentence };
+}
 /** The route picked in Start patrol's confirm: its exact words, and the body naming it. */
 function pickRoute(id: unknown) {
   const c = confirming.value;

package/components/Robot/LivePlan.vue

@@ -9,6 +9,15 @@
     is lost - never a frozen dot.
   -->
   <RobotFloorPlan detail :pick="pick" :image="image" :aspect="aspect" @pick="emit('pick', $event)">
+    <img v-if="image && overlay" class="hero-plan__overlay" :src="overlay" alt="" aria-hidden="true" draggable="false" referrerpolicy="no-referrer" />
+    <svg v-if="image && (zones.length || taughtRoute.length > 1)" class="hero-plan__zones" viewBox="0 0 100 100" preserveAspectRatio="none" aria-hidden="true">
+      <template v-for="(z, i) in zones" :key="`${z.kind}-${i}`">
+        <polyline v-if="z.kind === 'wall'" class="hero-plan__wall" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polyline>
+        <polygon v-else :class="z.kind === 'safe' ? 'hero-plan__safe' : 'hero-plan__slow'" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polygon>
+      </template>
+      <polyline v-if="taughtRoute.length > 1" class="hero-plan__taught" :points="svgPoints(taughtRoute)" />
+    </svg>
+    <span v-for="a in placedAreas" :key="a.name" class="hero-plan__area" :style="{ left: `${a.at!.x}%`, top: `${a.at!.y}%` }">{{ a.name }}</span>
     <template v-for="p in points" :key="p.targetPointId">
       <span class="hero-plan__pt" :style="{ left: `${p.x}%`, top: `${p.y}%` }" aria-hidden="true" />
       <span class="hero-plan__ptname" :style="{ left: `${p.x}%`, top: `${p.y}%` }">{{ p.name }}</span>
@@ -56,6 +65,12 @@ const props = withDefaults(
     /** The map shown: the robot's own image and its width / height. */
     image?: string | null;
     aspect?: number | null;
+    /** The maker's coloured area layer over the map image (Ounitech), and its areas' names + label spots. */
+    overlay?: string | null;
+    areas?: Array<{ name: string; at: { x: number; y: number } | null }>;
+    /** Virtual walls / safe zones / slow zones and the taught route on the map shown (0-100 shares). */
+    zones?: Array<{ kind: "wall" | "safe" | "slow"; name: string; points: Array<{ x: number; y: number }> }>;
+    taughtRoute?: Array<{ x: number; y: number }>;
     /** Saved points on the map shown (0-100 shares). */
     points?: Array<{ targetPointId: string; name: string; x: number; y: number }>;
     /** The route's dash walks only while the robot patrols. */
@@ -67,8 +82,10 @@ const props = withDefaults(
     /** The last reading kept through a short gap: drawn faded, never as live. */
     stale?: boolean;
   }>(),
-  { stale: false, name: "", statusLabel: "", point: null, heading: 0, trail: () => [], readout: "", lost: false, route: null, routes: null, image: null, aspect: null, points: () => [], routeMoving: false, spot: () => [], pick: false, tickMs: 1200 },
+  { stale: false, name: "", statusLabel: "", point: null, heading: 0, trail: () => [], readout: "", lost: false, route: null, routes: null, image: null, aspect: null, overlay: null, areas: () => [], zones: () => [], taughtRoute: () => [], points: () => [], routeMoving: false, spot: () => [], pick: false, tickMs: 1200 },
 );
+const svgPoints = (pts: Array<{ x: number; y: number }>) => pts.map((p) => `${p.x},${p.y}`).join(" ");
+const placedAreas = computed(() => (props.image ? props.areas.filter((a) => a.at) : []));
 const emit = defineEmits<{ pick: [point: { x: number; y: number }] }>();
 // The tag stays inside the plan (flipped left near the right edge, below near the top) - never clipped.
 const tagClass = computed(() => {

package/components/Robot/SiteFleet.vue

@@ -246,19 +246,20 @@ function seenText(row: any) {
 
 /* ---- patrol routes for the security robots on screen ---- */
 const routes = ref<Record<string, TPatrolRouteView[]>>({});
-/** Each security robot's own maps (PadBot map images), read once per robot. */
+/** Each robot's own maps (PadBot / Ounitech map images), read once per robot. */
+// ponytail: read once; the maker signs image URLs for ~1 h, so a page left open longer needs a reload.
 const robotMaps = ref<Record<string, Array<Record<string, any>>>>({});
 async function loadRoutes() {
-  if (props.type !== "security") {
-    routes.value = {};
-    return;
-  }
   const missing = ids.value.filter((id) => !(id in robotMaps.value));
   if (missing.length) {
     const got: Record<string, Array<Record<string, any>>> = {};
     await Promise.allSettled(missing.map(async (id) => (got[id] = (await getRobotMaps(id))?.items ?? [])));
     robotMaps.value = { ...robotMaps.value, ...Object.fromEntries(missing.map((id) => [id, got[id] ?? []])) };
   }
+  if (props.type !== "security") {
+    routes.value = {};
+    return;
+  }
   const next: Record<string, TPatrolRouteView[]> = {};
   await Promise.allSettled(
     ids.value.map(async (id) => {

package/composables/useRobots.ts

@@ -150,6 +150,11 @@ export default function useRobots() {
     );
   }
 
+  /** Cleaning jobs, alert history, consumables, power schedule, lifts and every reading (read-only; `supported: false` for brands without). */
+  function getRobotRecords(id: string) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/robots/${id}/records`, { method: "GET", query: { appSlug } });
+  }
+
   /**
    * Signed image URLs for a map's layers.
    *
@@ -592,6 +597,7 @@ export default function useRobots() {
     getRobotState,
     getRobotMaps,
     getRobotMapImages,
+    getRobotRecords,
     getRobotPlans,
     sendRobotCommand,
     getLiveVideo,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.76.0",
+  "version": "4.78.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/utils/robot-display.ts

@@ -1692,7 +1692,8 @@ export function robotAbilities(input: {
     on("floorReporting") && "floor",
     on("readLocation") && "live position",
     on("thermalCamera") && "heat readings",
-    on("waterTanks") && "water levels and tanks",
+    on("waterTanks") && "water levels",
+    on("waterTanks") && "tank checks",
     on("patrolHistory") && (on("thermalCamera") ? "past patrols with photos and temperatures" : "past patrols with photos"),
   ].filter(Boolean) as string[];
   const p = input?.profile ?? {};

package/utils/robot-maps.ts

@@ -22,8 +22,42 @@ export type TRobotMapView = {
   routeNames: string[];
   /** Saved points placed on this map's image (0-100 from its top-left). */
   points: TRobotMapPoint[];
+  /** The maker's coloured area layer (Ounitech partition image), drawn over the map; null when none. */
+  overlay: string | null;
+  /** The map's cleaning areas by name (Clean area picks from these); `at` = label spot, null when unknown. */
+  areas: Array<{ name: string; at: { x: number; y: number } | null }>;
+  /** The maker has not confirmed the map's corner, so the robot pin may be off: say "position approximate". */
+  approximate: boolean;
+  /** Virtual walls (never crossed), safe zones and slow zones on this map, as 0-100 shares. */
+  zones: TRobotMapZone[];
+  /** The route the robot was taught on this map (0-100 shares); empty when none. */
+  taughtRoute: Array<{ x: number; y: number }>;
 };
 
+export type TRobotMapZone = { kind: "wall" | "safe" | "slow"; name: string; points: Array<{ x: number; y: number }> };
+
+const share = (p: any) => isNum(p?.x) && isNum(p?.y) && p.x >= 0 && p.x <= 100 && p.y >= 0 && p.y <= 100;
+function mapZones(list: unknown): TRobotMapZone[] {
+  return (Array.isArray(list) ? list : []).flatMap((z: any) => {
+    const points = (Array.isArray(z?.points) ? z.points : []).filter(share).map((p: any) => ({ x: p.x, y: p.y }));
+    return (z?.kind === "wall" || z?.kind === "safe" || z?.kind === "slow") && points.length >= 2 ? [{ kind: z.kind, name: String(z.name ?? ""), points }] : [];
+  });
+}
+
+/** One line under the map naming what is drawn on it: "Drawn on the map: 1 virtual wall (red) · 1 slow zone (amber) · taught route (blue dashes)". */
+export function mapLayerLegend(view: Pick<TRobotMapView, "zones" | "taughtRoute"> | null | undefined): string {
+  if (!view) return "";
+  const n = (k: TRobotMapZone["kind"]) => view.zones.filter((z) => z.kind === k).length;
+  const part = (count: number, one: string, many: string, colour: string) => (count ? `${count} ${count === 1 ? one : many} (${colour})` : "");
+  const parts = [
+    part(n("wall"), "virtual wall", "virtual walls", "red"),
+    part(n("safe"), "safe zone", "safe zones", "green"),
+    part(n("slow"), "slow zone", "slow zones", "amber"),
+    view.taughtRoute.length >= 2 ? "taught route (blue dashes)" : "",
+  ].filter(Boolean);
+  return parts.length ? `Drawn on the map: ${parts.join(" · ")}` : "";
+}
+
 const isNum = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
 const levelName = (n: number) => (n > 0 ? `L${n}` : n < 0 ? `B${-n}` : "G");
 const TYPE_WORDS: Readonly<Record<number, string>> = { 0: "Point", 3: "Lift", 4: "Loading", 6: "Access door", 10: "Charging" };
@@ -47,7 +81,8 @@ export function robotMapShare(map: Record<string, any> | null | undefined, wx: u
  * `/robots/:id/maps` items (PadBot: `mapId` + `imageUrl`) as selector entries,
  * in PadBot's order. Named by PadBot's display name; without one, "Map N"
  * with its floor, else its first route's name, as the hint ("Map 1 (B1)").
- * [] for brands whose maps are not vendor images (Ounitech keeps its own view).
+ * Ounitech maps arrive in the same shape (the API adds mapId / imageUrl / size),
+ * plus their area layer, area names and "position approximate".
  */
 export function robotMapViews(
   items: Array<Record<string, any>> | null | undefined,
@@ -78,6 +113,13 @@ export function robotMapViews(
       current: !!currentMapId && m.mapId === currentMapId,
       routeNames,
       points,
+      overlay: typeof m.partitionImageUrl === "string" && /^https?:\/\//i.test(m.partitionImageUrl) ? m.partitionImageUrl : null,
+      areas: (Array.isArray(m.areas) ? m.areas : [])
+        .filter((a: any) => typeof a?.name === "string" && a.name.trim())
+        .map((a: any) => ({ name: String(a.name).trim(), at: a.at && isNum(a.at.x) && isNum(a.at.y) ? { x: a.at.x, y: a.at.y } : null })),
+      approximate: m.positionApproximate === true,
+      zones: mapZones(m.zones),
+      taughtRoute: (Array.isArray(m.taughtRoute) ? m.taughtRoute : []).filter(share).map((p: any) => ({ x: p.x, y: p.y })),
     };
   });
 }
@@ -107,3 +149,28 @@ export function robotMapsByFloor(views: TRobotMapView[]): Map<number, TRobotMapV
   for (const v of views) if (v.floorNo !== null) out.set(v.floorNo, [...(out.get(v.floorNo) ?? []), v]);
   return out;
 }
+
+/**
+ * Clean area (cleaning robots, web and phones): the area names on the map the
+ * robot is on (else the map shown). `empty` is the sentence when there are none.
+ */
+export function cleanAreaChoices(views: TRobotMapView[], selectedMapId: string | null | undefined, makerApp: string): { mapLabel: string; areas: string[]; empty: string } {
+  const map = views.find((v) => v.current) ?? views.find((v) => v.mapId === selectedMapId) ?? null;
+  const areas = map ? map.areas.map((a) => a.name) : [];
+  return {
+    mapLabel: map?.label ?? "",
+    areas,
+    empty: areas.length ? "" : `There are no cleaning areas on ${map ? map.label : "this robot's map"} yet. Areas are drawn in ${makerApp || "the maker's app"}.`,
+  };
+}
+
+/** The picked areas as the command body, the outcome's words and the confirm sentence (only names that are on the map). */
+export function cleanAreaCommand(robotName: string | null | undefined, areas: string[], picked: unknown): { body: { kind: "area"; areas: string[] }; what: string | undefined; sentence: string } {
+  const names = (Array.isArray(picked) ? picked : []).filter((n): n is string => typeof n === "string" && areas.includes(n));
+  const list = names.length > 2 ? `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}` : names.join(" and ");
+  return {
+    body: { kind: "area", areas: names },
+    what: names.length ? `cleaning ${list}` : undefined,
+    sentence: names.length ? `${robotName || "The robot"} starts cleaning ${list}, one pass.` : "Pick at least one area.",
+  };
+}

package/utils/robot-records.ts

@@ -0,0 +1,213 @@
+/**
+ * Robot detail's records card (`/robots/:id/records`): cleaning jobs, alert
+ * history, parts wear, power schedule, lifts and every reading the robot
+ * sends, as display rows. Pure helpers - no Vue, no Node globals.
+ */
+import { dayRange } from "./robot-display.ts";
+
+type TPart<T> = { items?: T[]; error?: string } | null | undefined;
+const isNum = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+const items = <T>(p: TPart<T>): T[] => (Array.isArray(p?.items) ? p!.items! : []);
+
+/** "45 s", "16 min", "1 h 5 min"; "—" when unknown. */
+export function durationText(sec: unknown): string {
+  if (!isNum(sec) || sec < 0) return "—";
+  if (sec < 60) return `${Math.round(sec)} s`;
+  const min = Math.round(sec / 60);
+  return min < 60 ? `${min} min` : `${Math.floor(min / 60)} h${min % 60 ? ` ${min % 60} min` : ""}`;
+}
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+/** An ISO time as "30 Sep, 08:15" in the viewer's zone (or `timeZone`); "—" when unknown. */
+export function whenText(iso: unknown, timeZone?: string): string {
+  const t = typeof iso === "string" ? Date.parse(iso) : NaN;
+  if (!Number.isFinite(t)) return "—";
+  const parts = Object.fromEntries(
+    // Fixed "30 Sep, 08:15" parts (en-GB), never the device locale; the zone is the viewer's unless one is given.
+    new Intl.DateTimeFormat("en-GB", { timeZone: timeZone || undefined, day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit", hourCycle: "h23" })
+      .formatToParts(t)
+      .map((p) => [p.type, p.value]),
+  );
+  return `${parts.day} ${MONTHS[Number(parts.month) - 1]}, ${parts.hour}:${parts.minute}`;
+}
+
+export type TJobRow = { key: string; when: string; area: string; job: string; duration: string; size: string; done: string; result: string; by: string };
+
+/** Cleaning jobs, newest first as the API sends them. */
+export function jobRows(records: { tasks?: TPart<Record<string, any>> } | null | undefined, timeZone?: string): TJobRow[] {
+  return items(records?.tasks).map((t, i) => {
+    const floor = isNum(t.floorNo) ? (t.floorNo > 0 ? `L${t.floorNo}` : t.floorNo < 0 ? `B${-t.floorNo}` : "G") : "";
+    const area = [t.map, floor].filter(Boolean).join(" · ") || "—";
+    const size = isNum(t.areaM2) ? (isNum(t.plannedM2) && t.plannedM2 > 0 ? `${t.areaM2} of ${t.plannedM2} m²` : `${t.areaM2} m²`) : "—";
+    return {
+      key: `${t.id ?? ""}-${i}`,
+      when: whenText(t.start, timeZone),
+      area,
+      job: [t.job, t.mode].filter(Boolean).join(" · ") || "—",
+      duration: durationText(t.durationSec),
+      size,
+      done: isNum(t.percent) ? `${Math.round(t.percent)}%` : "—",
+      result: t.result || "—",
+      by: t.source || "—",
+    };
+  });
+}
+
+export type TAlertRow = { key: string; when: string; code: string; level: string; message: string; state: string; vendorText: string };
+
+export function alertHistoryRows(records: { alerts?: TPart<Record<string, any>> } | null | undefined, timeZone?: string): TAlertRow[] {
+  return items(records?.alerts).map((a, i) => ({
+    key: `${a.code ?? ""}-${a.at ?? ""}-${i}`,
+    when: whenText(a.at, timeZone),
+    code: a.code ? String(a.code) : "—",
+    level: a.level || "",
+    message: a.message || a.vendorText || "—",
+    state: a.resolved ? "Resolved" : "Reported",
+    vendorText: a.vendorText && a.vendorText !== a.message ? String(a.vendorText) : "",
+  }));
+}
+
+/** Readings grouped in the API's order ("Battery", "Water", ...), base station last. */
+export function readingGroups(records: { readings?: TPart<Record<string, any>>; station?: TPart<Record<string, any>> } | null | undefined) {
+  const rows = [...items(records?.readings), ...items(records?.station).flatMap((s) => (Array.isArray(s?.readings) ? s.readings : []))];
+  const status = items(records?.station)[0]?.status;
+  if (status) rows.push({ key: "station-status", group: "Base station", label: "Station status", value: String(status), attention: false });
+  const groups: Array<{ group: string; rows: Array<{ key: string; label: string; value: string; attention: boolean }> }> = [];
+  for (const r of rows) {
+    const g = String(r?.group || "Other readings");
+    let hit = groups.find((x) => x.group === g);
+    if (!hit) groups.push((hit = { group: g, rows: [] }));
+    hit.rows.push({ key: String(r.key ?? r.label), label: String(r.label ?? r.key), value: String(r.value ?? ""), attention: r.attention === true });
+  }
+  return groups;
+}
+
+/** Readings that need a person ("Dust box fitted: No"), for the card's one-line summary. */
+export function attentionReadings(records: Parameters<typeof readingGroups>[0]): string[] {
+  return readingGroups(records).flatMap((g) => g.rows.filter((r) => r.attention).map((r) => `${r.label}: ${r.value}`));
+}
+
+export function partRows(records: { consumables?: TPart<Record<string, any>> } | null | undefined) {
+  return items(records?.consumables).map((c, i) => ({
+    key: `${c.part}-${i}`,
+    part: String(c.part ?? "Part"),
+    worked: isNum(c.hours) ? `${c.hours} h` : "—",
+    days: isNum(c.days) ? `${c.days} days` : "—",
+  }));
+}
+
+export function powerRows(records: { power?: TPart<Record<string, any>> } | null | undefined) {
+  return items(records?.power).map((p, i) => ({
+    key: `${p.time}-${i}`,
+    days: dayRange(p.days),
+    time: p.time || "—",
+    action: p.action === "on" ? "Switch on" : "Switch off",
+    enabled: p.enabled !== false,
+  }));
+}
+
+export function liftRows(records: { lifts?: TPart<Record<string, any>> } | null | undefined) {
+  return items(records?.lifts).map((l, i) => ({
+    key: `${l.name}-${i}`,
+    name: String(l.name ?? "Lift"),
+    state: `${l.online ? "Online" : "Offline"}${l.enabled === false ? " · disabled" : ""}${isNum(l.floorNo) ? ` · at L${l.floorNo}` : ""}`,
+  }));
+}
+
+/** "Couldn't read the cleaning records: …" per refused part, so a gap is said, never silent. */
+export function recordErrors(records: Record<string, any> | null | undefined): string[] {
+  const names: Record<string, string> = {
+    tasks: "cleaning jobs",
+    alerts: "alert history",
+    consumables: "parts wear",
+    power: "power schedule",
+    lifts: "lifts",
+    readings: "robot readings",
+    station: "base station",
+    statusLog: "status history",
+    appActions: "changes made in the maker's app",
+    settings: "robot settings",
+    obstacles: "obstacle picture",
+    mapVersions: "map versions",
+    mapHistory: "floor's map history",
+  };
+  if (!records) return [];
+  const out = typeof records.error === "string" && records.error ? [records.error] : [];
+  for (const [k, name] of Object.entries(names)) {
+    const e = records[k]?.error;
+    if (typeof e === "string" && e) out.push(`Couldn't read the ${name}: ${e}`);
+  }
+  return out;
+}
+
+/** The empty cleaning-jobs line, in plain words (the maker's own list is empty, not ours). */
+export function noJobsText(brand: string, days = 14): string {
+  return `${brand || "The maker"} reports no finished cleaning jobs in the last ${days} days.`;
+}
+
+/** The line under it: what would make a job appear, and that the maker has been asked. */
+export function noJobsHint(brand: string): string {
+  const who = brand || "the maker";
+  return `A job started here or by a schedule is listed once ${who} records it; if this robot was meant to clean, we have asked ${who} why nothing is listed.`;
+}
+
+type TWhenRow = { key: string; when: string };
+
+/** The robot's status changes (cleaning, charging, returning ...), newest first as sent. */
+export function statusLogRows(records: { statusLog?: TPart<Record<string, any>> } | null | undefined, timeZone?: string): Array<TWhenRow & { status: string }> {
+  return items(records?.statusLog).map((l, i) => ({ key: `${l.at ?? ""}-${i}`, when: whenText(l.at, timeZone), status: String(l.status || "—") }));
+}
+
+/** What people did to the robot in the maker's app ("Started a cleaning job · Leong"). */
+export function appActionRows(records: { appActions?: TPart<Record<string, any>> } | null | undefined, timeZone?: string): Array<TWhenRow & { action: string; by: string }> {
+  return items(records?.appActions).map((a, i) => ({ key: `${a.at ?? ""}-${i}`, when: whenText(a.at, timeZone), action: String(a.action || "—"), by: a.by ? String(a.by) : "—" }));
+}
+
+/** The robot's settings, grouped in the API's order ("Cleaning", "Battery", ... "Other settings" last). */
+export function settingGroups(records: { settings?: TPart<Record<string, any>> } | null | undefined) {
+  return readingGroups({ readings: records?.settings });
+}
+
+/** The current map's walls and zones by kind: "2 virtual walls (Entrance, …)". */
+export function zoneRows(records: { mapLayers?: TPart<Record<string, any>> } | null | undefined): Array<{ key: string; kind: string; names: string }> {
+  const zones: Array<{ kind?: string; name?: string }> = items(records?.mapLayers).flatMap((m) => (Array.isArray(m?.zones) ? m.zones : []));
+  const words: Record<string, [string, string]> = { wall: ["virtual wall", "virtual walls"], safe: ["safe zone", "safe zones"], slow: ["slow zone", "slow zones"] };
+  return (["wall", "safe", "slow"] as const).flatMap((k) => {
+    const names = zones.filter((z) => z.kind === k).map((z) => String(z.name ?? ""));
+    if (!names.length) return [];
+    const [one, many] = words[k]!;
+    return [{ key: k, kind: `${names.length} ${names.length === 1 ? one : many}`, names: names.join(", ") }];
+  });
+}
+
+/** Each version of the current map (re-scan or edit), newest first. */
+export function mapVersionRows(records: { mapVersions?: TPart<Record<string, any>> } | null | undefined, timeZone?: string) {
+  return items(records?.mapVersions)
+    .slice()
+    .sort((a, b) => (isNum(b.version) ? b.version : 0) - (isNum(a.version) ? a.version : 0))
+    .map((v, i) => ({ key: `${v.version ?? i}`, version: isNum(v.version) ? `Version ${v.version}` : "Version —", when: whenText(v.createdAt, timeZone), state: v.latest ? "In use" : "Older" }));
+}
+
+/** Every map made for the robot's floor: name, size, in use or not. */
+export function mapHistoryRows(records: { mapHistory?: TPart<Record<string, any>> } | null | undefined, timeZone?: string) {
+  return items(records?.mapHistory).map((m, i) => ({
+    key: `${m.name}-${i}`,
+    name: String(m.name ?? "Map"),
+    size: isNum(m.areaM2) ? `${m.areaM2} m²` : "—",
+    when: `made ${whenText(m.createdAt, timeZone)}${m.updatedAt ? ` · changed ${whenText(m.updatedAt, timeZone)}` : ""}`,
+    state: m.latest ? "Latest map" : m.inUse ? "Switched on" : "Old map",
+  }));
+}
+
+/** The obstacle picture as a data URL, or a sentence when it is too large / not sent. */
+export function obstaclePicture(records: { obstacles?: TPart<Record<string, any>> } | null | undefined): { image: string | null; note: string } {
+  const o = items(records?.obstacles)[0];
+  if (o && typeof o.image === "string" && /^data:image\/(png|jpeg);base64,/.test(o.image)) return { image: o.image, note: "" };
+  return { image: null, note: o?.tooLarge ? "The obstacle picture is too large to show here." : "No obstacle picture was sent." };
+}
+
+/** Which records parts this brand sends (a section shows only when its part is there - capability-driven). */
+export function recordParts(records: Record<string, any> | null | undefined): Set<string> {
+  return new Set(Object.keys(records ?? {}).filter((k) => records![k] && typeof records![k] === "object" && "items" in records![k]));
+}