@7365admin1/layer-common 4.54.1 → 4.56.0

package/components/Robot/LivePlan.vue

@@ -8,8 +8,12 @@
     clean: each click adds a numbered point. "Reconnecting…" when the position
     is lost - never a frozen dot.
   -->
-  <RobotFloorPlan detail :pick="pick" @pick="emit('pick', $event)">
-    <RobotPatrolRoutes v-if="route" :routes="[route]" :animate="routeMoving" large />
+  <RobotFloorPlan detail :pick="pick" :image="image" :aspect="aspect" @pick="emit('pick', $event)">
+    <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>
+    </template>
+    <RobotPatrolRoutes v-if="routes?.length || route" :routes="routes?.length ? routes : [route!]" :animate="routeMoving" large />
     <template v-if="point">
       <span v-for="t in trailDots(trail)" :key="t.key" class="hero-trail" :style="{ left: t.left, top: t.top, opacity: t.op }" aria-hidden="true" />
       <span class="hero-cross hero-cross--h" :style="{ top: point.top, transition: `top ${tickMs}ms linear` }" aria-hidden="true" />
@@ -46,6 +50,13 @@ withDefaults(
     /** Position lost: "Reconnecting…" over the plan. */
     lost?: boolean;
     route?: TPatrolRouteView | null;
+    /** Several routes (the robot's routes on the map shown); wins over `route`. */
+    routes?: TPatrolRouteView[] | null;
+    /** The map shown: the robot's own image and its width / height. */
+    image?: string | null;
+    aspect?: number | null;
+    /** 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. */
     routeMoving?: boolean;
     /** Spot-clean points (0-100 shares) and whether clicks add them. */
@@ -55,7 +66,7 @@ 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, 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, points: () => [], routeMoving: false, spot: () => [], pick: false, tickMs: 1200 },
 );
 const emit = defineEmits<{ pick: [point: { x: number; y: number }] }>();
 </script>

package/components/Robot/MiniMap.vue

@@ -15,12 +15,15 @@
         </svg>
       </v-btn>
       <button v-if="hasRoutes" type="button" class="hero-mini__toggle" :aria-pressed="showRoutes" title="Show the robots' lanes and waypoints" @click="showRoutes = !showRoutes">Routes</button>
+      <select v-if="floorMaps.length" v-model="chosenMap" class="hero-input hero-select hero-select--sm" aria-label="Robot map">
+        <option v-for="m in floorMaps" :key="m.mapId" :value="m.mapId">{{ m.label }}{{ m.current ? " · Robot is here" : "" }}</option>
+      </select>
       <select v-if="floors.length" :value="floor" class="hero-input hero-select hero-select--sm" aria-label="Floor" @change="chosen = Number(($event.target as HTMLSelectElement).value)">
         <option v-for="f in floors" :key="f" :value="f">{{ floorName(f) }}</option>
       </select>
     </div>
 
-    <RobotFloorPlan ref="plan">
+    <RobotFloorPlan ref="plan" :image="shownMap?.imageUrl ?? null" :aspect="shownMap?.width && shownMap?.height ? shownMap.width / shownMap.height : null">
       <template v-if="showRoutes && overlay.lanes.length + overlay.waypoints.length">
         <svg class="hero-plan__svg" viewBox="0 0 100 100" preserveAspectRatio="none" aria-hidden="true">
           <line v-for="(l, i) in overlay.lanes" :key="`l${i}`" class="hero-mini__lane" :class="{ 'hero-mini__lane--oneway': l.oneWay }" :x1="l.a.x" :y1="l.a.y" :x2="l.b.x" :y2="l.b.y" vector-effect="non-scaling-stroke" />
@@ -46,7 +49,7 @@
     </RobotFloorPlan>
 
     <div class="hero-mini__foot">
-      <span>Floor plan from robot (placeholder)</span>
+      <span>{{ shownMap ? `Robot map · ${shownMap.label}` : "Floor plan from robot (placeholder)" }}</span>
       <span v-if="type === 'security'"><span class="hero-mini__legend" aria-hidden="true" />Patrol routes</span>
       <span v-if="showRoutes && hasRoutes"><span class="hero-mini__legend hero-mini__legend--lane" aria-hidden="true" />Robot lanes</span>
       <span v-if="floor !== null" class="hero-mini__count">{{ robots.length }} on {{ floorName(floor) }}</span>
@@ -56,8 +59,9 @@
 </template>
 
 <script setup lang="ts">
-import { computed, ref } from "vue";
+import { computed, ref, watch } from "vue";
 import { routeOverlay } from "../../utils/rmf-editor";
+import { robotMapViews, type TRobotMapView } from "../../utils/robot-maps";
 import RobotFloorPlan from "./FloorPlan.vue";
 import RobotPatrolRoutes from "./PatrolRoutes.vue";
 import RobotReconnecting from "./Reconnecting.vue";
@@ -91,17 +95,46 @@ const props = withDefaults(
     tickMs?: number;
     /** The site's building (saved map or live HERO Fleet Core building) - its robot lanes and waypoints can be shown. */
     map?: Record<string, any> | null;
+    /** Each robot's own maps (`/robots/:id/maps` items) by robot id - PadBot's map images and a map selector. */
+    robotMaps?: Record<string, Array<Record<string, any>>>;
   }>(),
-  { type: "cleaning", routes: () => ({}), connected: true, brands: () => [], tickMs: 4000, map: null },
+  { type: "cleaning", routes: () => ({}), connected: true, brands: () => [], tickMs: 4000, map: null, robotMaps: () => ({}) },
 );
 const emit = defineEmits<{ open: [id: string] }>();
 
 const plan = ref<InstanceType<typeof RobotFloorPlan> | null>(null);
 const ids = computed(() => props.rows.map((r) => String(r._id)));
-const floors = computed(() => mapFloors(ids.value, props.states));
+/** Every robot map once (a robot's map is "current" when that robot reports it). */
+const allMaps = computed(() => {
+  const seen = new Map<string, TRobotMapView>();
+  for (const id of ids.value) {
+    for (const m of robotMapViews(props.robotMaps[id], props.states[id]?.mapId ?? null, props.routes[id] ?? [])) {
+      const had = seen.get(m.mapId);
+      seen.set(m.mapId, had ? { ...had, current: had.current || m.current } : m);
+    }
+  }
+  return [...seen.values()];
+});
+// Floors the robots report, plus the floors their own maps name.
+const floors = computed(() =>
+  [...new Set([...mapFloors(ids.value, props.states), ...allMaps.value.flatMap((m) => (m.floorNo === null ? [] : [m.floorNo]))])].sort((a, b) => a - b),
+);
 const chosen = ref<number | null>(null);
 const floor = computed(() => pickFloor(floors.value, chosen.value, ids.value, props.states));
-const robots = computed(() => mapRobots(props.rows, props.states, floor.value));
+/** The robot maps for the floor shown (a map with no floor is offered on every floor). */
+const floorMaps = computed(() => allMaps.value.filter((m) => m.floorNo === null || floor.value === null || m.floorNo === floor.value));
+const chosenMap = ref<string | null>(null);
+const shownMap = computed(
+  () => floorMaps.value.find((m) => m.mapId === chosenMap.value) ?? floorMaps.value.find((m) => m.current) ?? floorMaps.value[0] ?? null,
+);
+watch(shownMap, (m) => (chosenMap.value = m?.mapId ?? null), { immediate: true });
+/** On a robot map, only the robots on that map (a brand without map ids is drawn as before). */
+const robots = computed(() =>
+  mapRobots(props.rows, props.states, floor.value).filter((r) => {
+    const on = props.states[r.id]?.mapId;
+    return !shownMap.value || !on || on === shownMap.value.mapId;
+  }),
+);
 /** The robots' lanes and waypoints on the floor shown (toggle; on by default once the building has any). */
 const overlay = computed(() => (floor.value === null ? { lanes: [], waypoints: [], fiducials: [] } : routeOverlay(props.map, floor.value)));
 const hasRoutes = computed(() => !!props.map && (props.map.rmf?.levels ?? props.map.levels ?? []).some((l: any) => (l.lanes ?? []).length));
@@ -115,7 +148,8 @@ const floorRoutes = computed(() => {
     const st = props.states[id];
     for (const r of props.routes[id] ?? []) {
       const f = r.floorNo ?? (st?.floorKnown ? st.floorNo : null);
-      if (f === floor.value && !seen.has(r.id)) seen.set(r.id, r);
+      const onMap = !shownMap.value || !r.mapId || r.mapId === shownMap.value.mapId;
+      if ((r.mapId && shownMap.value ? onMap : f === floor.value) && !seen.has(r.id)) seen.set(r.id, r);
     }
   }
   return [...seen.values()];

package/components/Robot/PointPicker.vue

@@ -2,11 +2,20 @@
   <!-- Go to point / Set position: the robot's own saved points, per map. -->
   <div class="hero-dialog" role="dialog" aria-labelledby="hero-pick-title">
     <div id="hero-pick-title" class="hero-dialog__title">{{ kind === "navigate" ? "Go to point" : "Set position" }}</div>
-    <div v-if="kind === 'relocalize'" class="hero-dialog__body">Only points on the floor the robot reports are listed.</div>
-    <div v-if="!groups.length" class="hero-muted">No saved points{{ kind === "relocalize" ? " on the robot's current floor" : "" }}.</div>
+    <div v-if="kind === 'relocalize'" class="hero-dialog__body">Only points on the map the robot is on are listed.</div>
+    <div v-if="!groups.length" class="hero-muted">No saved points{{ kind === "relocalize" ? " on the robot's current map" : "" }}.</div>
     <div v-for="g in groups" :key="g.mapId" class="hero-pick__group">
-      <div class="hero-aside__title">{{ g.title }}</div>
-      <button v-for="p in g.points" :key="p.targetPointId" type="button" class="hero-pick__point" :aria-pressed="chosen === p" @click="chosen = p">
+      <div class="hero-aside__title">{{ g.title }}<template v-if="g.here"> · Robot is here</template></div>
+      <div v-if="g.note" class="hero-mapsel__hint">{{ g.note }}</div>
+      <button
+        v-for="p in g.points"
+        :key="p.targetPointId"
+        type="button"
+        class="hero-pick__point"
+        :aria-pressed="chosen === p"
+        :disabled="!g.ok"
+        @click="chosen = p"
+      >
         {{ p.name }} <span class="hero-dim">{{ p.type }}</span>
       </button>
     </div>
@@ -25,9 +34,37 @@
 <script setup lang="ts">
 import { computed, ref } from "vue";
 import type { TSavedPoint, TSavedPointGroup } from "../../utils/robot-display";
+import { robotMapReach, type TRobotMapView } from "../../utils/robot-maps";
 
-const props = defineProps<{ kind: "navigate" | "relocalize"; groups: TSavedPointGroup[]; floorNo?: number | null }>();
+const props = withDefaults(
+  defineProps<{
+    kind: "navigate" | "relocalize";
+    groups: TSavedPointGroup[];
+    floorNo?: number | null;
+    /** The map the robot reports it is on (PadBot); null when it has not said. */
+    currentMapId?: string | null;
+    /** The robot's maps, for the map-group rule of Go to point. */
+    maps?: TRobotMapView[];
+  }>(),
+  { floorNo: null, currentMapId: null, maps: () => [] },
+);
 const emit = defineEmits<{ close: []; pick: [point: TSavedPoint] }>();
 const chosen = ref<TSavedPoint | null>(null);
-const groups = computed(() => (props.kind === "relocalize" ? props.groups.filter((g) => g.floorNo !== null && g.floorNo === props.floorNo) : props.groups));
+/** The robot's own map first; another map's points only when the robot can get there on its own. */
+const groups = computed(() => {
+  const here = (g: TSavedPointGroup) => !!props.currentMapId && g.mapId === props.currentMapId;
+  const list =
+    props.kind === "relocalize"
+      ? props.groups.filter((g) => (props.currentMapId ? here(g) : g.floorNo !== null && g.floorNo === props.floorNo))
+      : props.groups;
+  return [...list]
+    .sort((a, b) => Number(here(b)) - Number(here(a)))
+    .map((g) => {
+      // With one map, or no map reported by a brand without map ids, nothing to guard.
+      const reach = props.kind === "navigate" && props.groups.length > 1 ? robotMapReach(props.maps, props.currentMapId, g.mapId) : { ok: true, note: "" };
+      // The selector's name for the map ("Map 1 (B1)") when PadBot gives only ids.
+      const title = props.maps.find((m) => m.mapId === g.mapId)?.label ?? g.title;
+      return { ...g, title, here: here(g), ok: reach.ok, note: reach.note };
+    });
+});
 </script>

package/components/Robot/SiteFleet.vue

@@ -37,9 +37,10 @@
         @click:row="onRow"
       >
         <template #item.name="{ item }"><span class="hero-table__name">{{ item.name }}</span></template>
-        <template #item.brand="{ item }"><span class="hero-dim">{{ brandName(item.brand, brands) }}</span></template>
+        <template #item.brand="{ item }"><span class="hero-dim">{{ brandModelText(item.brand, brands, live(item)) }}</span></template>
         <template #item.capability="{ item }">
-          <span v-if="capsOf(item)" class="hero-tag hero-tag--neutral hero-tag--xs">{{ capabilityLabel(capsOf(item)) }}</span>
+          <!-- One badge per row; the model's abilities in its tooltip (a mixed fleet without clutter). -->
+          <span v-if="capsOf(item)" class="hero-tag hero-tag--neutral hero-tag--xs" :title="abilityTip(item)">{{ capabilityLabel(capsOf(item)) }}</span>
         </template>
         <template #item.status="{ item }">
           <RobotStatusChip v-if="statusOf(item).kind === 'live'" :mode="statusOf(item).mode" :type="item.type" />
@@ -70,6 +71,7 @@
         :states="states"
         :type="type"
         :routes="routes"
+        :robot-maps="robotMaps"
         :connected="connected"
         :brands="brands"
         :map="routeMap"
@@ -91,8 +93,10 @@ import RobotMiniMap from "./MiniMap.vue";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import {
   agoText,
+  brandModelText,
   brandName,
   capabilityLabel,
+  robotAbilities,
   listMeta,
   robotErrorMessage,
   rowStatus,
@@ -127,7 +131,7 @@ const emit = defineEmits<{
   status: [status: { connected: boolean; faults: number; siteName: string; clientName: string }];
 }>();
 
-const { getSiteFleet, getSiteSummary, getRobotBrands, getPatrolRoutes, listSiteBuildingMaps, getBuildingMap, getFleetCoreBuilding } = useRobots();
+const { getSiteFleet, getSiteSummary, getRobotBrands, getPatrolRoutes, getRobotMaps, listSiteBuildingMaps, getBuildingMap, getFleetCoreBuilding } = useRobots();
 
 /**
  * The site's building for the mini-map's robot lanes: the live HERO Fleet
@@ -226,6 +230,14 @@ function capsOf(row: any) {
   if (s && s.monitorable === false) return {};
   return null;
 }
+/** "Does: … · Reports: …" for the capability badge's tooltip. */
+function abilityTip(row: any) {
+  const s = live(row);
+  return robotAbilities({ capabilities: capsOf(row), profile: s?.ok ? s.profile : null, type: row.type, brand: brandName(row.brand, brands.value) })
+    .map((r) => `${r.label}: ${r.value}`)
+    .join("
+");
+}
 /** The live fault when the robot answers, else its stored open fault. */
 const faultOf = (row: any) => (live(row)?.ok ? live(row)?.fault ?? null : row.fault ?? null);
 function seenText(row: any) {
@@ -235,11 +247,19 @@ 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. */
+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] ?? []])) };
+  }
   const next: Record<string, TPatrolRouteView[]> = {};
   await Promise.allSettled(
     ids.value.map(async (id) => {

package/package.json

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

@@ -395,7 +395,7 @@ export type TRobotCommandKind =
 const COMMANDS: ReadonlyArray<{ kind: TRobotCommandKind; label: string }> = [
   { kind: "full", label: "Clean all" },
   { kind: "area", label: "Clean area" },
-  { kind: "return", label: "Return to dock" },
+  { kind: "return", label: "Return to charger" },
   { kind: "pause", label: "Pause" },
   { kind: "resume", label: "Resume" },
   { kind: "cancel", label: "Cancel" },
@@ -605,14 +605,19 @@ export type TLiveRobotState = {
   batteryPercent?: number | null;
   floorNo?: number | null;
   floorKnown?: boolean;
+  /** The brand's id of the map the robot is on now (PadBot); absent / null when unknown. */
+  mapId?: string | null;
   position?: { x: number; y: number; theta: number } | null;
   /** Where it is on its own floor plan, 0-100 from the top-left; absent when the brand cannot say. */
   planPosition?: { x: number; y: number } | null;
-  /** The brand's own status words ("CLEANING_AUTO"), quoted as "Brand status". */
+  /** The brand's own status words ("CLEANING_AUTO"), quoted as "Robot reports". */
   statusName?: string;
   model?: string;
   fault?: { code: string; message?: string; since?: number; imageUrl?: string | null; thermalImageUrl?: string | null } | null;
+  /** Brand defaults + this MODEL's differences (core `robotManifest`): two models of one brand can differ. */
   capabilities?: Record<string, unknown>;
+  /** Plain-words facts for this brand + model (core `robotManifest`). */
+  profile?: TRobotProfile;
   lastSeenAt?: string | null;
   /** Epoch ms of the last answer that was read (set by `mergeLiveStates`). */
   readAt?: number;
@@ -890,6 +895,8 @@ export type TPatrolRouteView = {
   currentCheckpoint: number | null;
   /** Every stop's name in order, placed on the plan or not (PadBot); a route with none placed is listed, never drawn. */
   stops?: string[];
+  /** The brand's id of the map this route is on (PadBot). */
+  mapId?: string;
 };
 
 const placed = (c: { x?: unknown; y?: unknown }) => finite(c?.x) && finite(c?.y);
@@ -1110,6 +1117,8 @@ export function savedPointGroups(maps: Array<Record<string, any>> | null | undef
  */
 export function pointCommandBody(kind: "navigate" | "relocalize", point: TSavedPoint, live: TLiveRobotState | null | undefined): Record<string, unknown> | null {
   if (kind === "navigate") return { kind: "go-to-point", mapId: point.mapId, targetPointId: point.targetPointId };
+  // Set position only on the map the robot is on (when it says which).
+  if (typeof live?.mapId === "string" && live.mapId && point.mapId !== live.mapId) return null;
   if (point.floorNo === null || !finite(live?.floorNo) || live!.floorNo !== point.floorNo) return null;
   return { kind: "relocalize", floorNo: point.floorNo, x: point.x, y: point.y, theta: (point.yaw * Math.PI) / 180 };
 }
@@ -1206,14 +1215,16 @@ export type TRobotFact = { label: string; value: string; dim: boolean };
 
 /**
  * The detail screen's facts grid (README §3): Connection · Battery · Floor ·
- * Live position · Brand status · Model · Serial · Last seen. A fact the brand
+ * Live position · Robot reports · Model · Serial · Last seen. A fact the brand
  * cannot report reads "Not reported" at 50%; a brand with no interface
- * reports nothing live at all.
+ * reports nothing live at all. `hideUnreported` drops those cells instead
+ * (owner 2026-09-26: show only what THIS robot supports - hide, never grey).
  */
 export function robotFacts(input: {
   record?: Record<string, any> | null;
   live?: (TLiveRobotState & { statusName?: string; model?: string }) | null;
   now?: number;
+  hideUnreported?: boolean;
 }): TRobotFact[] {
   const live = input.live ?? null;
   const record = input.record ?? {};
@@ -1233,16 +1244,19 @@ export function robotFacts(input: {
   const position = !reports("readLocation")
     ? nr("Live position")
     : fact("Live position", live ? positionText(live, caps ?? { readLocation: true }) : "");
-  return [
+  const all = [
     connection,
     battery,
     floor,
     position,
-    none ? nr("Brand status") : fact("Brand status", live?.ok ? live.statusName : ""),
-    fact("Model", live?.ok ? live.model : ""),
+    // A bare vendor code ("CLEANING_AUTO") is not words: the status chip already says it in ours.
+    none ? nr("Robot reports") : fact("Robot reports", live?.ok && !/^[A-Z0-9_]+$/.test(live.statusName ?? "") ? live.statusName : ""),
+    fact("Model", live?.ok ? live.profile?.model || live.model : ""),
     fact("Serial", record.robotSn),
     fact("Last seen", agoText(live?.lastSeenAt ?? record.lastSeenAt, input.now)),
   ];
+  // Hidden: a fact the brand cannot report, and a model nobody reported.
+  return input.hideUnreported ? all.filter((f) => !(f.dim && f.value === "Not reported") && !((f.label === "Model" || f.label === "Robot reports") && f.value === "—")) : all;
 }
 
 /**
@@ -1252,7 +1266,7 @@ export function robotFacts(input: {
  */
 export function mergePose(
   live: TLiveRobotState | null | undefined,
-  event: { type?: unknown; pose?: { x?: unknown; y?: unknown; theta?: unknown; mode?: unknown } | null; planPosition?: unknown } | null | undefined,
+  event: { type?: unknown; pose?: { x?: unknown; y?: unknown; theta?: unknown; mode?: unknown } | null; planPosition?: unknown; mapId?: unknown } | null | undefined,
 ): TLiveRobotState | null {
   if (!live || !live.ok || event?.type !== "pose" || !event.pose) return live ?? null;
   const { x, y, theta, mode } = event.pose;
@@ -1264,6 +1278,7 @@ export function mergePose(
     positionAt: Date.now(),
     position: { x, y, theta: finite(theta) ? theta : live.position?.theta ?? 0 },
     ...(plan && finite(plan.x) && finite(plan.y) ? { planPosition: { x: plan.x, y: plan.y } } : {}),
+    ...(typeof event.mapId === "string" && event.mapId ? { mapId: event.mapId } : {}),
     ...(typeof mode === "string" && mode ? { mode } : {}),
   } as TLiveRobotState;
 }
@@ -1410,6 +1425,129 @@ export function capabilityNote(capabilities: Record<string, unknown> | null | un
   return `${label} — no ${list}`;
 }
 
+/** Plain-words facts for one brand + model, from core's manifest (`TFleetRobot.profile`). */
+export type TRobotProfile = {
+  model?: string;
+  modelKnown?: boolean;
+  alarms?: string[];
+  makerApp?: string;
+  makerAppOnly?: string[];
+};
+
+export type TRobotAbilityRow = { label: string; value: string };
+
+const listText = (items: string[]) =>
+  items.length > 1 ? `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}` : items[0] ?? "";
+const firstUp = (t: string) => (t ? t.charAt(0).toUpperCase() + t.slice(1) : t);
+
+/**
+ * "What this robot can do" (owner 2026-09-26): a few short rows in our words,
+ * built only from THIS robot's manifest (brand + model), so two models read
+ * differently. Rows with nothing to say are left out; [] while the robot has
+ * not been read, or when it has no interface (the no-monitoring panel says so).
+ *
+ *  - Does:      what it does when told (only what its maker's API lets us send);
+ *  - Reports:   what it tells us (battery, floor, position, heat, past patrols);
+ *  - Alarms:    the alarm kinds it raises;
+ *  - In <app>:  what only the maker's own app does (so nobody hunts for it here);
+ *  - Not shared yet: the facts (battery, floor, position) its maker does not give us.
+ */
+export function robotAbilities(input: {
+  capabilities?: Record<string, unknown> | null;
+  profile?: TRobotProfile | null;
+  type?: unknown;
+  brand?: unknown;
+} | null | undefined): TRobotAbilityRow[] {
+  const caps = input?.capabilities;
+  if (!caps || typeof caps !== "object" || capabilityLabel(caps) === "No interface") return [];
+  const on = (k: string) => caps[k] === true;
+  const patrols = input?.type === "security" && on("patrolControl");
+  const cleans = input?.type !== "security";
+  const does = [
+    patrols && "patrols its routes (start, stop, resume)",
+    cleans && on("startProcess") && "cleans a whole floor or chosen areas",
+    cleans && on("spotClean") && "cleans spots you pick on the plan",
+    on("pauseResume") && "pauses and resumes",
+    !patrols && on("pauseProcess") && "stops a job",
+    on("navigateToPoint") && "goes to a point you pick",
+    on("relocalize") && "can be told where it is",
+    on("sendToDock") && "returns to its charger",
+    on("liveVideo") && "streams live video",
+    on("manualDrive") && "can be driven by hand",
+  ].filter(Boolean) as string[];
+  const reports = [
+    on("battery") && "battery",
+    on("floorReporting") && "floor",
+    on("readLocation") && "live position",
+    on("thermalCamera") && "heat readings",
+    on("patrolHistory") && (on("thermalCamera") ? "past patrols with photos and temperatures" : "past patrols with photos"),
+  ].filter(Boolean) as string[];
+  const p = input?.profile ?? {};
+  const alarms = (Array.isArray(p.alarms) ? p.alarms : []).filter((a) => typeof a === "string" && a);
+  const makerOnly = (Array.isArray(p.makerAppOnly) ? p.makerAppOnly : []).filter((a) => typeof a === "string" && a);
+  const rows: TRobotAbilityRow[] = [];
+  if (does.length) rows.push({ label: "Does", value: `${firstUp(listText(does))}.` });
+  if (reports.length) rows.push({ label: "Reports", value: `${firstUp(listText(reports))}.` });
+  if (alarms.length) rows.push({ label: "Alarms", value: `${firstUp(listText(alarms))}${on("resolveAlerts") ? " - mark them resolved here." : "."}` });
+  if (makerOnly.length && p.makerApp) rows.push({ label: `In ${p.makerApp}`, value: `${firstUp(listText(makerOnly))}.` });
+  // Facts only: an action it doesn't take is simply absent from "Does", never listed as missing.
+  const missing = [!on("battery") && "battery", !on("floorReporting") && "floor", !on("readLocation") && "live position"].filter(Boolean) as string[];
+  if (missing.length) rows.push({ label: "Not shared yet", value: `${firstUp(listText(missing))}.` });
+  return rows;
+}
+
+/**
+ * The empty schedule for a robot whose maker keeps schedules in its own app:
+ * "Patrol schedules are set in the PadBot app. PadBot doesn't share them with us yet."
+ */
+export function scheduleElsewhereText(type: unknown, brand: unknown, profile?: TRobotProfile | null): string {
+  const what = type === "security" ? "Patrol schedules" : "Cleaning schedules";
+  const name = (typeof brand === "string" && brand.trim()) || "The maker";
+  const app = profile?.makerApp || `${name}'s own app`;
+  return `${what} are set in ${app}. ${name} doesn't share them with us yet.`;
+}
+
+/**
+ * The confirm step for a command (owner 2026-09-26: say what will happen
+ * before it is sent). `point` names the saved point for Go to point / Set position.
+ */
+export function commandConfirm(
+  kind: unknown,
+  input: { type?: unknown; name?: unknown; point?: unknown } = {},
+): { title: string; body: string; action: string } {
+  const who = (typeof input.name === "string" && input.name) || "The robot";
+  const at = typeof input.point === "string" && input.point ? input.point : "";
+  const label = kind === "full" && input.type === "security" ? "Start patrol" : commandLabel(kind);
+  const body: Record<string, string> = {
+    full: input.type === "security" ? `${who} starts walking its default patrol route once.` : `${who} starts cleaning the whole floor it is on.`,
+    area: `${who} starts cleaning the chosen areas.`,
+    return: `${who} stops what it is doing and drives back to its charger.`,
+    pause: `${who} stops where it is and waits. Press Resume to carry on.`,
+    resume: `${who} carries on with the job it paused.`,
+    cancel: `${who} stops the current job and stays where it is. It will not carry on by itself.`,
+    navigate: at ? `${who} drives to ${at}.` : `${who} drives to the point you pick.`,
+    relocalize: at
+      ? `${who} is told it is standing at ${at}. Only do this if it really is there - a wrong position gets it lost.`
+      : `${who} is told where it is standing. Only do this if the position is right.`,
+    "patrol-resume": `${who} carries on with the patrol that was interrupted.`,
+  };
+  return { title: `${label}?`, body: body[String(kind)] ?? `${who}: ${label}.`, action: label };
+}
+
+/** The Brand column: "PadBot S2", "Demo S1 (simulated)", or just "Ounitech" when no model is reported. */
+export function brandModelText(
+  brand: unknown,
+  brands: Array<{ brand?: unknown; displayName?: unknown }> | null | undefined,
+  live?: TLiveRobotState | null,
+): string {
+  const name = brandName(brand, brands);
+  const model = live?.ok ? (live.profile?.model || live.model || "").trim() : "";
+  if (!model) return name;
+  const word = name.split(" ")[0]!.toLowerCase();
+  const simulated = /\(simulated\)/i.test(name) ? " (simulated)" : "";
+  return (model.toLowerCase().startsWith(word) ? model : `${name.replace(/\s*\(.*\)$/, "")} ${model}`) + simulated;
+}
+
 /**
  * The note under the credentials. The handoff says "stored encrypted"; they
  * are not encrypted at rest today (see HERO-PENDING_INTEGRATIONS), so the note

package/utils/robot-maps.ts

@@ -0,0 +1,109 @@
+/**
+ * A robot's OWN maps (PadBot §5.1: one map per floor or area) for the map
+ * selector on robot detail, Go to point / Set position and the building map.
+ * Pure helpers - no Vue, no Node globals.
+ */
+
+export type TRobotMapPoint = { targetPointId: string; name: string; type: string; x: number; y: number };
+
+export type TRobotMapView = {
+  mapId: string;
+  /** "Map 1 (B1)", "Lobby · L3". */
+  label: string;
+  floorNo: number | null;
+  imageUrl: string | null;
+  /** Image size in px - the plan is drawn at this aspect ratio. */
+  width: number | null;
+  height: number | null;
+  mapGroup: string;
+  /** The robot reports it is on this map now. */
+  current: boolean;
+  /** The patrol routes saved on this map, by name. */
+  routeNames: string[];
+  /** Saved points placed on this map's image (0-100 from its top-left). */
+  points: TRobotMapPoint[];
+};
+
+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" };
+
+/**
+ * World metres -> share of the map image from its top-left (ROS map: origin at
+ * the bottom-left pixel, y up) - the same transform the API uses for the
+ * robot's own position, so points and robot line up on each map's image.
+ * Null without a usable frame or outside the image.
+ */
+export function robotMapShare(map: Record<string, any> | null | undefined, wx: unknown, wy: unknown): { x: number; y: number } | null {
+  const w = map?.width, h = map?.height, r = map?.resolution;
+  if (!isNum(w) || !isNum(h) || !isNum(r) || w <= 0 || h <= 0 || r <= 0 || !isNum(wx) || !isNum(wy)) return null;
+  const sx = ((wx - (isNum(map?.originX) ? map.originX : 0)) / r / w) * 100;
+  const sy = 100 - ((wy - (isNum(map?.originY) ? map.originY : 0)) / r / h) * 100;
+  if (sx < 0 || sx > 100 || sy < 0 || sy > 100) return null;
+  return { x: Math.round(sx * 100) / 100, y: Math.round(sy * 100) / 100 };
+}
+
+/**
+ * `/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).
+ */
+export function robotMapViews(
+  items: Array<Record<string, any>> | null | undefined,
+  currentMapId: string | null | undefined,
+  routes: Array<{ name?: string; mapId?: string }> | null | undefined = [],
+): TRobotMapView[] {
+  const list = (Array.isArray(items) ? items : []).filter((m) => typeof m?.mapId === "string" && m.mapId && typeof m?.imageUrl === "string");
+  return list.map((m, i) => {
+    const floorNo = Number.isInteger(m.floor) ? (m.floor as number) : null;
+    const routeNames = (routes ?? []).filter((r) => r?.mapId === m.mapId && r.name).map((r) => String(r.name));
+    const shown = typeof m.mapDisplayName === "string" ? m.mapDisplayName.trim() : "";
+    const hint = floorNo !== null ? levelName(floorNo) : routeNames[0]?.replace(/ \(default\)$/, "") ?? "";
+    const label = shown ? (floorNo !== null ? `${shown} · ${levelName(floorNo)}` : shown) : hint ? `Map ${i + 1} (${hint})` : `Map ${i + 1}`;
+    const points = (Array.isArray(m.targetPoints) ? m.targetPoints : []).flatMap((t: any) => {
+      const at = robotMapShare(m, t?.worldX, t?.worldY);
+      return at && typeof t?.targetPointId === "string" && t.targetPointId
+        ? [{ targetPointId: t.targetPointId, name: String(t.name || "Unnamed point"), type: TYPE_WORDS[t.targetPointType] ?? "Point", ...at }]
+        : [];
+    });
+    return {
+      mapId: m.mapId,
+      label,
+      floorNo,
+      imageUrl: /^https?:\/\//i.test(m.imageUrl) ? m.imageUrl : null,
+      width: isNum(m.width) && m.width > 0 ? m.width : null,
+      height: isNum(m.height) && m.height > 0 ? m.height : null,
+      mapGroup: typeof m.mapGroup === "string" ? m.mapGroup.trim() : "",
+      current: !!currentMapId && m.mapId === currentMapId,
+      routeNames,
+      points,
+    };
+  });
+}
+
+/** The map the selector opens on: where the robot is, else PadBot's default map, else the first. */
+export function robotMapDefault(items: Array<Record<string, any>> | null | undefined, views: TRobotMapView[]): string | null {
+  return views.find((v) => v.current)?.mapId ?? (Array.isArray(items) ? items : []).find((m) => m?.isDefault === true && views.some((v) => v.mapId === m.mapId))?.mapId ?? views[0]?.mapId ?? null;
+}
+
+/**
+ * Whether Go to point may send the robot to a point on `targetMapId`. Same
+ * map: yes. Another map: only inside the same PadBot map group (the robot
+ * travels between those maps by lift / map switch); an unknown current map is
+ * never guessed. Mirrors the API's own check.
+ */
+export function robotMapReach(views: TRobotMapView[], currentMapId: string | null | undefined, targetMapId: string): { ok: boolean; note: string } {
+  if (currentMapId && currentMapId === targetMapId) return { ok: true, note: "" };
+  const from = views.find((v) => v.mapId === currentMapId);
+  const to = views.find((v) => v.mapId === targetMapId);
+  if (from?.mapGroup && from.mapGroup === to?.mapGroup) return { ok: true, note: "The robot will travel to this map on its own (lift or map switch)." };
+  return { ok: false, note: "The robot must be on this map first." };
+}
+
+/** The robot maps with a known floor, per floor, for the building map. */
+export function robotMapsByFloor(views: TRobotMapView[]): Map<number, TRobotMapView[]> {
+  const out = new Map<number, TRobotMapView[]>();
+  for (const v of views) if (v.floorNo !== null) out.set(v.floorNo, [...(out.get(v.floorNo) ?? []), v]);
+  return out;
+}