@7365admin1/layer-common 4.54.0 → 4.55.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.55.0
+
+### Minor Changes
+
+- 6719639: Robot maps: a robot with more than one map (PadBot) now has a map selector on robot detail and the site mini-map, opening on the map the robot is on ("Robot is here"). Each map shows its own image at its real shape, its saved points and its routes. Go to point offers another map's points only when PadBot can take the robot there (same map group), otherwise says "The robot must be on this map first."; Set position lists only the robot's current map. The building map draws a robot's map on its floor when the floor number is known and the floor has no saved plan.
+
+## 4.54.1
+
+### Patch Changes
+
+- 401e0a2: Robot detail: when the robot cannot be read, show the API's plain reason (e.g. "Ounitech rejected the robot list (sign-in) ...") under the title instead of only "Reconnecting". `mergeLiveStates` carries the optional `reason` from `/robots/states`.
+
 ## 4.54.0
 
 ### Minor Changes
@@ -1569,11 +1581,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

@@ -663,6 +663,13 @@
 }
 .hero-plan--detail { max-height: 440px; }
 .hero-plan--pick { cursor: crosshair; }
+/* The robot's own map image under the overlays; the plan takes its aspect ratio. */
+.hero-plan__img { position: absolute; inset: 0; width: 100%; height: 100%; max-width: none; object-fit: fill; pointer-events: none; user-select: none; opacity: 0.85; }
+.hero-mapsel { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-bottom: 6px; }
+.hero-mapsel__here { font-size: 12px; padding: 1px 6px; border: 1px solid var(--hero-accent); color: var(--hero-accent); }
+.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: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); }
@@ -1257,3 +1264,4 @@ div.hero-editor__wp.hero-editor__sel, div.hero-editor__fid.hero-editor__sel { ou
 .hero-drive__pad button:active { background: var(--hero-accent); color: var(--hero-bg); }
 .hero-drive__head { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }
 .hero-pick__group { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin-bottom: 6px; }
+.hero-pick__point:disabled { opacity: 0.45; cursor: not-allowed; }

package/components/Robot/BuildingMap.vue

@@ -116,7 +116,8 @@
             :style="{ transform: `translateZ(${i * FLOOR_GAP_PX}px)`, opacity: f.dim, '--hero-fill': look.fill }"
           >
             <img v-if="f.plan" class="hero-bmap__planimg" :src="f.plan.url" :style="f.plan.style" alt="" aria-hidden="true" draggable="false" />
-            <template v-if="!fleet && !f.plan">
+            <img v-else-if="f.robotMap?.imageUrl" class="hero-bmap__planimg" :src="f.robotMap.imageUrl" style="left: 0; top: 0; width: 100%; height: 100%" alt="" aria-hidden="true" draggable="false" referrerpolicy="no-referrer" />
+            <template v-if="!fleet && !f.plan && !f.robotMap?.imageUrl">
               <span class="hero-bmap__room" style="left: 8%; top: 10%; width: 34%; height: 30%" aria-hidden="true" />
               <span class="hero-bmap__room" style="left: 58%; top: 10%; width: 34%; height: 44%" aria-hidden="true" />
               <span class="hero-bmap__room" style="left: 8%; top: 62%; width: 60%; height: 28%" aria-hidden="true" />
@@ -205,6 +206,7 @@
       <div class="hero-aside__title hero-bmap__asidetitle">Floors · top down</div>
       <div v-for="f in legend" :key="f.floorNo" class="hero-bmap__legendrow">
         <b>{{ floorName(f.floorNo) }}</b>
+        <div v-if="f.robotMaps.length" class="hero-mapsel__hint">Robot map: {{ f.robotMaps.map((m) => m.label + (m.current ? " (robot is here)" : "")).join(", ") }}</div>
         <div class="hero-bmap__chips">
           <button v-for="r in f.robots" :key="r.id" type="button" class="hero-bmap__chip" @click="emit('open', r.id)"><span :class="`hero-tone--${tone(r)}`">{{ r.name }}</span></button>
           <span v-if="!f.robots.length" class="hero-muted">—</span>
@@ -231,6 +233,7 @@ import { floorPlanFor } from "../../utils/robot-floorplan";
 import { floorAspect, floorDoors, placementInWorld, planBoxIn, routeOverlay, viewerLifts } from "../../utils/rmf-editor";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import { openDoorNames } from "../../utils/robot-fleet-core";
+import { robotMapViews, robotMapsByFloor, type TRobotMapView } from "../../utils/robot-maps";
 import {
   brandName,
   floorName,
@@ -304,9 +307,17 @@ const siteLabel = computed(() => props.siteName || names.value.siteName || "This
 const ids = computed(() => rows.value.map((r) => String(r._id)));
 const { states, connected } = useRobotLive(ids, siteStatesFeed());
 const routes = ref<Record<string, TPatrolRouteView[]>>({});
-const { getPatrolRoutes, getRobotBrands } = useRobots();
+const { getPatrolRoutes, getRobotBrands, getRobotMaps } = useRobots();
+/** Each security robot's own maps (PadBot), read once per robot: drawn on their floor when the floor has no saved plan. */
+const robotMaps = ref<Record<string, Array<Record<string, any>>>>({});
 watch(ids, async (list) => {
   if (props.type !== "security") return void (routes.value = {});
+  const missing = list.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(list.map(async (id) => {
     const res = await getPatrolRoutes(id);
@@ -319,7 +330,19 @@ getRobotBrands().then((res: any) => (brands.value = res?.items ?? []), () => und
 
 /* ---- floors, features, robots per floor ---- */
 const shapes = computed<TEditorShape[]>(() => shapesFromMap(map.value));
-const floors = computed(() => buildingFloors(mapFloors(ids.value, states.value), map.value));
+/** The robots' maps with a known floor, per floor (a robot's map is "current" when it reports it). */
+const robotFloorMaps = computed(() => {
+  const all: TRobotMapView[] = [];
+  for (const id of ids.value) {
+    for (const m of robotMapViews(robotMaps.value[id], states.value[id]?.mapId ?? null, routes.value[id] ?? [])) {
+      const i = all.findIndex((x) => x.mapId === m.mapId);
+      if (i < 0) all.push(m);
+      else if (m.current) all[i] = { ...all[i]!, current: true };
+    }
+  }
+  return robotMapsByFloor(all);
+});
+const floors = computed(() => buildingFloors([...new Set([...mapFloors(ids.value, states.value), ...robotFloorMaps.value.keys()])].sort((a, b) => a - b), map.value));
 const focus = ref<number | null>(null);
 watch(floors, (f) => {
   if (focus.value !== null && !f.includes(focus.value)) focus.value = null;
@@ -361,6 +384,9 @@ const floors3d = computed(() =>
     return {
       floorNo,
       plan: floorImage(floorNo),
+      robotMaps: robotFloorMaps.value.get(floorNo) ?? [],
+      // ponytail: one robot map drawn per floor (the one a robot is on, else the first); the rest are listed.
+      robotMap: (robotFloorMaps.value.get(floorNo) ?? []).find((m) => m.current) ?? robotFloorMaps.value.get(floorNo)?.[0] ?? null,
       dim: floorOpacity(cam.value.tilt, focus.value, floorNo),
       shapes: parts.shapes,
       glyphs: parts.glyphs,

package/components/Robot/Detail.vue

@@ -20,6 +20,7 @@
   </div>
 
   <div v-if="error" class="hero-notice" role="alert">{{ error }}</div>
+  <div v-else-if="live && !live.ok && live.reason" class="hero-notice" role="status">Can't read this robot right now: {{ live.reason }}</div>
 
   <div v-if="fault" class="hero-faultbar" role="alert">
     <span class="hero-faultbar__code">{{ fault.code }}</span>
@@ -98,17 +99,29 @@
         <span class="hero-aside__title">{{ planTitle }}</span>
         <span class="hero-aside__hint" style="flex-shrink: 0">{{ planHint }}</span>
       </div>
+      <div v-if="mapViews.length > 1 || (mapViews.length === 1 && !mapViews[0]!.current)" class="hero-mapsel">
+        <select v-model="selectedMapId" class="hero-input hero-select hero-select--sm" aria-label="Robot map">
+          <option v-for="m in mapViews" :key="m.mapId" :value="m.mapId">{{ m.label }}{{ m.current ? " · Robot is here" : "" }}</option>
+        </select>
+        <span v-if="selectedMap?.current" class="hero-mapsel__here">Robot is here</span>
+        <span v-else-if="selectedMap" class="hero-mapsel__hint">{{ hereText }}</span>
+        <span v-if="selectedMap?.routeNames.length" class="hero-mapsel__hint">Routes: {{ selectedMap.routeNames.join(", ") }}</span>
+      </div>
       <RobotLivePlan
         :name="record?.name"
         :status-label="statusLabel"
-        :point="posLive ? point : null"
+        :point="posLive && robotOnShownMap ? point : null"
         :stale="shown?.stale === true"
         :heading="headingDeg(shown)"
         :trail="trail"
         :readout="readout"
         :lost="posLost"
         :route="route"
-        :route-moving="statusMode === 'WORKING'"
+        :routes="selectedMap ? mapRoutes : null"
+        :image="selectedMap?.imageUrl ?? null"
+        :aspect="selectedMap?.width && selectedMap?.height ? selectedMap.width / selectedMap.height : null"
+        :points="selectedMap?.points ?? []"
+        :route-moving="statusMode === 'WORKING' && robotOnShownMap"
         :spot="spot"
         :pick="spotOn"
         :tick-ms="tickMs"
@@ -159,7 +172,16 @@
     <RobotManualDrive v-if="driveOpen" :robot-id="robotId" :name="record?.name" @close="driveOpen = false" />
   </v-dialog>
   <v-dialog v-model="pickOpen" width="520">
-    <RobotPointPicker v-if="pickOpen && pickKind" :kind="pickKind" :groups="pointGroups" :floor-no="live?.floorNo ?? null" @close="pickOpen = false" @pick="onPick" />
+    <RobotPointPicker
+      v-if="pickOpen && pickKind"
+      :kind="pickKind"
+      :groups="pointGroups"
+      :floor-no="live?.floorNo ?? null"
+      :current-map-id="live?.mapId ?? null"
+      :maps="mapViews"
+      @close="pickOpen = false"
+      @pick="onPick"
+    />
   </v-dialog>
 
   <RobotToast v-model="toast" />
@@ -179,6 +201,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 useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import {
   brandName,
@@ -329,12 +352,17 @@ const readout = computed(() => `${positionText(live.value, caps.value, now.value
 const spot = ref<Array<{ x: number; y: number }>>([]);
 const spotOn = computed(() => showSpotClean({ canCommand: props.canCommand, capabilities: caps.value, online: online.value, type: robotType.value }));
 
-const route = computed<TPatrolRouteView | null>(() => patrol.value?.routes?.[0] ?? null);
+const route = computed<TPatrolRouteView | null>(() => (selectedMap.value ? mapRoutes.value[0] ?? null : patrol.value?.routes?.[0] ?? null));
 const floorText = computed(() => facts.value[2]?.value ?? "");
-const planTitle = computed(() => (spotOn.value ? "Spot clean" : route.value ? `Live position · ${route.value.name}` : "Live position"));
+const planTitle = computed(() => {
+  if (spotOn.value) return "Spot clean";
+  if (selectedMap.value && !selectedMap.value.current) return `Map · ${selectedMap.value.label}`;
+  return route.value ? `Live position · ${route.value.name}` : "Live position";
+});
 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) return `${selectedMap.value.points.length} saved points · ${mapRoutes.value.length} routes`;
   if (route.value) return `${route.value.checkpoints.length} checkpoints · ${floorText.value}`;
   return floorText.value;
 });
@@ -365,6 +393,37 @@ async function loadSchedule() {
   }
 }
 
+/* ---- the robot's own maps (PadBot: one per floor / area): a selector, opening where the robot is ---- */
+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);
+watch(mapViews, (views) => {
+  if (!views.some((m) => m.mapId === selectedMapId.value)) selectedMapId.value = robotMapDefault(mapItems.value, views);
+});
+// The robot changes map (lift / map switch): follow it while the robot's map was shown.
+watch(
+  () => live.value?.mapId,
+  (to, from) => {
+    if (to && from && selectedMapId.value === from && mapViews.value.some((m) => m.mapId === to)) selectedMapId.value = to;
+  },
+);
+/** Without robot maps the placeholder plan shows the robot as before; with them, only on its own map. */
+const robotOnShownMap = computed(() => !selectedMap.value || selectedMap.value.current);
+const currentMapLabel = computed(() => mapViews.value.find((m) => m.current)?.label ?? "");
+const hereText = computed(() => (currentMapLabel.value ? `The robot is on ${currentMapLabel.value}` : "The robot has not said which map it is on"));
+/** The routes saved on the map shown (a route without a map id goes with the robot's current map). */
+const mapRoutes = computed(() =>
+  (patrol.value?.routes ?? []).filter((r) => (r.mapId ? r.mapId === selectedMap.value?.mapId : selectedMap.value?.current)),
+);
+async function loadMaps() {
+  if (!record.value || noInterface.value) return;
+  try {
+    mapItems.value = (await getRobotMaps(props.robotId))?.items ?? [];
+  } catch {
+    mapItems.value = [];
+  }
+}
 /* ---- the position stream: only for a brand that reports one ---- */
 function startStream() {
   stream?.stop();
@@ -416,7 +475,8 @@ const pickKind = ref<"navigate" | "relocalize" | null>(null);
 async function send(kind: TRobotCommandKind) {
   if (kind === "navigate" || kind === "relocalize") {
     try {
-      pointGroups.value = savedPointGroups((await getRobotMaps(props.robotId))?.items);
+      mapItems.value = (await getRobotMaps(props.robotId))?.items ?? [];
+      pointGroups.value = savedPointGroups(mapItems.value);
     } catch {
       pointGroups.value = [];
     }
@@ -474,7 +534,7 @@ function onPick(p: TSavedPoint) {
   if (!kind) return;
   const body = pointCommandBody(kind, p, live.value);
   if (!body) {
-    toast.value = "Set position: the robot is not on that floor.";
+    toast.value = "Set position: the robot must be on this map first.";
     return;
   }
   run(kind, body);
@@ -536,6 +596,8 @@ watch(
     record.value = null;
     plans.value = [];
     patrol.value = null;
+    mapItems.value = [];
+    selectedMapId.value = null;
     trail.value = [];
     spot.value = [];
     lastPose.value = null;
@@ -543,11 +605,15 @@ watch(
     streamLost.value = false;
     await loadRecord();
     loadSchedule();
+    loadMaps();
   },
   { immediate: true },
 );
 // The first live reading says whether there is a schedule to ask for (no interface = none).
-watch(noInterface, () => loadSchedule());
+watch(noInterface, () => {
+  loadSchedule();
+  loadMaps();
+});
 getRobotBrands().then(
   (res) => (brands.value = res?.items ?? []),
   () => undefined,

package/components/Robot/FloorPlan.vue

@@ -2,27 +2,45 @@
   <!--
     The floor plan both the mini-map and robot detail draw on: 4:3, 10% grid,
     wall outlines, the red dock, corner brackets and the scan line. A
-    placeholder for the image each robot uploads (README "Assets"). Overlays
+    placeholder for the image each robot uploads (README "Assets"). With
+    `image` (the robot's own map, e.g. PadBot) the plan takes that image's
+    aspect ratio, so 0-100 overlay shares land on the right pixel. Overlays
     (routes, robots, trail, spot points) go in the default slot.
   -->
-  <div ref="root" class="hero-plan" :class="{ 'hero-plan--detail': detail, 'hero-plan--pick': pick }" @click="onClick">
+  <div ref="root" class="hero-plan" :class="{ 'hero-plan--detail': detail, 'hero-plan--pick': pick, 'hero-plan--image': !!image }" :style="frameStyle" @click="onClick">
+    <img v-if="image" class="hero-plan__img" :src="image" alt="" aria-hidden="true" draggable="false" referrerpolicy="no-referrer" />
     <span class="hero-plan__corner hero-plan__corner--tl" aria-hidden="true" />
     <span class="hero-plan__corner hero-plan__corner--tr" aria-hidden="true" />
     <span class="hero-plan__corner hero-plan__corner--bl" aria-hidden="true" />
     <span class="hero-plan__corner hero-plan__corner--br" aria-hidden="true" />
-    <span class="hero-plan__wall" style="left: 8%; top: 10%; width: 34%; height: 30%" aria-hidden="true" />
-    <span class="hero-plan__wall" style="left: 58%; top: 10%; width: 34%; height: 44%" aria-hidden="true" />
-    <span class="hero-plan__wall" style="left: 8%; top: 62%; width: 60%; height: 28%" aria-hidden="true" />
-    <span class="hero-plan__dock" aria-hidden="true"><span v-if="detail" class="hero-plan__dock-label">Dock</span></span>
+    <template v-if="!image">
+      <span class="hero-plan__wall" style="left: 8%; top: 10%; width: 34%; height: 30%" aria-hidden="true" />
+      <span class="hero-plan__wall" style="left: 58%; top: 10%; width: 34%; height: 44%" aria-hidden="true" />
+      <span class="hero-plan__wall" style="left: 8%; top: 62%; width: 60%; height: 28%" aria-hidden="true" />
+      <span class="hero-plan__dock" aria-hidden="true"><span v-if="detail" class="hero-plan__dock-label">Dock</span></span>
+    </template>
     <span class="hero-plan__scan" aria-hidden="true" />
     <slot />
   </div>
 </template>
 
 <script setup lang="ts">
-import { ref } from "vue";
+import { computed, ref } from "vue";
 
-const props = defineProps<{ detail?: boolean; pick?: boolean }>();
+const props = defineProps<{
+  detail?: boolean;
+  pick?: boolean;
+  /** The robot's own map image (http/https); null keeps the placeholder plan. */
+  image?: string | null;
+  /** That image's width / height, so the plan keeps its shape. */
+  aspect?: number | null;
+}>();
+/** The image's own shape; the detail plan's 440 px height cap narrows the width instead of squashing it. */
+const frameStyle = computed(() => {
+  const a = props.image && props.aspect && Number.isFinite(props.aspect) && props.aspect > 0 ? props.aspect : null;
+  if (!a) return undefined;
+  return { aspectRatio: String(a), ...(props.detail ? { width: `min(100%, ${Math.round(440 * a)}px)`, maxHeight: "none", marginInline: "auto" } : {}) };
+});
 const emit = defineEmits<{ pick: [point: { x: number; y: number }] }>();
 const root = ref<HTMLElement | null>(null);
 

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

@@ -70,6 +70,7 @@
         :states="states"
         :type="type"
         :routes="routes"
+        :robot-maps="robotMaps"
         :connected="connected"
         :brands="brands"
         :map="routeMap"
@@ -127,7 +128,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
@@ -235,11 +236,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.0",
+  "version": "4.55.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

@@ -598,11 +598,15 @@ export type TLiveRobotState = {
   ok: boolean;
   /** false = its brand has no interface: nothing to show, ever. */
   monitorable?: boolean;
+  /** When `ok` is false: why, in words (e.g. "Ounitech rejected the robot list (sign-in) (code X: ...)"). */
+  reason?: string;
   online?: boolean;
   mode?: string;
   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;
@@ -654,7 +658,13 @@ export function mergeLiveStates(
       next[item.id] =
         item.monitorable !== false && p?.ok && recent(p.readAt)
           ? { ...p, stale: true }
-          : { id: item.id, ok: false, monitorable: item.monitorable !== false };
+          : {
+              id: item.id,
+              ok: false,
+              monitorable: item.monitorable !== false,
+              // The API's plain reason, so the detail screen says WHY instead of only "Reconnecting".
+              ...(typeof item.reason === "string" && item.reason ? { reason: item.reason.slice(0, 300) } : {}),
+            };
       continue;
     }
     const s = { ...item, ok: true, readAt: now, stale: false } as TLiveRobotState;
@@ -882,6 +892,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);
@@ -1102,6 +1114,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 };
 }
@@ -1244,7 +1258,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;
@@ -1256,6 +1270,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;
 }

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;
+}