@7365admin1/layer-common 4.45.0 → 4.47.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.47.0
+
+### Minor Changes
+
+- cde8389: `getVerifications` takes `origin`; the console Client List's Pending tab lists only invitations Seven365 sent.
+
+## 4.46.0
+
+### Minor Changes
+
+- 4cf067f: Robot building map editor: floor plans per floor (upload / replace / remove, stored privately in the map; Set scale by measuring a known length; Fit), HERO Fleet Core import into the saved map, and downloads of the building file and route maps. The 3D building map draws saved floor plans. Edit map is also offered at HERO Fleet Core sites (it edits the site's saved copy). The Add robot note says "stored encrypted" only when the server reports it.
+
 ## 4.45.0
 
 ### Minor Changes
@@ -1509,11 +1521,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

@@ -1043,6 +1043,12 @@
 }
 .hero-editor__plan:focus-visible { outline: 2px solid var(--hero-accent); outline-offset: 0; }
 .hero-editor__room { position: absolute; border: 2px solid var(--hero-text); opacity: 0.4; pointer-events: none; }
+/* Floor plan image (stored privately in the map) under everything drawn; scale by measurement. */
+.hero-editor__planimg, .hero-bmap__planimg { position: absolute; max-width: none; pointer-events: none; user-select: none; opacity: 0.55; object-fit: fill; }
+.hero-editor__measure { stroke: var(--hero-accent); stroke-width: 2; stroke-dasharray: 4 3; }
+.hero-editor__mpoint { position: absolute; width: 10px; height: 10px; margin: -5px 0 0 -5px; border-radius: 50%; background: var(--hero-accent); pointer-events: none; }
+.hero-editor__measurebox { display: flex; flex-direction: column; gap: 6px; padding: 8px; border: 1px dashed var(--hero-accent); font-size: 12px; }
+.hero-editor__measurein { width: 110px; min-height: 32px; }
 .hero-editor__svg { position: absolute; inset: 0; width: 100%; height: 100%; overflow: visible; pointer-events: none; }
 .hero-editor__wall { stroke: var(--hero-text); stroke-width: 1.5; }
 .hero-editor__zone-shape { fill: color-mix(in srgb, var(--hero-text) 10%, transparent); stroke: var(--hero-text); stroke-width: 1; stroke-dasharray: 4 3; }

package/components/ClientMain.vue

@@ -636,6 +636,8 @@ async function fetchPending() {
   const res = await getVerifications({
     status: 'pending',
     type:   'user-invite',
+    // Only what Seven365 sent - never a client's own invitations (owner, 2026-09-25).
+    origin: 'seven365',
     page:   page.value,
     search: search.value,
     email: search.value,

package/components/Robot/BuildingMap.vue

@@ -18,7 +18,7 @@
       <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true"><path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3" /></svg>
       Full screen
     </v-btn>
-    <v-btn v-if="canEditMap && !fleet" :variant="editing ? 'outlined' : 'flat'" :color="editing ? undefined : 'primary'" @click="editing = !editing">
+    <v-btn v-if="canEditMap" :variant="editing ? 'outlined' : 'flat'" :color="editing ? undefined : 'primary'" @click="editing = !editing">
       {{ editing ? "Exit edit mode" : "Edit map" }}
     </v-btn>
   </div>
@@ -26,12 +26,15 @@
   <div v-if="error" class="hero-notice" role="alert">{{ error }}</div>
   <div v-else-if="!loading && emptyNote" class="hero-notice">{{ emptyNote }}</div>
 
-  <div v-if="fleet" class="hero-notice" role="status">Live building from HERO Fleet Core - doors and lifts update every few seconds. It is managed by the fleet, so it cannot be edited here.</div>
+  <div v-if="fleet && !editing" class="hero-notice" role="status">Live building from HERO Fleet Core - doors and lifts update every few seconds. The fleet manages it; Edit map changes this site's saved copy (floor plans, import, downloads).</div>
+  <div v-else-if="fleet && editing" class="hero-notice" role="status">Editing this site's saved building map. The live HERO Fleet Core view is unchanged until you import.</div>
 
   <RobotMapEditor
-    v-if="editing && canEditMap && !fleet"
+    v-if="editing && canEditMap"
     ref="editor"
-    :map="map"
+    :map="saved"
+    :site="site"
+    :fleet-site="fleet"
     :floors="floors"
     :site-name="siteLabel"
     :owner-robot-id="ownerRobotId"
@@ -107,7 +110,8 @@
             class="hero-bmap__floor"
             :style="{ transform: `translateZ(${i * FLOOR_GAP_PX}px)`, opacity: f.dim, '--hero-fill': look.fill }"
           >
-            <template v-if="!fleet">
+            <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">
               <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" />
@@ -201,6 +205,8 @@ import { computed, onBeforeUnmount, ref, toRef, watch } from "vue";
 import RobotMapEditor from "./MapEditor.vue";
 import RobotReconnecting from "./Reconnecting.vue";
 import useRobotBuilding from "../../composables/useRobotBuilding";
+import useFloorPlanImages from "../../composables/useFloorPlanImages";
+import { floorPlanFor, planBox } from "../../utils/robot-floorplan";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
 import { openDoorNames } from "../../utils/robot-fleet-core";
 import {
@@ -264,7 +270,7 @@ const emit = defineEmits<{
   status: [status: { connected: boolean; faults: number; siteName: string; clientName: string }];
 }>();
 
-const { rows, map, fleet, names, loading, error, reload } = useRobotBuilding(
+const { rows, map, saved, fleet, names, loading, error, reload } = useRobotBuilding(
   toRef(props, "organization"),
   toRef(props, "site"),
   toRef(props, "type"),
@@ -307,9 +313,19 @@ const floorRoutes = (floorNo: number) => {
   }
   return [...seen.values()];
 };
+/** Each floor's saved plan image (kept privately in the map), drawn under the shapes. */
+const { urls: planUrls } = useFloorPlanImages(saved);
+function floorImage(floorNo: number) {
+  const p = floorPlanFor(saved.value, floorNo);
+  const url = planUrls.value[floorNo];
+  if (!p || !url) return null;
+  const b = planBox(p);
+  return { url, style: { left: `${b.left}%`, top: `${b.top}%`, width: `${b.width}%`, height: `${b.height}%` } };
+}
 const floors3d = computed(() =>
   floors.value.map((floorNo) => ({
     floorNo,
+    plan: floorImage(floorNo),
     dim: floorOpacity(cam.value.tilt, focus.value, floorNo),
     shapes: shapes.value.filter((s) => s.kind !== "lift" && s.floorNo === floorNo),
     routes: props.type === "security" ? floorRoutes(floorNo) : [],
@@ -388,11 +404,11 @@ function fullscreen(el?: HTMLElement | null) {
   else el?.requestFullscreen?.();
 }
 const editing = ref(false);
-watch([() => props.canEditMap, fleet], ([can, isFleet]) => {
-  if (!can || isFleet) editing.value = false;
+watch(() => props.canEditMap, (can) => {
+  if (!can) editing.value = false;
 });
 /** The robot a first save is attached to (maps are stored per robot): one of this site's. */
-const ownerRobotId = computed(() => String(map.value?.robotId ?? rows.value[0]?._id ?? ""));
+const ownerRobotId = computed(() => String(saved.value?.robotId ?? rows.value[0]?._id ?? ""));
 function onSaved() {
   reload();
 }

package/components/Robot/Form.vue

@@ -72,7 +72,7 @@
         />
       </div>
     </div>
-    <div class="hero-dialog__note">{{ CREDENTIALS_NOTE }} Capability: {{ note }}</div>
+    <div class="hero-dialog__note">{{ credentialsNote(credentialsEncrypted) }} Capability: {{ note }}</div>
     <div v-if="error" class="hero-notice hero-notice--error" role="alert">{{ error }}</div>
     <div class="hero-dialog__actions">
       <v-btn variant="outlined" :disabled="saving" @click="emit('cancel')">Cancel</v-btn>
@@ -88,11 +88,11 @@ import {
   capabilityNote,
   credentialPatch,
   credentialPlaceholder,
-  CREDENTIALS_NOTE,
   robotErrorMessage,
   typeLabel,
   type TRobotType,
 } from "../../utils/robot-display";
+import { credentialsNote } from "../../utils/robot-floorplan";
 
 const props = withDefaults(
   defineProps<{
@@ -137,6 +137,8 @@ const saving = ref(false);
 const error = ref("");
 
 const brands = ref<Array<Record<string, any>>>([]);
+/** The server says it stores credentials encrypted; only then does the note say so. */
+const credentialsEncrypted = ref(false);
 const loadingBrands = ref(false);
 const options = computed(() => {
   const list = brandOptions(brands.value, type.value);
@@ -172,7 +174,9 @@ function onClient() {
 onMounted(async () => {
   loadingBrands.value = true;
   try {
-    brands.value = (await getRobotBrands())?.items ?? [];
+    const res = await getRobotBrands();
+    brands.value = res?.items ?? [];
+    credentialsEncrypted.value = res?.credentialsEncrypted === true;
   } catch {
     brands.value = [];
   } finally {

package/components/Robot/MapEditor.vue

@@ -11,6 +11,10 @@
     selects, Delete removes, Esc clears, Ctrl/Cmd+Z undo, Ctrl/Cmd+Shift+Z or
     Ctrl+Y redo. Every drag is one undo step. Save checks in plain words
     first, then writes the building map through the API (versioned).
+    Floor plan (per floor): upload / replace / remove an image kept privately
+    in the map, Set scale by measuring a known length, Fit. Building file:
+    import the HERO Fleet Core building, download the building file or a
+    route map.
   -->
   <div ref="root" class="hero-editor" :class="{ 'hero-editor--fs': isFs }">
     <div class="hero-editor__bar">
@@ -59,9 +63,12 @@
         @keydown="onKey"
         @blur="keyboard = false"
       >
-        <span class="hero-editor__room" style="left: 8%; top: 10%; width: 34%; height: 30%" aria-hidden="true" />
-        <span class="hero-editor__room" style="left: 58%; top: 10%; width: 34%; height: 44%" aria-hidden="true" />
-        <span class="hero-editor__room" style="left: 8%; top: 62%; width: 60%; height: 28%" aria-hidden="true" />
+        <img v-if="floorPlan && planUrl" class="hero-editor__planimg" :src="planUrl" :style="planImgStyle" alt="" aria-hidden="true" draggable="false" />
+        <template v-else-if="!floorPlan">
+          <span class="hero-editor__room" style="left: 8%; top: 10%; width: 34%; height: 30%" aria-hidden="true" />
+          <span class="hero-editor__room" style="left: 58%; top: 10%; width: 34%; height: 44%" aria-hidden="true" />
+          <span class="hero-editor__room" style="left: 8%; top: 62%; width: 60%; height: 28%" aria-hidden="true" />
+        </template>
         <svg class="hero-editor__svg" viewBox="0 0 100 100" preserveAspectRatio="none" aria-hidden="true">
           <template v-for="s in visible" :key="s.id">
             <polygon v-if="s.kind === 'zone'" class="hero-editor__zone-shape" :class="{ 'hero-editor__sel': isSel(s.id) }" :points="pts(s.points)" vector-effect="non-scaling-stroke" />
@@ -72,7 +79,9 @@
             </template>
           </template>
           <line v-if="rotateLine" class="hero-editor__rotline" :x1="rotateLine.x1" :y1="rotateLine.y1" :x2="rotateLine.x2" :y2="rotateLine.y2" vector-effect="non-scaling-stroke" />
+          <line v-if="measure.a && measure.b" class="hero-editor__measure" :x1="measure.a.x" :y1="measure.a.y" :x2="measure.b.x" :y2="measure.b.y" vector-effect="non-scaling-stroke" />
         </svg>
+        <span v-for="(m, i) in [measure.a, measure.b].filter(Boolean)" :key="`m${i}`" class="hero-editor__mpoint" :style="{ left: `${m!.x}%`, top: `${m!.y}%` }" aria-hidden="true" />
         <template v-for="s in visible" :key="`l-${s.id}`">
           <div v-if="s.kind === 'zone'" class="hero-editor__label" :style="boxStyle(s)" :title="shapeTitle(s)">{{ s.name || "Unnamed zone" }}</div>
           <div v-else-if="s.kind === 'lift'" class="hero-editor__lift" :class="{ 'hero-editor__sel': isSel(s.id) }" :style="boxStyle(s)" :title="shapeTitle(s)">Lift</div>
@@ -102,6 +111,35 @@
           <span>{{ shapeTitle(s) }}</span><span class="hero-editor__pos">{{ shapeAnchor(s).x }}, {{ shapeAnchor(s).y }}</span>
         </button>
         <div v-if="!visible.length" class="hero-muted">Nothing drawn yet. Pick a tool and click the plan.</div>
+
+        <div class="hero-aside__title hero-editor__asidetitle">Floor plan · {{ floorName(floor) }}</div>
+        <div class="hero-editor__actions">
+          <button type="button" class="hero-editor__act" :disabled="planLocked" :title="planLockText" @click="pickPlan">{{ planBusy ? "Saving…" : floorPlan ? "Replace plan" : "Upload plan" }}</button>
+          <template v-if="floorPlan">
+            <button type="button" class="hero-editor__act" :disabled="planLocked" :title="planLockText" :aria-pressed="measuring" @click="startMeasure">Set scale</button>
+            <button type="button" class="hero-editor__act" :disabled="planLocked" :title="planLockText" @click="fitPlanNow">Fit</button>
+            <button type="button" class="hero-editor__act hero-editor__act--del" :disabled="planLocked" :title="planLockText" @click="removePlanNow">Remove plan</button>
+          </template>
+        </div>
+        <input ref="planInput" type="file" accept="image/png,image/jpeg,image/webp" hidden @change="onPlanFile" />
+        <div v-if="planLockText && !planBusy" class="hero-muted">{{ planLockText }}</div>
+        <div v-if="floorPlan" class="hero-muted">{{ scaleText(floorPlan) }}</div>
+        <div v-if="measuring" class="hero-editor__measurebox" role="group" aria-label="Set scale">
+          <span>{{ measure.b ? "Real length between the two points, in metres:" : measure.a ? "Click the other end." : "Click one end of a length you know on the plan (a wall, a doorway)." }}</span>
+          <div class="hero-editor__actions">
+            <input v-if="measure.b" v-model.number="measureM" type="number" min="0.01" step="0.01" class="hero-input hero-editor__measurein" aria-label="Real length in metres" placeholder="e.g. 12.5" @keydown.enter.prevent="applyMeasure" />
+            <button v-if="measure.b" type="button" class="hero-editor__act" @click="applyMeasure">Apply</button>
+            <button type="button" class="hero-editor__act" @click="cancelMeasure">Cancel</button>
+          </div>
+        </div>
+
+        <div class="hero-aside__title hero-editor__asidetitle">Building file · HERO Fleet Core</div>
+        <div v-if="map?.rmf" class="hero-muted">{{ rmfLine(map.rmf) }}</div>
+        <div class="hero-editor__actions">
+          <button v-if="fleetSite" type="button" class="hero-editor__act" :disabled="planBusy || saving || state.dirty" :title="state.dirty ? 'Save your drawing first.' : ''" @click="importFleet">Import from HERO Fleet Core</button>
+          <button type="button" class="hero-editor__act" :disabled="!map?._id" @click="download('building')">Download building file</button>
+          <button v-for="g in graphs" :key="`g${g}`" type="button" class="hero-editor__act" @click="download('nav', g)">Download route map{{ graphs.length > 1 ? ` ${g}` : "" }}</button>
+        </div>
         <div class="hero-editor__note">The plan image comes from the robot; everything here is drawn on top of it. Keyboard: Tab to the plan; arrow keys move the cursor (or nudge what is selected, Shift for 1 m); Enter places or selects; Delete removes; Esc clears the selection.</div>
       </aside>
     </div>
@@ -111,6 +149,23 @@
 <script setup lang="ts">
 import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
 import { floorName, MAP_TOOLS } from "../../utils/robot-display";
+import useFloorPlanImages from "../../composables/useFloorPlanImages";
+import {
+  compressSize,
+  exportFileName,
+  fitPlan,
+  fleetImportBody,
+  floorPlanFileProblem,
+  floorPlanFor,
+  FLOOR_PLAN_MAX_BYTES,
+  planBox,
+  replacePlacement,
+  rescaleByMeasure,
+  rmfGraphs,
+  rmfLine,
+  scaleText,
+  type TPlanPoint,
+} from "../../utils/robot-floorplan";
 import {
   DEFAULT_GRID_M,
   doorSwing,
@@ -155,11 +210,15 @@ const props = withDefaults(
     ownerRobotId?: string;
     /** The floor to open on. */
     startFloor?: number | null;
+    /** The site, for the HERO Fleet Core import. */
+    site?: string;
+    /** The site has HERO Fleet Core robots: offer "Import from HERO Fleet Core". */
+    fleetSite?: boolean;
   }>(),
-  { map: null, siteName: "", ownerRobotId: "", startFloor: null },
+  { map: null, siteName: "", ownerRobotId: "", startFloor: null, site: "", fleetSite: false },
 );
 const emit = defineEmits<{ saved: [] }>();
-const { createBuildingMap, updateBuildingMap } = useRobots();
+const { createBuildingMap, updateBuildingMap, saveFloorPlan, removeFloorPlan, exportBuildingMap, getFleetCoreBuildingData } = useRobots();
 
 const state = ref<TEditorState>(emptyEditor(shapesFromMap(props.map)));
 const dispatch = (a: TEditorAction) => (state.value = editorReduce(state.value, a));
@@ -240,6 +299,8 @@ function onPlanDown(e: PointerEvent) {
   plan.value?.focus({ preventScroll: true });
   keyboard.value = false;
   const p = at(e);
+  // Set scale: the two clicks are the measured length, not drawing.
+  if (measuring.value) return void measureClick(p);
   const target = hitShape(visible.value, p, tolerance(e.pointerType));
   const t = tool.value;
   if (t === "delete") {
@@ -464,6 +525,182 @@ async function save() {
   }
 }
 
+/* ---- floor plan: stored in the map (not the public file store), per floor ---- */
+const { urls: planUrls } = useFloorPlanImages(computed(() => props.map));
+const floorPlan = computed(() => floorPlanFor(props.map, floor.value));
+// (`plan` is the plan ELEMENT, for pointer maths; this floor's image record is `floorPlan`.)
+const planUrl = computed(() => planUrls.value[floor.value] ?? "");
+const planImgStyle = computed(() => {
+  const b = planBox(floorPlan.value!);
+  return { left: `${b.left}%`, top: `${b.top}%`, width: `${b.width}%`, height: `${b.height}%` };
+});
+const planBusy = ref(false);
+const planLockText = computed(() =>
+  !props.map?._id ? "Save the map once, then add a floor plan." : state.value.dirty ? "Save your drawing first, then change the floor plan." : "",
+);
+const planLocked = computed(() => planBusy.value || saving.value || Boolean(planLockText.value));
+const planInput = ref<HTMLInputElement | null>(null);
+const note = (text: string, ok = false) => dispatch({ type: "notice", text, ok });
+const errText = (e: any, fallback: string) => e?.data?.message || e?.message || fallback;
+
+function pickPlan() {
+  if (!planLocked.value) planInput.value?.click();
+}
+
+const blobToDataUrl = (b: Blob) =>
+  new Promise<string>((ok, no) => {
+    const r = new FileReader();
+    r.onload = () => ok(String(r.result));
+    r.onerror = () => no(r.error);
+    r.readAsDataURL(b);
+  });
+
+/** Shrink in the browser until it fits the 1 MB the server keeps: WebP (JPEG where WebP cannot be written), then smaller. */
+async function compressPlan(file: File) {
+  const bmp = await createImageBitmap(file);
+  let { width, height } = compressSize(bmp.width, bmp.height);
+  const canvas = document.createElement("canvas");
+  try {
+    for (let attempt = 0; attempt < 8; attempt++) {
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext("2d")!;
+      ctx.fillStyle = "#fff";
+      ctx.fillRect(0, 0, width, height);
+      ctx.drawImage(bmp, 0, 0, width, height);
+      for (const q of [0.85, 0.7, 0.55]) {
+        let out = await new Promise<Blob | null>((r) => canvas.toBlob(r, "image/webp", q));
+        if (out?.type !== "image/webp") out = await new Promise<Blob | null>((r) => canvas.toBlob(r, "image/jpeg", q));
+        if (out && out.size <= FLOOR_PLAN_MAX_BYTES) return { image: await blobToDataUrl(out), widthPx: width, heightPx: height };
+      }
+      width = Math.max(1, Math.round(width * 0.8));
+      height = Math.max(1, Math.round(height * 0.8));
+    }
+  } finally {
+    bmp.close?.();
+  }
+  throw new Error("This floor plan cannot be made small enough. Try a simpler or smaller image.");
+}
+
+async function onPlanFile(e: Event) {
+  const input = e.target as HTMLInputElement;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file || !props.map?._id) return;
+  const problem = floorPlanFileProblem(file);
+  if (problem) return void note(problem);
+  planBusy.value = true;
+  try {
+    const img = await compressPlan(file);
+    await saveFloorPlan(String(props.map._id), floor.value, {
+      version: Number(props.map.version) || 1,
+      ...img,
+      ...replacePlacement(floorPlan.value, img.widthPx, img.heightPx),
+    });
+    note(`Floor plan saved for ${floorName(floor.value)}. Use Set scale to measure a known length.`, true);
+    emit("saved");
+  } catch (err) {
+    note(errText(err, "Could not save the floor plan."));
+  } finally {
+    planBusy.value = false;
+  }
+}
+
+async function placePlan(next: { metersPerPixel: number; tx: number; ty: number }, done: string) {
+  const p = floorPlan.value;
+  if (!p || !props.map?._id) return;
+  planBusy.value = true;
+  try {
+    await saveFloorPlan(String(props.map._id), floor.value, { version: Number(props.map.version) || 1, widthPx: p.widthPx, heightPx: p.heightPx, ...next });
+    note(done, true);
+    emit("saved");
+  } catch (err) {
+    note(errText(err, "Could not save the floor plan scale."));
+  } finally {
+    planBusy.value = false;
+  }
+}
+
+const fitPlanNow = () => floorPlan.value && placePlan(fitPlan(floorPlan.value.widthPx, floorPlan.value.heightPx), "Floor plan fitted to the drawing area.");
+
+async function removePlanNow() {
+  if (!props.map?._id || !floorPlan.value) return;
+  if (!window.confirm(`Remove the floor plan of ${floorName(floor.value)}? Walls, doors and zones stay.`)) return;
+  planBusy.value = true;
+  try {
+    await removeFloorPlan(String(props.map._id), floor.value, Number(props.map.version) || 1);
+    note(`Floor plan removed from ${floorName(floor.value)}.`, true);
+    emit("saved");
+  } catch (err) {
+    note(errText(err, "Could not remove the floor plan."));
+  } finally {
+    planBusy.value = false;
+  }
+}
+
+/* ---- Set scale: two clicks on a known length, then its real length ---- */
+const measuring = ref(false);
+const measure = ref<{ a: TPlanPoint | null; b: TPlanPoint | null }>({ a: null, b: null });
+const measureM = ref<number | null>(null);
+function startMeasure() {
+  measuring.value = !measuring.value;
+  measure.value = { a: null, b: null };
+  measureM.value = null;
+}
+function measureClick(p: TPlanPoint) {
+  measure.value = !measure.value.a || measure.value.b ? { a: p, b: null } : { ...measure.value, b: p };
+}
+function cancelMeasure() {
+  measuring.value = false;
+  measure.value = { a: null, b: null };
+}
+async function applyMeasure() {
+  const { a, b } = measure.value;
+  if (!a || !b || !floorPlan.value) return;
+  const r = rescaleByMeasure(floorPlan.value, a, b, Number(measureM.value));
+  if ("error" in r) return void note(r.error);
+  cancelMeasure();
+  await placePlan(r.plan, `Scale set: ${scaleText(r.plan)}.`);
+}
+watch(floor, cancelMeasure);
+
+/* ---- building file: HERO Fleet Core import, downloads ---- */
+const graphs = computed(() => rmfGraphs(props.map?.rmf));
+
+async function importFleet() {
+  if (!props.site) return;
+  if (props.map?._id && !window.confirm("Replace this building's walls, doors, lifts and routes with the HERO Fleet Core building? Floor plans stay.")) return;
+  if (!props.map?._id && !props.ownerRobotId) return void note("Can't import yet: this site has no robot to keep the map with.");
+  planBusy.value = true;
+  try {
+    const res = await getFleetCoreBuildingData(props.site);
+    const body = fleetImportBody(props.map, res?.rmf ?? {}, props.siteName);
+    if (props.map?._id) await updateBuildingMap(String(props.map._id), { ...body, version: Number(props.map.version) || 1 });
+    else await createBuildingMap({ ...body, robotId: props.ownerRobotId });
+    note(`Imported from HERO Fleet Core: ${rmfLine(res?.rmf)}.`, true);
+    emit("saved");
+  } catch (err) {
+    note(errText(err, "Could not import the HERO Fleet Core building."));
+  } finally {
+    planBusy.value = false;
+  }
+}
+
+async function download(format: "building" | "nav", graph = 0) {
+  if (!props.map?._id) return;
+  try {
+    const blob = await exportBuildingMap(String(props.map._id), format, format === "nav" ? graph : undefined);
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = exportFileName(String(props.map.name ?? ""), format, graph);
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+  } catch (err) {
+    note(errText(err, "Could not download the file."));
+  }
+}
+
 /* ---- drawing helpers + full screen ---- */
 const pts = (list: Array<{ x: number; y: number }>) => list.map((p) => `${p.x},${p.y}`).join(" ");
 function boxStyle(s: TEditorShape) {

package/composables/useFloorPlanImages.ts

@@ -0,0 +1,52 @@
+import { onBeforeUnmount, ref, watch, type Ref } from "vue";
+
+/**
+ * The floor-plan images of one building map, as object URLs by floor.
+ *
+ * The images sit behind the session (stored in the map record, not the public
+ * file store), so each is fetched with the session header and shown from a
+ * local object URL. A plan is fetched again only when its `updatedAt` changes;
+ * old URLs are released.
+ */
+export default function useFloorPlanImages(map: Ref<Record<string, any> | null | undefined>) {
+  const { getFloorPlanImage } = useRobots();
+  const urls = ref<Record<number, string>>({});
+  const keys = new Map<number, string>();
+
+  function release(floorNo: number) {
+    const u = urls.value[floorNo];
+    if (u) URL.revokeObjectURL(u);
+    const next = { ...urls.value };
+    delete next[floorNo];
+    urls.value = next;
+    keys.delete(floorNo);
+  }
+
+  watch(
+    () => [map.value?._id, (map.value?.floorPlans ?? []).map((p: any) => `${p.floorNo}:${p.updatedAt}`).join("|")],
+    async () => {
+      const id = map.value?._id ? String(map.value._id) : "";
+      const plans: Array<Record<string, any>> = id ? map.value?.floorPlans ?? [] : [];
+      const wanted = new Map(plans.map((p) => [Number(p.floorNo), `${id}:${p.updatedAt}`]));
+      for (const f of [...keys.keys()]) if (wanted.get(f) !== keys.get(f)) release(f);
+      await Promise.all(
+        [...wanted].map(async ([floorNo, key]) => {
+          if (keys.get(floorNo) === key) return;
+          keys.set(floorNo, key);
+          try {
+            const blob = await getFloorPlanImage(id, floorNo);
+            if (keys.get(floorNo) !== key) return;
+            urls.value = { ...urls.value, [floorNo]: URL.createObjectURL(blob) };
+          } catch {
+            // No image drawn for that floor; the next change of the map tries again.
+            keys.delete(floorNo);
+          }
+        }),
+      );
+    },
+    { immediate: true },
+  );
+
+  onBeforeUnmount(() => [...keys.keys()].forEach(release));
+  return { urls };
+}

package/composables/useRobotBuilding.ts

@@ -24,6 +24,12 @@ export default function useRobotBuilding(
   /** Every robot at the site this app may see, both types where the app shows both. */
   const all = ref<Array<Record<string, any>>>([]);
   const map = ref<Record<string, any> | null>(null);
+  /**
+   * The site's SAVED map - what the editor edits (drawn walls, floor plans, an
+   * imported HERO Fleet Core building). At a fleet site `map` is the live fleet
+   * building instead, and this is the stored copy beside it.
+   */
+  const saved = ref<Record<string, any> | null>(null);
   const names = ref({ siteName: "", clientName: "" });
   const loading = ref(true);
   const error = ref("");
@@ -31,13 +37,17 @@ export default function useRobotBuilding(
   /** The robots of the type on screen (scope isolation: the other type is never drawn). */
   const rows = computed(() => all.value.filter((r) => r.type === type.value));
 
-  async function loadMap() {
+  async function loadSaved() {
+    const newest = (await listSiteBuildingMaps(site.value, { limit: 1 }))?.items?.[0];
+    return newest ? await getBuildingMap(String(newest._id)) : null;
+  }
+
+  async function loadMap(stored: Record<string, any> | null) {
     if (hasFleetRobots(all.value)) {
       const building = await getFleetCoreBuilding(site.value).catch(() => null);
       if (building) return building;
     }
-    const newest = (await listSiteBuildingMaps(site.value, { limit: 1 }))?.items?.[0];
-    return newest ? await getBuildingMap(String(newest._id)) : null;
+    return stored;
   }
 
   /** Live doors and lifts of the fleet building; a failed refresh keeps the last reading. */
@@ -63,13 +73,16 @@ export default function useRobotBuilding(
       if (mine !== run) return;
       all.value = fleet?.items ?? [];
       names.value = { siteName: summary?.site?.name ?? "", clientName: summary?.client?.name ?? "" };
-      const found = await loadMap();
+      const stored = await loadSaved();
+      const found = await loadMap(stored);
       if (mine !== run) return;
+      saved.value = stored;
       map.value = found;
     } catch (e: any) {
       if (mine !== run) return;
       all.value = [];
       map.value = null;
+      saved.value = null;
       error.value = e?.data?.message || "Could not load this building.";
     } finally {
       if (mine === run) loading.value = false;
@@ -78,5 +91,5 @@ export default function useRobotBuilding(
 
   watch([organization, site], load, { immediate: true });
 
-  return { all, rows, map, fleet, names, loading, error, reload: load };
+  return { all, rows, map, saved, fleet, names, loading, error, reload: load };
 }

package/composables/useRobots.ts

@@ -364,6 +364,57 @@ export default function useRobots() {
     });
   }
 
+  /**
+   * The HERO Fleet Core building in stored form (lanes, waypoints, door types,
+   * lift cabin doors) for the editor's import. Nothing is saved until the
+   * editor saves it.
+   */
+  function getFleetCoreBuildingData(site: string) {
+    return useNuxtApp().$api<Record<string, any>>("/api/robots/fleet-core/building", {
+      method: "GET",
+      query: { site, appSlug, format: "rmf" },
+    });
+  }
+
+  /** The map as a building file or one route graph, as a Blob to download. */
+  function exportBuildingMap(mapId: string, format: "building" | "nav", graph?: number) {
+    return useNuxtApp().$api<Blob>(`/api/robots/building-maps/${mapId}/export`, {
+      method: "GET",
+      query: { format, graph, appSlug },
+      responseType: "blob",
+    });
+  }
+
+  /**
+   * One floor's plan image. A Blob, not a URL: the image sits behind the
+   * session like the map itself, and an <img src> cannot carry the header.
+   */
+  function getFloorPlanImage(mapId: string, floorNo: number) {
+    return useNuxtApp().$api<Blob>(`/api/robots/building-maps/${mapId}/floor-plans/${floorNo}`, {
+      method: "GET",
+      responseType: "blob",
+    });
+  }
+
+  /** Add / replace (with `image`) or re-scale (without) one floor's plan. Versioned like a map save. */
+  function saveFloorPlan(
+    mapId: string,
+    floorNo: number,
+    body: { version: number; image?: string; widthPx: number; heightPx: number; metersPerPixel: number; tx: number; ty: number },
+  ) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/robots/building-maps/${mapId}/floor-plans/${floorNo}`, {
+      method: "PUT",
+      body,
+    });
+  }
+
+  function removeFloorPlan(mapId: string, floorNo: number, version: number) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/robots/building-maps/${mapId}/floor-plans/${floorNo}`, {
+      method: "DELETE",
+      query: { version },
+    });
+  }
+
   function deleteBuildingMap(mapId: string) {
     return useNuxtApp().$api<Record<string, any>>(`/api/robots/building-maps/${mapId}`, {
       method: "DELETE",
@@ -414,6 +465,11 @@ export default function useRobots() {
     createBuildingMap,
     updateBuildingMap,
     deleteBuildingMap,
+    getFleetCoreBuildingData,
+    exportBuildingMap,
+    getFloorPlanImage,
+    saveFloorPlan,
+    removeFloorPlan,
     getLiftQueue,
     requestLift,
     releaseLiftSession,

package/composables/useVerification.ts

@@ -9,6 +9,8 @@ export default function useVerification() {
     siteId = "",
     orgId = "",
     limit = 20,
+    // "seven365": only the invitations Seven365 sent (the console's lists).
+    origin = "",
   } = {}): Promise<{
     items: TMiniVerification[];
     pages: number;
@@ -16,7 +18,11 @@ export default function useVerification() {
   }> {
     return useNuxtApp().$api("/api/verifications", {
       method: "GET",
-      query: { status, search, page, type, email, app, siteId, orgId, limit },
+      query: {
+        status, search, page, type, email, app, siteId, orgId, limit,
+        // Sent only when asked for: an older API refuses a key it does not know.
+        ...(origin && { origin }),
+      },
     });
   }
 

package/package.json

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

@@ -0,0 +1,132 @@
+/**
+ * Floor plans and HERO Fleet Core building files in the map editor - the pure
+ * rules (placement, scale by measurement, import body, file names). The
+ * components only draw what these return.
+ *
+ * A floor plan is an image stored privately in the building map (never the
+ * public file store) and placed in the HERO plan frame (40 x 26 m, the same
+ * frame every drawn wall, door and lift uses): its top-left corner at
+ * (`tx`, `ty`) metres, `metersPerPixel` from a measured distance.
+ */
+
+/** The HERO plan frame - `utils/robot-building.ts` PLAN_W_M / PLAN_H_M (decision 30). */
+export const FRAME_W_M = 40;
+export const FRAME_H_M = 26;
+/** What the API stores per image, after compression here. */
+export const FLOOR_PLAN_MAX_BYTES = 1_000_000;
+/** Longest side the browser compresses a plan to. */
+export const FLOOR_PLAN_MAX_PX = 2400;
+export const FLOOR_PLAN_TYPES = ["image/png", "image/jpeg", "image/webp"];
+
+export type TFloorPlan = { floorNo: number; widthPx: number; heightPx: number; metersPerPixel: number; tx: number; ty: number; updatedAt?: string };
+export type TPlanPoint = { x: number; y: number };
+
+const r6 = (v: number) => Math.round(v * 1e6) / 1e6;
+
+export const floorPlanFor = (map: Record<string, any> | null | undefined, floorNo: number): TFloorPlan | null =>
+  ((map?.floorPlans ?? []) as TFloorPlan[]).find((p) => p.floorNo === floorNo) ?? null;
+
+/** A new plan fitted inside the frame, top-left aligned, aspect kept. */
+export function fitPlan(widthPx: number, heightPx: number): Pick<TFloorPlan, "metersPerPixel" | "tx" | "ty"> {
+  return { metersPerPixel: r6(Math.min(FRAME_W_M / widthPx, FRAME_H_M / heightPx)), tx: 0, ty: 0 };
+}
+
+/**
+ * A replacement image keeps the building's real size and place: same width in
+ * metres, same corner. (A re-drawn plan of the same floor should not need
+ * measuring again.)
+ */
+export function replacePlacement(old: TFloorPlan | null, widthPx: number, heightPx: number) {
+  if (!old) return fitPlan(widthPx, heightPx);
+  return { metersPerPixel: r6((old.widthPx * old.metersPerPixel) / widthPx), tx: old.tx, ty: old.ty };
+}
+
+/** Where the image sits over the plan, as percentages of the frame (the editor draws everything in %). */
+export function planBox(p: Pick<TFloorPlan, "widthPx" | "heightPx" | "metersPerPixel" | "tx" | "ty">) {
+  return {
+    left: (p.tx / FRAME_W_M) * 100,
+    top: (p.ty / FRAME_H_M) * 100,
+    width: ((p.widthPx * p.metersPerPixel) / FRAME_W_M) * 100,
+    height: ((p.heightPx * p.metersPerPixel) / FRAME_H_M) * 100,
+  };
+}
+
+/** Metres between two points given in plan percentages. */
+export function planDistanceM(a: TPlanPoint, b: TPlanPoint) {
+  return Math.hypot(((b.x - a.x) / 100) * FRAME_W_M, ((b.y - a.y) / 100) * FRAME_H_M);
+}
+
+/**
+ * Scale by measurement: two points the person clicked on the plan (in plan %)
+ * and the real distance between them. The image grows or shrinks about its
+ * top-left corner. Null (with a reason) when it cannot be done.
+ */
+export function rescaleByMeasure(p: TFloorPlan, a: TPlanPoint, b: TPlanPoint, realM: number): { plan: TFloorPlan } | { error: string } {
+  const drawn = planDistanceM(a, b);
+  if (!(realM > 0) || !Number.isFinite(realM)) return { error: "Enter the real distance in metres (more than 0)." };
+  if (drawn < 0.05) return { error: "Pick two points further apart." };
+  const metersPerPixel = r6(p.metersPerPixel * (realM / drawn));
+  if (metersPerPixel < 0.0001 || metersPerPixel > 10) return { error: "That distance gives an impossible scale. Check the two points and the number." };
+  return { plan: { ...p, metersPerPixel } };
+}
+
+/** "1 px = 4.2 cm · plan 33.6 x 25.2 m" */
+export function scaleText(p: TFloorPlan | null) {
+  if (!p) return "";
+  const cm = p.metersPerPixel * 100;
+  const w = p.widthPx * p.metersPerPixel;
+  const h = p.heightPx * p.metersPerPixel;
+  const big = w > FRAME_W_M + 0.05 || h > FRAME_H_M + 0.05;
+  return `1 px = ${cm >= 10 ? cm.toFixed(0) : cm.toFixed(1)} cm · plan ${w.toFixed(1)} × ${h.toFixed(1)} m${big ? " (larger than the 40 × 26 m drawing area - the edge is cut off)" : ""}`;
+}
+
+/** Plain-language reason a picked file cannot be used, or null. */
+export function floorPlanFileProblem(file: { type: string; size: number }) {
+  if (!FLOOR_PLAN_TYPES.includes(file.type)) return "Choose a PNG, JPEG or WebP image of the floor plan.";
+  if (file.size > 40_000_000) return "That image is too large to open (40 MB at most).";
+  return null;
+}
+
+/** The size to compress to: longest side at most FLOOR_PLAN_MAX_PX, never upscaled. */
+export function compressSize(widthPx: number, heightPx: number, maxPx = FLOOR_PLAN_MAX_PX) {
+  const s = Math.min(1, maxPx / Math.max(widthPx, heightPx));
+  return { width: Math.max(1, Math.round(widthPx * s)), height: Math.max(1, Math.round(heightPx * s)) };
+}
+
+/**
+ * The save body for an import from HERO Fleet Core: the fleet's building is the
+ * truth (`rmf`) and the server derives the drawn walls, doors and lifts from
+ * it. Floor plans and the map's name stay.
+ */
+export function fleetImportBody(map: Record<string, any> | null | undefined, rmf: Record<string, any>, siteName = "") {
+  return { name: String(map?.name || `${siteName || "Site"} building`).slice(0, 60), levels: [], doors: [], lifts: [], rmf };
+}
+
+/** "Tower B" -> "tower-b.building.yaml" / "tower-b-nav-0.yaml" - the names the API sends too. */
+export function exportFileName(name: string, format: "building" | "nav", graph = 0) {
+  const slug = (name || "building").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "building";
+  return format === "building" ? `${slug}.building.yaml` : `${slug}-nav-${graph}.yaml`;
+}
+
+/** "3 floors · 42 lanes · 18 named points · 19 doors · 2 lifts" for a stored rmf part. */
+export function rmfLine(rmf: Record<string, any> | null | undefined) {
+  if (!rmf?.levels) return "";
+  const levels = rmf.levels as Array<Record<string, any>>;
+  const n = (f: (l: Record<string, any>) => number) => levels.reduce((s, l) => s + f(l), 0);
+  const parts = [
+    `${levels.length} floor${levels.length === 1 ? "" : "s"}`,
+    `${n((l) => l.lanes?.length ?? 0)} lanes`,
+    `${n((l) => (l.vertices ?? []).filter((v: any) => v.name).length)} named points`,
+    `${n((l) => l.doors?.length ?? 0)} doors`,
+    `${rmf.lifts?.length ?? 0} lifts`,
+  ];
+  return parts.join(" · ");
+}
+
+/** The route graphs a download can offer. */
+export const rmfGraphs = (rmf: Record<string, any> | null | undefined): number[] =>
+  ((rmf?.graphs ?? []) as Array<{ idx: number }>).map((g) => g.idx).sort((a, b) => a - b);
+
+/** The Add robot dialog's credentials note - it says "encrypted" only when this server really encrypts. */
+export const credentialsNote = (encrypted: boolean) =>
+  encrypted ? "Credentials are stored encrypted and never shown again after saving." : "Credentials are never shown again after saving.";