@7365admin1/layer-common 4.97.1-staging.567 → 4.97.1-staging.569

package/assets/css/robot-hero.css

@@ -681,6 +681,8 @@
 .hero-plan__safe { fill: rgba(67, 160, 71, 0.18); stroke: #43a047; }
 .hero-plan__slow { fill: rgba(251, 140, 0, 0.18); stroke: #fb8c00; }
 .hero-plan__taught { fill: none; stroke: #1e88e5; stroke-dasharray: 4 3; }
+.hero-plan__pass { fill: rgba(0, 172, 193, 0.14); stroke: #00acc1; stroke-dasharray: 2 2; }
+.hero-plan__track { fill: none; stroke: #8e24aa; stroke-dasharray: 3 2; }
 .hero-rec__obstacles { display: block; max-width: 100%; max-height: 320px; margin-top: 4px; border: 1px solid var(--hero-line, rgba(127, 127, 127, 0.3)); image-rendering: pixelated; }
 .hero-plan__area { position: absolute; transform: translate(-50%, -50%); font-size: 12px; font-weight: 600; padding: 0 4px; white-space: nowrap; pointer-events: none; color: var(--hero-text); background: var(--hero-bg); border: 1px solid var(--hero-accent); }
 .hero-rec { margin-top: 16px; }

package/components/Robot/CleaningRecords.vue

@@ -22,12 +22,22 @@
     <div v-else class="hero-rec__wrap">
       <table class="hero-rec__table">
         <thead>
-          <tr><th>Started</th><th>Area</th><th>Job</th><th>Took</th><th>Cleaned</th><th>Done</th><th>Result</th><th>Started by</th></tr>
+          <tr><th>Started</th><th>Area</th><th>Job</th><th>Took</th><th>Cleaned</th><th>Done</th><th>Result</th><th>Started by</th><th /></tr>
         </thead>
         <tbody>
-          <tr v-for="j in shownJobs" :key="j.key">
-            <td>{{ j.when }}</td><td>{{ j.area }}</td><td>{{ j.job }}</td><td>{{ j.duration }}</td><td>{{ j.size }}</td><td>{{ j.done }}</td><td>{{ j.result }}</td><td>{{ j.by }}</td>
-          </tr>
+          <template v-for="j in shownJobs" :key="j.key">
+            <tr>
+              <td>{{ j.when }}</td><td>{{ j.area }}</td><td>{{ j.job }}<span v-if="j.settings" class="hero-muted"><br />{{ j.settings }}</span></td><td>{{ j.duration }}</td><td>{{ j.size }}</td><td>{{ j.done }}</td><td>{{ j.result }}</td><td>{{ j.by }}</td>
+              <td><v-btn v-if="j.sourceKey" variant="text" size="small" :loading="detailLoading === j.sourceKey" @click="toggleDetail(j.sourceKey)">{{ openDetail === j.sourceKey ? "Hide" : "Detail" }}</v-btn></td>
+            </tr>
+            <tr v-if="openDetail && openDetail === j.sourceKey">
+              <td colspan="9">
+                <div v-if="detailError" class="hero-notice hero-notice--error" role="status">{{ detailError }}</div>
+                <div v-else-if="!detailRows.length" class="hero-sched__empty">{{ makerApp }} sent no floor or area runs for this job.</div>
+                <div v-for="d in detailRows" :key="d.key" class="hero-sched__row"><b>{{ d.where }}</b><span>{{ d.when }} · {{ d.duration }} · {{ d.size }} · {{ d.done }}</span><span>{{ d.result }}</span></div>
+              </td>
+            </tr>
+          </template>
         </tbody>
       </table>
       <v-btn v-if="jobs.length > 5" variant="text" size="small" @click="allJobs = !allJobs">{{ allJobs ? "Show fewer" : `See all ${jobs.length}` }}</v-btn>
@@ -149,10 +159,11 @@ import {
   settingGroups,
   statusLogRows,
   zoneRows,
+  jobDetailRows,
 } from "../../utils/robot-records";
 
 const props = defineProps<{ robotId: string; makerApp: string; brand?: string }>();
-const { getRobotRecords } = useRobots();
+const { getRobotRecords, getRobotJobDetail } = useRobots();
 
 const records = ref<Record<string, any> | null>(null);
 const loading = ref(false);
@@ -186,6 +197,26 @@ watch(
   { immediate: true },
 );
 
+/* One job's floor / area runs, read when asked (one open at a time). */
+const openDetail = ref<string | null>(null);
+const detailLoading = ref<string | null>(null);
+const detail = ref<Record<string, any> | null>(null);
+const detailError = ref("");
+const detailRows = computed(() => jobDetailRows(detail.value));
+async function toggleDetail(source: string) {
+  if (openDetail.value === source) return void (openDetail.value = null);
+  detailLoading.value = source;
+  detailError.value = "";
+  try {
+    detail.value = await getRobotJobDetail(props.robotId, source);
+  } catch (e: any) {
+    detail.value = null;
+    detailError.value = `Couldn't read the job detail: ${robotErrorMessage(e)}`;
+  } finally {
+    detailLoading.value = null;
+    openDetail.value = source;
+  }
+}
 const jobs = computed(() => jobRows(records.value));
 const shownJobs = computed(() => (allJobs.value ? jobs.value : jobs.value.slice(0, 5)));
 const alerts = computed(() => alertHistoryRows(records.value));

package/components/Robot/Detail.vue

@@ -30,8 +30,14 @@
     </div>
   </div>
 
-  <!-- Emergency stop: anyone allowed to command this robot, one tap, no confirm (PadBot today). -->
-  <RobotEmergencyStop v-if="cmdOk && caps?.emergencyStop === true" :robot-id="robotId" :name="record?.name" @stopped="fastUntil = Date.now() + COMMAND_FOLLOW_MS" />
+  <!-- Emergency stop: anyone allowed to command this robot, one tap, no confirm (PadBot, OneWay). OneWay's is a software stop: Release lifts it. -->
+  <RobotEmergencyStop
+    v-if="cmdOk && caps?.emergencyStop === true"
+    :robot-id="robotId"
+    :name="record?.name"
+    :releasable="caps?.emergencyRelease === true && fault?.code === 'E-STOP'"
+    @stopped="fastUntil = Date.now() + COMMAND_FOLLOW_MS"
+  />
 
   <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>
@@ -242,7 +248,16 @@
         class="mb-2"
         @update:model-value="pickRoute"
       />
+      <!-- Documented job options (Ounitech clean mode / power / repeats; PadBot patrol rounds), only where the brand declares them. -->
+      <template v-if="offered.clean">
+        <v-select v-model="jobOpts.modeFlag" :items="CLEAN_MODE_CHOICES" label="Cleaning mode" density="compact" hide-details class="mb-2" />
+        <v-checkbox v-if="jobOpts.modeFlag === 2" v-model="jobOpts.subModeFlag" :true-value="1" :false-value="0" label="Also vacuum while washing" density="compact" hide-details />
+        <v-select v-model="jobOpts.levelFlag" :items="CLEAN_POWER_CHOICES" label="Power" density="compact" hide-details class="mb-2" />
+        <v-select v-model="jobOpts.cleanTimes" :items="CLEAN_TIMES_CHOICES" label="Times to clean" density="compact" hide-details class="mb-2" />
+      </template>
+      <v-select v-if="offered.rounds" v-model="jobOpts.rounds" :items="PATROL_ROUND_CHOICES" label="Rounds" density="compact" hide-details class="mb-2" />
       <div class="hero-dialog__body">{{ confirming.text.body }}</div>
+      <div v-if="optionsLine" class="hero-dialog__body">{{ optionsLine }}</div>
       <div class="hero-dialog__actions">
         <v-btn variant="outlined" @click="confirmOpen = false">Don't send</v-btn>
         <!-- Cancel sends the robot home (core 2026-10-15); this keeps it where it stops. -->
@@ -368,6 +383,15 @@ import {
   type TRobotCommandKind,
   type TSavedPoint,
   type TSavedPointGroup,
+  CLEAN_MODE_CHOICES,
+  CLEAN_POWER_CHOICES,
+  CLEAN_TIMES_CHOICES,
+  JOB_OPTION_DEFAULTS,
+  PATROL_ROUND_CHOICES,
+  jobOptionsLine,
+  jobOptionsOffered,
+  withJobOptions,
+  type TJobOptions,
 } from "../../utils/robot-display";
 
 const props = withDefaults(
@@ -798,10 +822,19 @@ function pickRoute(id: unknown) {
   c.what = /^patrol/i.test(name) ? name : `patrolling ${name}`;
   c.text = commandConfirm("area", { type: "security", name: record.value?.name, route: { name, stops }, map });
 }
+/* Job options on a start: reset each time the confirm opens. */
+const jobOpts = ref<TJobOptions>({ ...JOB_OPTION_DEFAULTS });
+const offered = computed(() => jobOptionsOffered(confirming.value?.kind, robotType.value, caps.value));
+const optionsLine = computed(() => jobOptionsLine(offered.value, jobOpts.value));
+watch(confirmOpen, (open) => {
+  if (open) jobOpts.value = { ...JOB_OPTION_DEFAULTS };
+});
 function confirmSend(stayHere = false) {
   const c = confirming.value;
   confirmOpen.value = false;
-  if (c) run(c.kind, stayHere === true ? { ...c.body, stayHere: true } : c.body, c.what);
+  if (!c) return;
+  const body = withJobOptions(c.body, offered.value, jobOpts.value);
+  run(c.kind, stayHere === true ? { ...body, stayHere: true } : body, c.what);
 }
 
 /** The robot's plan image size for its floor, for turning plan clicks into pixels. */

package/components/Robot/EmergencyStop.vue

@@ -4,12 +4,15 @@
     command this robot. One tap, NO confirm - a stop must never wait on a
     dialog or on a state read. The server sends PadBot's "full machine stop"
     over the live link AND its stop command, and says which reached the robot.
+    OneWay's stop is a software one that stays on: while the robot reports it
+    (`releasable`), Release lifts it - after a confirm, since the robot may move again.
   -->
   <div class="hero-estop" role="group" aria-label="Emergency stop">
     <button type="button" class="hero-estop__btn" :disabled="busy" @click="stop">
       <span class="hero-estop__icon" aria-hidden="true">■</span>
       {{ busy ? "Stopping…" : "Emergency stop" }}
     </button>
+    <v-btn v-if="releasable" variant="outlined" :loading="releasing" :disabled="busy" @click="release">Release emergency stop</v-btn>
     <div v-if="result" class="hero-estop__msg" :class="{ 'hero-estop__msg--error': failed }" role="status" aria-live="assertive">{{ result }}</div>
   </div>
 </template>
@@ -18,11 +21,12 @@
 import { ref } from "vue";
 import { estopResultText } from "../../utils/robot-config";
 
-const props = defineProps<{ robotId: string; name?: string }>();
+const props = defineProps<{ robotId: string; name?: string; releasable?: boolean }>();
 const emit = defineEmits<{ stopped: [] }>();
-const { emergencyStopRobot } = useRobots();
+const { emergencyStopRobot, releaseEmergencyStopRobot } = useRobots();
 
 const busy = ref(false);
+const releasing = ref(false);
 const result = ref("");
 const failed = ref(false);
 
@@ -42,6 +46,23 @@ async function stop() {
     busy.value = false;
   }
 }
+
+async function release() {
+  if (!window.confirm(`Release the emergency stop on ${props.name || "this robot"}? It can take commands and move again.`)) return;
+  releasing.value = true;
+  failed.value = false;
+  result.value = "";
+  try {
+    const r = await releaseEmergencyStopRobot(props.robotId);
+    result.value = r?.message || "Emergency stop released.";
+    emit("stopped");
+  } catch (e: any) {
+    failed.value = true;
+    result.value = e?.data?.message || e?.message || "The release did not reach the robot. The emergency stop is still on.";
+  } finally {
+    releasing.value = false;
+  }
+}
 </script>
 
 <style scoped>

package/components/Robot/Form.vue

@@ -67,7 +67,7 @@
           :id="`${uid}-token`"
           v-model="appToken"
           class="hero-input"
-          type="password"
+          :type="tokenSecret ? 'password' : 'text'"
           autocomplete="new-password"
           spellcheck="false"
           :placeholder="credentialPlaceholder(editing)"
@@ -108,7 +108,14 @@ import {
   type TRobotType,
 } from "../../utils/robot-display";
 import { credentialsNote } from "../../utils/robot-floorplan";
-import { credentialLabels, credentialMissingMessage, discoveredRobotOptions } from "../../utils/robot-credential-form";
+import {
+  credentialDiscoverable,
+  credentialLabels,
+  credentialMissingMessage,
+  credentialTokenDefault,
+  credentialTokenIsSecret,
+  discoveredRobotOptions,
+} from "../../utils/robot-credential-form";
 
 const props = withDefaults(
   defineProps<{
@@ -154,9 +161,17 @@ const robotSn = ref(savedSn);
 const found = ref<Array<{ value: string; label: string; disabled: boolean }>>([]);
 const finding = ref(false);
 const labels = computed(() => credentialLabels(brand.value));
-const typed = computed(() => !!appKey.value.trim() && !!appToken.value.trim());
-// Ounitech / PadBot: one credential pair per company account, so the robot is picked from its list.
-const discoverable = computed(() => brand.value === "ounitech" || brand.value === "padbot");
+// A prefilled server address with no key typed is not a typed pair (Find robots then uses the client's saved one).
+const tokenValue = computed(() => (!appKey.value.trim() && appToken.value.trim() === credentialTokenDefault(brand.value) ? "" : appToken.value.trim()));
+const typed = computed(() => !!appKey.value.trim() && !!tokenValue.value);
+// Ounitech / PadBot / OneWay: one company credential lists its robots, so the robot is picked from that list.
+const discoverable = computed(() => credentialDiscoverable(brand.value));
+// OneWay's second field is its server's address: plain text, prefilled with OneWay's cloud when adding.
+const tokenSecret = computed(() => credentialTokenIsSecret(brand.value));
+watch(brand, (b, was) => {
+  if (editing.value) return;
+  if (!appToken.value.trim() || appToken.value === credentialTokenDefault(was)) appToken.value = credentialTokenDefault(b);
+});
 const findHint = computed(() =>
   editing.value || typed.value
     ? "Press Find robots"
@@ -219,12 +234,12 @@ onMounted(async () => {
 
 async function find() {
   error.value = "";
-  if (!!appKey.value.trim() !== !!appToken.value.trim()) {
+  if (!!appKey.value.trim() !== !!tokenValue.value) {
     return void (error.value = `Enter both the ${labels.value.key} and the ${labels.value.token}.`);
   }
   finding.value = true;
   try {
-    const pair = typed.value ? { appKey: appKey.value.trim(), appToken: appToken.value.trim() } : null;
+    const pair = typed.value ? { appKey: appKey.value.trim(), appToken: tokenValue.value } : null;
     const body = pair
       ? { site: site.value, brand: brand.value, ...pair }
       : editing.value
@@ -247,11 +262,11 @@ async function submit() {
   error.value = "";
   if (!name.value.trim()) return void (error.value = "Give the robot a name.");
   // Adding with no pair typed = reuse this client's saved one; needs the picked robot.
-  const useSaved = !editing.value && discoverable.value && !appKey.value.trim() && !appToken.value.trim();
+  const useSaved = !editing.value && discoverable.value && !appKey.value.trim() && !tokenValue.value;
   if (useSaved && !robotSn.value) {
     return void (error.value = `Enter the ${labels.value.key} and ${labels.value.token}, or press Find robots to use this client's saved ones and pick the robot.`);
   }
-  const creds = useSaved ? ({ ok: true, body: {} } as const) : credentialPatch(appKey.value, appToken.value, editing.value);
+  const creds = useSaved ? ({ ok: true, body: {} } as const) : credentialPatch(appKey.value, tokenValue.value, editing.value);
   if (!creds.ok) return void (error.value = credentialMissingMessage(labels.value, editing.value));
   const serial = robotSn.value && robotSn.value !== savedSn ? { robotSn: robotSn.value } : {};
   saving.value = true;

package/components/Robot/LiftQueue.vue

@@ -41,7 +41,10 @@
       <div v-if="l.gateway || (canEditMap && setupMapId)" class="hero-lift__gw" :data-status="l.gateway?.status ?? 'none'">
         <template v-if="l.gateway">
           <span class="hero-chip" :class="`hero-tone--${l.gateway.tone}`" role="status">{{ l.gateway.text }}</span>
+          <span v-if="l.gateway.fault" class="hero-chip hero-tone--error" role="alert">{{ l.gateway.fault }}</span>
           <span v-if="l.gateway.decoded" class="hero-lift__gwread">{{ l.gateway.decoded }}</span>
+          <span v-if="l.gateway.facts" class="hero-muted hero-lift__gwread">{{ l.gateway.facts }}</span>
+          <span v-if="l.gateway.calls" class="hero-muted hero-lift__gwread">{{ l.gateway.calls }}</span>
           <span v-else-if="l.gateway.undecoded" class="hero-muted hero-lift__gwread">Real lift answering · floor/door not decoded yet (fill [decode] in the gateway settings)</span>
           <span v-if="l.gateway.help" class="hero-muted hero-lift__gwhelp">{{ l.gateway.help }}</span>
           <details v-if="l.gateway.registers.length" class="hero-lift__gwraw">

package/components/Robot/LivePlan.vue

@@ -12,8 +12,8 @@
     <img v-if="image && overlay" class="hero-plan__overlay" :src="overlay" alt="" aria-hidden="true" draggable="false" referrerpolicy="no-referrer" />
     <svg v-if="image && (zones.length || taughtRoute.length > 1)" class="hero-plan__zones" viewBox="0 0 100 100" preserveAspectRatio="none" aria-hidden="true">
       <template v-for="(z, i) in zones" :key="`${z.kind}-${i}`">
-        <polyline v-if="z.kind === 'wall'" class="hero-plan__wall" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polyline>
-        <polygon v-else :class="z.kind === 'safe' ? 'hero-plan__safe' : 'hero-plan__slow'" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polygon>
+        <polyline v-if="z.kind === 'wall' || z.kind === 'track'" :class="z.kind === 'wall' ? 'hero-plan__wall' : 'hero-plan__track'" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polyline>
+        <polygon v-else :class="`hero-plan__${z.kind}`" :points="svgPoints(z.points)"><title>{{ z.name }}</title></polygon>
       </template>
       <polyline v-if="taughtRoute.length > 1" class="hero-plan__taught" :points="svgPoints(taughtRoute)" />
     </svg>
@@ -69,7 +69,7 @@ const props = withDefaults(
     overlay?: string | null;
     areas?: Array<{ name: string; at: { x: number; y: number } | null }>;
     /** Virtual walls / safe zones / slow zones and the taught route on the map shown (0-100 shares). */
-    zones?: Array<{ kind: "wall" | "safe" | "slow"; name: string; points: Array<{ x: number; y: number }> }>;
+    zones?: Array<{ kind: "wall" | "safe" | "slow" | "pass" | "track"; name: string; points: Array<{ x: number; y: number }> }>;
     taughtRoute?: Array<{ x: number; y: number }>;
     /** Saved points on the map shown (0-100 shares). */
     points?: Array<{ targetPointId: string; name: string; x: number; y: number }>;

package/components/Robot/SetupPanel.vue

@@ -134,6 +134,43 @@
           </span>
         </div>
         <v-btn v-if="settings.length" size="small" color="primary" variant="flat" :disabled="busy || !Object.keys(changedSettings).length" @click="ask({ action: 'settings', values: changedSettings })">Save settings</v-btn>
+
+        <div class="hero-section__title">Parts replaced</div>
+        <p class="hero-muted">After a brush, mop, filter or bag is replaced, reset its hours so the wear count starts again.</p>
+        <div v-if="setup.parts?.error" class="hero-notice hero-notice--error">{{ setup.parts.error }}</div>
+        <div v-else-if="!parts.length" class="hero-sched__empty">The robot reports no parts.</div>
+        <div v-for="p in parts" :key="p.code" class="hero-sched__row hero-setup__row">
+          <b>{{ p.part }}</b>
+          <span>{{ p.hours != null ? `${p.hours} h` : "hours not reported" }}{{ p.days != null ? ` · ${p.days} days` : "" }}</span>
+          <span class="hero-setup__actions">
+            <v-btn size="small" variant="outlined" :disabled="busy" @click="ask({ action: 'parts-reset', codes: [p.code] }, { parts: [p.part] })">Part replaced · reset hours</v-btn>
+          </span>
+        </div>
+      </section>
+
+      <!-- Area settings (Ounitech overwrite-area-list): name, path, location mode, edge cleaning -->
+      <section v-if="caps.setupZones === true && areas.length" class="hero-setup__section" aria-label="Area settings">
+        <div class="hero-section__title">Areas on {{ currentMap?.name ?? "this map" }}</div>
+        <p class="hero-muted">How the robot cleans each area. The area shapes themselves are drawn in the Ounitech app.</p>
+        <div v-for="a in areas" :key="a.name" class="hero-setup__form">
+          <input v-model="areaEdits[a.name]!.name" class="hero-input" maxlength="40" :aria-label="`Name of area ${a.name}`" />
+          <label>Path
+            <select v-model.number="areaEdits[a.name]!.pathType" class="hero-input hero-select hero-select--sm">
+              <option v-for="c in AREA_PATH_CHOICES" :key="c.value" :value="c.value">{{ c.title }}</option>
+            </select>
+          </label>
+          <label>Place
+            <select v-model="areaEdits[a.name]!.locationMode" class="hero-input hero-select hero-select--sm">
+              <option v-for="c in AREA_LOCATION_CHOICES" :key="c.value" :value="c.value">{{ c.title }}</option>
+            </select>
+          </label>
+          <label>Edges
+            <select v-model.number="areaEdits[a.name]!.alongWallMode" class="hero-input hero-select hero-select--sm">
+              <option v-for="c in AREA_EDGE_CHOICES" :key="c.value" :value="c.value">{{ c.title }}</option>
+            </select>
+          </label>
+          <v-btn size="small" variant="outlined" :disabled="busy || !areaChange(currentMap?.mapId, a, areaEdits[a.name]!)" @click="ask(areaChange(currentMap?.mapId, a, areaEdits[a.name]!)!)">Save area</v-btn>
+        </div>
       </section>
     </template>
 
@@ -154,7 +191,17 @@
 import { computed, reactive, ref, watch } from "vue";
 import RobotSetupZones from "./SetupZones.vue";
 import RobotSetupPoints from "./SetupPoints.vue";
-import { DAY_CHOICES, daysText, scheduleProblem, settingsDiff, setupConfirmText } from "../../utils/robot-config";
+import {
+  AREA_EDGE_CHOICES,
+  AREA_LOCATION_CHOICES,
+  AREA_PATH_CHOICES,
+  DAY_CHOICES,
+  areaChange,
+  daysText,
+  scheduleProblem,
+  settingsDiff,
+  setupConfirmText,
+} from "../../utils/robot-config";
 
 const props = defineProps<{ robotId: string; name?: string; brand?: string; capabilities?: Record<string, unknown> | null }>();
 const emit = defineEmits<{ changed: [] }>();
@@ -198,8 +245,9 @@ const confirmOpen = ref(false);
 const confirming = ref<{ change: Record<string, any>; text: ReturnType<typeof setupConfirmText> } | null>(null);
 const currentMap = computed(() => (setup.value?.maps ?? []).find((m: any) => m.mapId === (setup.value?.mapId ?? mapId.value)) ?? null);
 
-function ask(change: Record<string, any>, ctx: { map?: string } = {}) {
-  confirming.value = { change, text: setupConfirmText(change, { robot: props.name, map: ctx.map ?? currentMap.value?.name }) };
+function ask(change: Record<string, any>, ctx: { map?: string; parts?: string[] } = {}) {
+  // `parts` is for the sentence only; the server gets the codes.
+  confirming.value = { change, text: setupConfirmText({ ...change, ...(ctx.parts ? { parts: ctx.parts } : {}) }, { robot: props.name, map: ctx.map ?? currentMap.value?.name }) };
   confirmOpen.value = true;
 }
 async function send() {
@@ -266,6 +314,15 @@ watch(setup, (s) => {
   if (!planForm.planId && planForm.floorNo == null) planForm.floorNo = s?.floorNo ?? s?.floors?.[0] ?? null;
 });
 const changedSettings = computed(() => settingsDiff(settings.value, edited));
+
+/* ---- parts replaced, area settings (Ounitech) ---- */
+const parts = computed<any[]>(() => setup.value?.parts?.value ?? []);
+const areas = computed<any[]>(() => (currentMap.value?.areas ?? []).filter((a: any) => a?.name && a.name !== "default"));
+const areaEdits = reactive<Record<string, { name: string; pathType: number | null; locationMode: string | null; alongWallMode: number | null }>>({});
+watch(areas, (list) => {
+  for (const k of Object.keys(areaEdits)) delete areaEdits[k];
+  for (const a of list) areaEdits[a.name] = { name: a.name, pathType: a.pathType ?? null, locationMode: a.locationMode ?? null, alongWallMode: a.alongWallMode ?? null };
+}, { immediate: true });
 </script>
 
 <style>

package/components/Robot/SetupPoints.vue

@@ -18,10 +18,12 @@
         :image="map.imageUrl"
         :aspect="map.width && map.height ? map.width / map.height : null"
         :points="placed"
+        :zones="map.zones ?? []"
         :spot="picked ? [picked] : []"
         :pick="picking !== null"
         @pick="(p) => (picked = p)"
       />
+      <p v-if="map.imageUrl && (map.zones ?? []).length" class="hero-muted">{{ mapLayerLegend({ zones: map.zones, taughtRoute: [] }) }}. Set in the PadBot app; shown here so new points stay out of them.</p>
       <div v-if="picking" class="hero-spotbar" role="group" aria-label="Pick a spot">
         <span>{{ picking === "add" ? "Click the map where the new point goes." : `Click the map where "${moving?.name}" goes.` }}</span>
         <v-btn size="small" color="primary" variant="flat" :disabled="!picked || busy" @click="donePick">Use this spot</v-btn>
@@ -60,6 +62,7 @@
 import { computed, reactive, ref, watch } from "vue";
 import RobotLivePlan from "./LivePlan.vue";
 import type { TShare } from "../../utils/robot-config";
+import { mapLayerLegend } from "../../utils/robot-maps";
 
 const props = defineProps<{ setup: Record<string, any>; busy?: boolean }>();
 const emit = defineEmits<{ apply: [change: Record<string, any>, ctx?: { map?: string }] }>();

package/composables/useRobots.ts

@@ -155,6 +155,11 @@ export default function useRobots() {
     return useNuxtApp().$api<Record<string, any>>(`/api/robots/${id}/records`, { method: "GET", query: { appSlug } });
   }
 
+  /** One past cleaning job's floor / area runs, by the record's `sourceKey` (read-only). */
+  function getRobotJobDetail(id: string, source: string) {
+    return useNuxtApp().$api<{ items?: Array<Record<string, any>> }>(`/api/robots/${id}/records/job`, { method: "GET", query: { appSlug, source } });
+  }
+
   /**
    * Signed image URLs for a map's layers.
    *
@@ -358,6 +363,15 @@ export default function useRobots() {
     );
   }
 
+  /** `emergencyRelease` (OneWay): lift a software emergency stop so the robot takes commands again. */
+  function releaseEmergencyStopRobot(id: string) {
+    return useNuxtApp().$api<{ ok: boolean; message: string }>(`/api/robots/${id}/emergency-stop`, {
+      method: "POST",
+      query: { appSlug },
+      body: { release: true },
+    });
+  }
+
   /** Super Admin setup: what can be changed now, read fresh from the maker's cloud (`mapId` picks the map). */
   function getRobotSetup(id: string, mapId?: string | null) {
     return useNuxtApp().$api<Record<string, any>>(`/api/robots/${id}/setup`, {
@@ -656,6 +670,7 @@ export default function useRobots() {
     saveSiteFleetCore,
     createSiteRelayKey,
     emergencyStopRobot,
+    releaseEmergencyStopRobot,
     getRobotSetup,
     applyRobotSetup,
     listBuildingMaps,
@@ -696,6 +711,7 @@ export default function useRobots() {
     getRobotMaps,
     getRobotMapImages,
     getRobotRecords,
+    getRobotJobDetail,
     getRobotPlans,
     sendRobotCommand,
     getLiveVideo,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.97.1-staging.567",
+  "version": "4.97.1-staging.569",
   "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-building.ts

@@ -1535,6 +1535,29 @@ const MODE_TEXT = ["Mode unknown", "Normal", "Robot mode", "FIRE mode", "Out of
  * one status line, a tone, and the decoded floor/door/motion/mode once the
  * gateway's [decode] settings are filled in. `null` = no gateway: the car is simulated.
  */
+/** The B0S details (`gateway.details`) as the lift card's lines: the fault, then facts, then registered calls. */
+export function liftBoardLines(d: Record<string, any> | null | undefined) {
+  if (!d) return { fault: "", facts: "", calls: "" };
+  const num = (v: unknown) => typeof v === "number" && Number.isFinite(v);
+  const fault = d.fault ? String(d.fault.text || "Lift fault") : "";
+  const facts = [
+    d.detailedMode && d.detailedMode !== d.status ? `Mode: ${d.detailedMode}` : "",
+    d.load ? `Load: ${d.load}` : "",
+    num(d.bottomFloor) && num(d.topFloor) ? `Floors ${d.bottomFloor}-${d.topFloor}` : "",
+    d.boardLink === "Offline" ? "Board has lost the lift controller" : "",
+    num(d.speedMps) && d.speedMps > 0 ? `${d.speedMps} m/s` : "",
+    num(d.runHours) ? `${d.runHours} run hours` : "",
+    num(d.runCount) ? `${Number(d.runCount).toLocaleString("en-GB")} runs` : "",
+  ].filter(Boolean).join(" · ");
+  const list = (a: unknown) => (Array.isArray(a) && a.length ? a.join(", ") : "");
+  const calls = [
+    list(d.carCalls) ? `Car calls: ${list(d.carCalls)}` : "",
+    list(d.hallUp) ? `Hall up: ${list(d.hallUp)}` : "",
+    list(d.hallDown) ? `Hall down: ${list(d.hallDown)}` : "",
+  ].filter(Boolean).join(" · ");
+  return { fault, facts, calls };
+}
+
 export function liftGatewayLine(g: Record<string, any> | null) {
   if (!g) return null;
   const ago = g.ageS == null ? "" : agoText(0, Number(g.ageS) * 1000);
@@ -1558,12 +1581,15 @@ export function liftGatewayLine(g: Record<string, any> | null) {
   };
   const line = byStatus[g.status] ?? byStatus.offline!;
   const st = g.status === "connected" ? g.state : null;
+  // The board's own words (Inovance B0S registers, decoded by the API): a lift in fault says Fault, not Offline.
+  const d = g.status === "connected" && g.details && typeof g.details === "object" ? (g.details as Record<string, any>) : null;
+  const boardMode = d?.status && d.status !== "Normal" ? String(d.status) : "";
   const decoded = st
     ? [
         st.currentFloor ? `Floor ${st.currentFloor}` : "",
         st.doorState != null ? DOOR_TEXT[st.doorState] ?? "" : "",
         st.motionState != null ? MOTION_TEXT[st.motionState] ?? "" : "",
-        st.currentMode != null ? MODE_TEXT[st.currentMode] ?? "" : "",
+        boardMode || (st.currentMode != null ? MODE_TEXT[st.currentMode] ?? "" : ""),
       ].filter(Boolean).join(" · ")
     : "";
   const registers = Object.entries((g.registers ?? {}) as Record<string, number>)
@@ -1574,6 +1600,7 @@ export function liftGatewayLine(g: Record<string, any> | null) {
     status: String(g.status ?? "offline"),
     connected: g.status === "connected",
     decoded,
+    ...liftBoardLines(d),
     // Until the Inovance register list is in the gateway's settings, only raw numbers exist.
     undecoded: g.status === "connected" && !decoded,
     registers,

package/utils/robot-config.ts

@@ -145,11 +145,51 @@ export function setupConfirmText(change: Record<string, any>, ctx: { robot?: str
       return { title: "Change this point?", body: `Patrol routes and buttons that use it go to the new place / name from now on.`, action: "Save point" };
     case "point-delete":
       return { title: "Delete this point?", body: `It is removed from ${robot}'s map. Patrol routes that use it may stop working; check them in the PadBot app.`, action: "Delete point" };
+    case "parts-reset": {
+      const parts = Array.isArray(change.parts) && change.parts.length ? change.parts.join(", ") : "this part";
+      return {
+        title: `Reset the hours of ${parts}?`,
+        body: `Only after the part has been replaced: its hours on ${robot} restart from 0 and the old count can't be brought back.`,
+        action: "Reset hours",
+      };
+    }
+    case "area-settings":
+      return {
+        title: `Change area "${change.areaName}"?`,
+        body: `${robot} cleans area "${change.areaName}" on ${map} with the new settings from its next job${change.name && change.name !== change.areaName ? `, and the area is called "${change.name}" here and in the Ounitech app (schedules keep working; Clean area uses the new name)` : ""}. Every other area is sent back unchanged.`,
+        action: "Save area",
+      };
     default:
       return { title: "Send this change?", body: "", action: "Send" };
   }
 }
 
+/** overwrite-area-list values (Ounitech 2025.10): how the robot covers an area, how it keeps its place, how it cleans the edges. */
+export const AREA_PATH_CHOICES = [
+  { title: "Loop (outside in)", value: 0 },
+  { title: "Zigzag (back and forth)", value: 1 },
+  { title: "Taught route", value: 2 },
+] as const;
+export const AREA_LOCATION_CHOICES = [
+  { title: "Open area", value: "open_area" },
+  { title: "Narrow corridor", value: "narrow_tunnel" },
+  { title: "Factory / warehouse", value: "factory" },
+] as const;
+export const AREA_EDGE_CHOICES = [
+  { title: "Off", value: 0 },
+  { title: "Standard", value: 1 },
+  { title: "Deep", value: 2 },
+] as const;
+
+/** The area change to send: only fields that differ from what the robot has (null when nothing changed). */
+export function areaChange(mapId: unknown, was: Record<string, any>, now: Record<string, any>) {
+  const out: Record<string, unknown> = {};
+  const name = String(now.name ?? "").trim();
+  if (name && name !== was.name) out.name = name;
+  for (const k of ["pathType", "locationMode", "alongWallMode"]) if (now[k] != null && now[k] !== was[k]) out[k] = now[k];
+  return Object.keys(out).length ? { action: "area-settings", mapId, areaName: was.name, ...out } : null;
+}
+
 /** The emergency stop's answer in plain words (never "accepted" when nothing reached the robot). */
 export function estopResultText(r: { live?: boolean; rest?: boolean; message?: string } | null | undefined): string {
   if (!r) return "";

package/utils/robot-credential-form.ts

@@ -14,9 +14,29 @@ export function credentialLabels(brand: unknown): { key: string; token: string }
   // PadBot issues an AccessKey ID + AccessKey Secret per account (API v4.0 §2.1).
   if (brand === "padbot") return { key: "AccessKey ID", token: "AccessKey Secret" };
   if (brand === "demo") return { key: "App key (any value)", token: "Token (any value)" };
+  // OneWay (Anbot RMS): one API key per company; the second field is the RMS server's address.
+  if (brand === "oneway") return { key: "API key", token: "Server address" };
   return { key: "App key", token: "Token" };
 }
 
+/** OneWay's cloud, prefilled in "Server address" when adding (change it only for a company's own RMS). */
+export const ONEWAY_DEFAULT_SERVER = "https://www.anbotcloud.cn";
+
+/** What the second field starts with when adding a robot of this brand ("" = empty). */
+export function credentialTokenDefault(brand: unknown): string {
+  return brand === "oneway" ? ONEWAY_DEFAULT_SERVER : "";
+}
+
+/** False when the second field is not a secret (OneWay's server address): shown as plain text. */
+export function credentialTokenIsSecret(brand: unknown): boolean {
+  return brand !== "oneway";
+}
+
+/** Brands whose one company credential lists its robots, so Add robot picks the serial (Find robots). */
+export function credentialDiscoverable(brand: unknown): boolean {
+  return brand === "ounitech" || brand === "padbot" || brand === "oneway";
+}
+
 /** "Enter the AppID and the Secret ..." - `credentialPatch`'s refusal, in the brand's words. */
 export function credentialMissingMessage(labels: { key: string; token: string }, editing: boolean): string {
   return editing

package/utils/robot-display.ts

@@ -1948,3 +1948,59 @@ export function nameTagSide(
 /** The bigger tags: robot detail's "name + status" (11px 800, 14px from the dot, 26px above) and the building map's name (11px 800). */
 export const DETAIL_TAG = { charW: 7.4, pad: 12, gap: 14, above: 30 };
 export const BUILDING_TAG = { charW: 7.4, pad: 13, gap: 6, above: 0 };
+
+/* ------------------------------------------------ job options (2026-10-19) */
+
+/** Ounitech start-*-cleaning modeFlag / levelFlag, and PadBot §6.2 patrolCount (0 = until stopped). */
+export const CLEAN_MODE_CHOICES = [
+  { title: "Vacuum", value: 1 },
+  { title: "Wash floor", value: 2 },
+  { title: "Dust mop", value: 3 },
+] as const;
+export const CLEAN_POWER_CHOICES = [
+  { title: "Standard", value: 1 },
+  { title: "Strong", value: 2 },
+  { title: "Silent", value: 3 },
+] as const;
+export const CLEAN_TIMES_CHOICES = [1, 2, 3, 4, 5].map((n) => ({ title: n === 1 ? "Once" : `${n} times`, value: n }));
+export const PATROL_ROUND_CHOICES = [
+  ...[1, 2, 3, 5, 10].map((n) => ({ title: n === 1 ? "Once" : `${n} rounds`, value: n })),
+  { title: "Until stopped", value: 0 },
+];
+
+export type TJobOptions = { modeFlag: number; subModeFlag: number; levelFlag: number; cleanTimes: number; rounds: number };
+export const JOB_OPTION_DEFAULTS: TJobOptions = { modeFlag: 1, subModeFlag: 0, levelFlag: 1, cleanTimes: 1, rounds: 1 };
+
+/**
+ * Which job options the confirm offers: clean options for a cleaning robot whose
+ * brand declares `cleanOptions`, rounds for a security robot whose brand declares
+ * `patrolRounds` - only on a start (full / area), never on any other command.
+ */
+export function jobOptionsOffered(kind: unknown, type: unknown, capabilities: Record<string, unknown> | null | undefined) {
+  const start = kind === "full" || kind === "area";
+  return {
+    clean: start && type !== "security" && capabilities?.cleanOptions === true,
+    rounds: start && type === "security" && capabilities?.patrolRounds === true,
+  };
+}
+
+/** The command body with the picked options (only the offered ones; vacuum-while-washing only for wash). */
+export function withJobOptions(body: Record<string, unknown>, offered: { clean: boolean; rounds: boolean }, o: TJobOptions) {
+  if (offered.clean) {
+    return { ...body, modeFlag: o.modeFlag, subModeFlag: o.modeFlag === 2 ? o.subModeFlag : 0, levelFlag: o.levelFlag, cleanTimes: o.cleanTimes };
+  }
+  if (offered.rounds) return { ...body, cleanTimes: o.rounds };
+  return body;
+}
+
+/** One line under the confirm saying what the options mean for this job. */
+export function jobOptionsLine(offered: { clean: boolean; rounds: boolean }, o: TJobOptions): string {
+  if (offered.clean) {
+    const mode = CLEAN_MODE_CHOICES.find((c) => c.value === o.modeFlag)?.title ?? "Vacuum";
+    const power = CLEAN_POWER_CHOICES.find((c) => c.value === o.levelFlag)?.title ?? "Standard";
+    const wet = o.modeFlag === 2 ? (o.subModeFlag === 1 ? ", vacuuming while it washes" : "") + ". Wash mode needs water in the clean-water tank" : "";
+    return `${mode}, ${power.toLowerCase()} power, ${o.cleanTimes === 1 ? "once" : `${o.cleanTimes} times`}${wet}.`;
+  }
+  if (offered.rounds) return o.rounds === 0 ? "It keeps patrolling until someone presses Cancel." : `It patrols the route ${o.rounds === 1 ? "once" : `${o.rounds} times`}.`;
+  return "";
+}

package/utils/robot-maps.ts

@@ -34,13 +34,14 @@ export type TRobotMapView = {
   taughtRoute: Array<{ x: number; y: number }>;
 };
 
-export type TRobotMapZone = { kind: "wall" | "safe" | "slow"; name: string; points: Array<{ x: number; y: number }> };
+export type TRobotMapZone = { kind: "wall" | "safe" | "slow" | "pass" | "track"; name: string; points: Array<{ x: number; y: number }> };
+const ZONE_KINDS: readonly string[] = ["wall", "safe", "slow", "pass", "track"];
 
 const share = (p: any) => isNum(p?.x) && isNum(p?.y) && p.x >= 0 && p.x <= 100 && p.y >= 0 && p.y <= 100;
 function mapZones(list: unknown): TRobotMapZone[] {
   return (Array.isArray(list) ? list : []).flatMap((z: any) => {
     const points = (Array.isArray(z?.points) ? z.points : []).filter(share).map((p: any) => ({ x: p.x, y: p.y }));
-    return (z?.kind === "wall" || z?.kind === "safe" || z?.kind === "slow") && points.length >= 2 ? [{ kind: z.kind, name: String(z.name ?? ""), points }] : [];
+    return ZONE_KINDS.includes(z?.kind) && points.length >= 2 ? [{ kind: z.kind, name: String(z.name ?? ""), points }] : [];
   });
 }
 
@@ -53,6 +54,8 @@ export function mapLayerLegend(view: Pick<TRobotMapView, "zones" | "taughtRoute"
     part(n("wall"), "virtual wall", "virtual walls", "red"),
     part(n("safe"), "safe zone", "safe zones", "green"),
     part(n("slow"), "slow zone", "slow zones", "amber"),
+    part(n("pass"), "passable area", "passable areas", "teal dashes"),
+    part(n("track"), "virtual track", "virtual tracks", "purple dashes"),
     view.taughtRoute.length >= 2 ? "taught route (blue dashes)" : "",
   ].filter(Boolean);
   return parts.length ? `Drawn on the map: ${parts.join(" · ")}` : "";

package/utils/robot-records.ts

@@ -32,7 +32,20 @@ export function whenText(iso: unknown, timeZone?: string): string {
   return `${parts.day} ${MONTHS[Number(parts.month) - 1]}, ${parts.hour}:${parts.minute}`;
 }
 
-export type TJobRow = { key: string; when: string; area: string; job: string; duration: string; size: string; done: string; result: string; by: string };
+export type TJobRow = {
+  key: string; when: string; area: string; job: string; duration: string; size: string; done: string; result: string; by: string;
+  /** The settings it ran with ("Wash floor · strong · 2 times"), "" when not reported. */
+  settings: string;
+  /** The key for its floor / area detail (`/records/job?source=`), null when the brand has none. */
+  sourceKey: string | null;
+};
+
+/** "Wash floor · strong · 2 times · vacuum while washing" from a job's settings (get-source-list). */
+export function jobSettingsText(s: Record<string, any> | null | undefined): string {
+  if (!s || typeof s !== "object") return "";
+  const times = s.repeats === "Until stopped" ? "until stopped" : s.repeats && s.repeats !== "1" ? `${s.repeats} times` : "";
+  return [s.mode, s.power ? `${String(s.power).toLowerCase()} power` : "", times, s.vacuumWhileWashing ? "vacuum while washing" : ""].filter(Boolean).join(" · ");
+}
 
 /** Cleaning jobs, newest first as the API sends them. */
 export function jobRows(records: { tasks?: TPart<Record<string, any>> } | null | undefined, timeZone?: string): TJobRow[] {
@@ -49,7 +62,25 @@ export function jobRows(records: { tasks?: TPart<Record<string, any>> } | null |
       size,
       done: isNum(t.percent) ? `${Math.round(t.percent)}%` : "—",
       result: t.result || "—",
-      by: t.source || "—",
+      by: (t.startedBy ? `${t.startedBy}${t.scheduleId ? ` #${t.scheduleId}` : ""}` : t.source) || "—",
+      settings: jobSettingsText(t.settings),
+      sourceKey: typeof t.sourceKey === "string" && t.sourceKey ? t.sourceKey : null,
+    };
+  });
+}
+
+/** One job's floor / area runs (`/records/job`), in the order the robot did them. */
+export function jobDetailRows(detail: { items?: Array<Record<string, any>> } | null | undefined, timeZone?: string) {
+  return (Array.isArray(detail?.items) ? detail!.items! : []).map((t, i) => {
+    const floor = isNum(t.floorNo) ? (t.floorNo > 0 ? `L${t.floorNo}` : t.floorNo < 0 ? `B${-t.floorNo}` : "G") : "";
+    return {
+      key: `${t.id ?? ""}-${i}`,
+      where: [t.map, floor, isNum(t.areaNo) ? `area ${t.areaNo}` : ""].filter(Boolean).join(" · ") || "—",
+      when: whenText(t.start, timeZone),
+      duration: durationText(t.durationSec),
+      size: isNum(t.areaM2) ? (isNum(t.plannedM2) && t.plannedM2 > 0 ? `${t.areaM2} of ${t.plannedM2} m²` : `${t.areaM2} m²`) : "—",
+      done: isNum(t.percent) ? `${Math.round(t.percent)}%` : "—",
+      result: t.status || t.result || "—",
     };
   });
 }