@7365admin1/layer-common 4.77.0 → 4.78.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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
@@ -1920,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

@@ -671,6 +671,13 @@
 .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; }

package/components/Robot/CleaningRecords.vue

@@ -1,8 +1,11 @@
 <template>
   <!--
     Robot detail's records (`/robots/:id/records`, read-only): recent cleaning
-    jobs, alert history, then - folded - every reading the robot sends, parts
-    wear, the power schedule and lifts. Brands without records render nothing.
+    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">
@@ -13,7 +16,9 @@
       <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" class="hero-sched__empty">No cleaning jobs in the last 14 days.</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>
@@ -38,6 +43,14 @@
     </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(", ")}` : "" }}
@@ -68,21 +81,84 @@
       <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, attentionReadings, jobRows, liftRows, partRows, powerRows, readingGroups, recordErrors } from "../../utils/robot-records";
+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 }>();
+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) {
@@ -104,6 +180,7 @@ watch(
     records.value = null;
     allJobs.value = false;
     allAlerts.value = false;
+    allLog.value = false;
     load(true);
   },
   { immediate: true },
@@ -119,4 +196,15 @@ 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

@@ -113,12 +113,15 @@
           :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>
@@ -193,7 +196,7 @@
   </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" />
+  <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">
@@ -301,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,
@@ -574,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);
 });
@@ -717,10 +721,9 @@ async function send(kind: TRobotCommandKind) {
   }
   // Clean area (cleaning robots): the API cleans named areas, so pick them from the robot's map.
   if (kind === "area" && robotType.value !== "security") {
-    const map = mapViews.value.find((m) => m.current) ?? selectedMap.value;
-    const zones = map?.areas.map((a) => a.name) ?? [];
+    const { areas: zones, empty } = cleanAreaChoices(mapViews.value, selectedMapId.value, makerApp.value);
     if (!zones.length) {
-      commandResult.value = { text: `There are no cleaning areas on ${map ? map.label : "this robot's map"} yet. Areas are drawn in ${makerApp.value}.`, warn: true };
+      commandResult.value = { text: empty, warn: true };
       return;
     }
     confirming.value = { kind: "area", body: {}, text: { title: "", body: "", action: "" }, zones, zoneNames: [zones[0]!] };
@@ -753,13 +756,11 @@ const confirming = ref<{
 function pickZones(names: unknown) {
   const c = confirming.value;
   if (!c?.zones) return;
-  const picked = (Array.isArray(names) ? names : []).filter((n): n is string => typeof n === "string" && c.zones!.includes(n));
-  const list = picked.length > 2 ? `${picked.slice(0, -1).join(", ")} and ${picked.at(-1)}` : picked.join(" and ");
-  c.zoneNames = picked;
-  c.body = { kind: "area", areas: picked };
-  c.what = picked.length ? `cleaning ${list}` : undefined;
-  const text = commandConfirm("area", { type: robotType.value, name: record.value?.name });
-  c.text = { ...text, body: picked.length ? `${record.value?.name ?? "The robot"} starts cleaning ${list}, one pass.` : "Pick at least one area." };
+  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) {

package/components/Robot/LivePlan.vue

@@ -10,6 +10,13 @@
   -->
   <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" />
@@ -61,6 +68,9 @@ const props = withDefaults(
     /** 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. */
@@ -72,8 +82,9 @@ 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, overlay: null, areas: () => [], 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.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.77.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-maps.ts

@@ -28,8 +28,36 @@ export type TRobotMapView = {
   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" };
@@ -90,6 +118,8 @@ export function robotMapViews(
         .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 })),
     };
   });
 }
@@ -119,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

@@ -24,7 +24,8 @@ 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(
-    new Intl.DateTimeFormat("en-GB", { day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit", hourCycle: "h23", ...(timeZone ? { timeZone } : {}) })
+    // 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]),
   );
@@ -124,6 +125,12 @@ export function recordErrors(records: Record<string, any> | null | undefined): s
     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] : [];
@@ -133,3 +140,74 @@ export function recordErrors(records: Record<string, any> | null | undefined): s
   }
   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]));
+}