@7365admin1/core 3.133.1 → 3.135.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/core",
   "license": "MIT",
-  "version": "3.133.1",
+  "version": "3.135.0",
   "author": "7365admin1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/test/e2e/member-site-access.e2e.test.mjs

@@ -13,6 +13,7 @@
 import { after, before, describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { ObjectId } from "mongodb";
+import { readFileSync } from "node:fs";
 
 import { startHarness } from "./harness.mjs";
 
@@ -25,6 +26,9 @@ const U = {
   orgAdmin: "msa-org-admin@e2e.example.com",
   dual: "msa-dual@e2e.example.com",
   resident: "msa-resident@e2e.example.com",
+  tan: "msa-tan@e2e.example.com",
+  stray: "msa-stray@e2e.example.com",
+  pinnedGuard: "msa-pinned-guard@e2e.example.com",
 };
 
 describe("member site access", { concurrency: 1 }, () => {
@@ -69,7 +73,8 @@ describe("member site access", { concurrency: 1 }, () => {
     assert.equal(res.body.sites.length, 3);
     assert.equal(res.body.orgWide.length, 1);
     const a = res.body.sites.find((s) => s.site === String(id.A));
-    assert.deepEqual(a.roles.map((r) => r.name).sort(), ["Cleaner at A", "X at A"]);
+    assert.deepEqual(a.roles.map((r) => r.name).sort(), ["Cleaner at A", "Security (Org)", "X at A"]);
+    assert.deepEqual(a.roles.filter((r) => r.scope === "organisation").map((r) => r.name), ["Security (Org)"], "org console roles are never offered");
   });
 
   it("3. A (role X) + B (role Y), organisation role removed: sees only A and B", async () => {
@@ -146,6 +151,84 @@ describe("member site access", { concurrency: 1 }, () => {
     assert.ok(refused(await save("orgAdmin", [[id.A, id.X]], { removeOrgAccess: true }, id.users.owner)));
     assert.equal((await save("owner", [[id.A, id.X]], {}, id.users.resident)).status, 400);
   });
+
+  // Owner request 2026-09-30: create a role ONCE at organisation level and give it to an
+  // organisation member at the sites picked - reaching those sites only, never org-wide.
+  describe("organisation roles used per site", () => {
+    const readTan = () => h.api(`/members/site-access?org=${id.org}&user=${id.users.tan}`, { sid: sid.tan });
+
+    it("15. before: Tan (organisation level) reaches every site", async () => {
+      assert.deepEqual((await sitesSeen("tan")).sites, sort(id.A, id.B, id.C));
+    });
+
+    it("16. owner gives Tan the organisation role Security (Org) at A and B only: he reaches A and B, nothing else", async () => {
+      const res = await save("owner", [[id.A, id.orgSec], [id.B, id.orgSec]], { removeOrgAccess: true }, id.users.tan);
+      assert.equal(res.status, 200, JSON.stringify(res.body));
+      const rows = await h.db.collection("members").find({ user: id.users.tan, status: { $ne: "deleted" } }).toArray();
+      assert.deepEqual(rows.map((m) => `${m.siteId}:${m.role}:${m.type}`).sort(), [`${id.A}:${id.orgSec}:${SEC}`, `${id.B}:${id.orgSec}:${SEC}`].sort());
+      assert.ok(rows.every((m) => String(m.createdBy) === String(id.users.owner)), "rows are stamped by the owner");
+      assert.deepEqual((await sitesSeen("tan")).sites, sort(id.A, id.B));
+      assert.equal((await invitesAt("tan", id.A)).status, 200, "acts at A");
+      assert.ok(refused(await invitesAt("tan", id.C)), "site C refused");
+    });
+
+    it("17. no organisation scope: Tan (role holds *) cannot open site access for anybody, nor list org-wide invitations", async () => {
+      assert.ok(refused(await readTan()));
+      assert.ok(refused(await view("tan", id.users.dual)));
+      assert.ok(refused(await save("tan", [[id.A, id.orgSec]], {}, id.users.dual)));
+      const orgInvites = await h.api(`/verifications?status=pending&type=member-invite&orgId=${id.org}`, { sid: sid.tan });
+      assert.ok(refused(orgInvites) || (orgInvites.body?.items ?? []).every((v) => String(v.metadata?.siteId ?? "") !== ""), JSON.stringify(orgInvites.body));
+    });
+
+    it("18. the 09-02 rule is untouched: an older pinned row with an organisation role (not placed by anyone) still reaches every site", async () => {
+      assert.deepEqual((await sitesSeen("stray")).sites, sort(id.A, id.B, id.C));
+    });
+
+    it("19. choosing the SAME organisation role in Site access re-stamps that row: then it reaches only its site", async () => {
+      assert.equal((await save("owner", [[id.A, id.orgSec]], {}, id.users.stray)).status, 200);
+      assert.deepEqual((await sitesSeen("stray")).sites, sort(id.A));
+    });
+
+    it("20. an organisation role of another organisation, or the org-console role, is refused for a site", async () => {
+      assert.equal((await save("owner", [[id.A, id.foreignOrgSec]], {}, id.users.tan)).status, 400);
+      assert.equal((await save("owner", [[id.A, id.orgRole]], {}, id.users.tan)).status, 400);
+    });
+
+    it("21. the owner creates an organisation role in the Organization app (full Security catalogue + inventory staff preset); the org list shows only site-less roles and Site access offers it at every site at once", async () => {
+      const catalogue = JSON.parse(readFileSync(new URL("./fixtures/lc-role-catalogues.json", import.meta.url), "utf8"));
+      const permissions = catalogue.security_agency ?? catalogue.catalogues?.security_agency;
+      assert.ok(Array.isArray(permissions) && permissions.includes("inventory:request-stock"), "fixture has the security catalogue");
+      const created = await h.api("/roles", { method: "POST", sid: sid.owner, body: { name: "Guard (Org)", permissions, type: SEC, org: String(id.org) } });
+      assert.equal(created.status, 201, JSON.stringify(created.body));
+      const staff = await h.api("/roles", { method: "POST", sid: sid.owner, body: { name: "Store staff (Org)", permissions: ["inventory:view-inventory", "inventory:request-stock", "inventory:record-usage"], type: SEC, org: String(id.org) } });
+      assert.equal(staff.status, 201, JSON.stringify(staff.body));
+
+      const list = await h.api(`/roles?org=${id.org}&type=${SEC}&scope=organisation&limit=100`, { sid: sid.owner });
+      assert.equal(list.status, 200, JSON.stringify(list.body));
+      assert.deepEqual(list.body.items.map((r) => r.name).sort(), ["Guard (Org)", "Security (Org)", "Store staff (Org)"]);
+      assert.equal((await h.api(`/roles?org=${id.org}&scope=everything`, { sid: sid.owner })).status, 400);
+
+      const box = await h.api(`/members/site-access?org=${id.org}&user=${id.users.tan}`, { sid: sid.owner });
+      for (const site of box.body.sites) {
+        assert.deepEqual(site.roles.filter((r) => r.scope === "organisation").map((r) => r.name).sort(), ["Guard (Org)", "Security (Org)", "Store staff (Org)"], site.name);
+      }
+    });
+
+    it("23. Assign Role (site Members) giving an organisation role to a member pinned to A keeps him at A", async () => {
+      const row = await h.db.collection("members").findOne({ user: id.users.pinnedGuard });
+      const res = await h.api(`/members/id/${row._id}/role/${id.orgSec}/type/${SEC}/org/${id.org}`, { method: "PUT", sid: sid.owner });
+      assert.equal(res.status, 200, JSON.stringify(res.body));
+      assert.equal(String((await h.db.collection("members").findOne({ _id: row._id })).role), String(id.orgSec));
+      assert.deepEqual((await sitesSeen("pinnedGuard")).sites, sort(id.A));
+      assert.ok(refused(await invitesAt("pinnedGuard", id.B)));
+    });
+
+    it("22. a site-confined member cannot create or list the organisation's roles for another organisation", async () => {
+      const res = await h.api("/roles", { method: "POST", sid: sid.tan, body: { name: "Sneaky", permissions: ["*"], type: SEC, org: String(id.other) } });
+      assert.ok(refused(res), JSON.stringify(res.body));
+      assert.ok(refused(await h.api(`/roles?org=${id.other}&scope=organisation`, { sid: sid.tan })));
+    });
+  });
 });
 
 async function seed(h) {
@@ -154,6 +237,7 @@ async function seed(h) {
   const A = new ObjectId(), B = new ObjectId(), C = new ObjectId(), foreign = new ObjectId();
   const W = new ObjectId();
   const X = new ObjectId(), Y = new ObjectId(), Z = new ObjectId(), orgRole = new ObjectId(), ownerRole = new ObjectId(), foreignRole = new ObjectId();
+  const orgSec = new ObjectId(), foreignOrgSec = new ObjectId();
 
   await h.db.collection("organizations").insertMany([
     { _id: org, name: "Aigle MSA", email: "aigle-msa@e2e.example.com", type: "org", nature: SEC, status: "active", createdAt: now },
@@ -171,6 +255,8 @@ async function seed(h) {
     { _id: orgRole, name: "Org Admin", type: "organization", org, site: "", permissions: ["*"], status: "active" },
     { _id: ownerRole, name: "owner", type: "organization", org, site: "", permissions: ["*"], default: true, status: "active" },
     { _id: foreignRole, name: "Foreign", type: SEC, org: other, site: foreign, permissions: ["*"], status: "active" },
+    { _id: orgSec, name: "Security (Org)", type: SEC, org, site: "", permissions: ["*"], status: "active" },
+    { _id: foreignOrgSec, name: "Foreign (Org)", type: SEC, org: other, site: "", permissions: ["*"], status: "active" },
   ]);
   const users = {};
   for (const [k, email] of Object.entries(U)) {
@@ -190,6 +276,9 @@ async function seed(h) {
     { user: users.resident, email: U.resident, org, type: "resident", role: X, siteId: A, status: "active", deletedAt: "", createdAt: now },
     { user: users.kanesan, email: U.kanesan, org, type: "organization", role: orgRole, status: "active", deletedAt: "", createdAt: now },
     { user: users.siteAdmin, email: U.siteAdmin, org, type: SEC, role: X, siteId: A, status: "active", deletedAt: "", createdAt: now },
+    { user: users.tan, email: U.tan, org, type: "organization", role: orgRole, status: "active", deletedAt: "", createdAt: now },
+    { user: users.pinnedGuard, email: U.pinnedGuard, org, type: SEC, role: X, siteId: A, status: "active", deletedAt: "", createdAt: now },
+    { user: users.stray, email: U.stray, org, type: SEC, role: orgSec, siteId: A, status: "active", deletedAt: "", createdAt: now },
   ]);
-  return { org, other, A, B, C, foreign, X, Y, Z, orgRole, foreignRole, users };
+  return { org, other, A, B, C, foreign, X, Y, Z, orgRole, foreignRole, orgSec, foreignOrgSec, users };
 }

package/test/e2e/robot-vendor-errors.e2e.test.mjs

@@ -144,8 +144,9 @@ describe("robot vendor failures are handled answers; diagnose names the step", {
     mode = "ok";
     const ok = await h.api(`/robots/${id.robot}/diagnose`, { sid: staffSid });
     assert.equal(ok.body.failedStep, null, JSON.stringify(ok.body));
-    // credentials, sign-in, get robot, maps, then the 11 read-only 2025.10 calls (all answered).
-    assert.equal(ok.body.steps.length, 15, JSON.stringify(ok.body.steps.map((s) => s.step)));
+    // credentials, sign-in, get robot, maps, then the 16 read-only 2025.10 calls (all answered;
+    // this mock's map has no numeric mapId, so the 4 per-map layer reads are skipped).
+    assert.equal(ok.body.steps.length, 20, JSON.stringify(ok.body.steps.map((s) => s.step)));
     assert.ok(ok.body.steps.every((s) => s.ok), JSON.stringify(ok.body.steps.filter((s) => !s.ok)));
     assert.match(ok.body.steps[2].detail, /model Q3, battery 88%, floor 1/);
     assert.ok(ok.body.clock?.vendorDate, "the vendor's clock is reported");

package/test/ounitech-api-2025-10.test.mjs

@@ -21,6 +21,14 @@ import {
   ounitechTime,
   pngSize,
   clearOunitechCaches,
+  ounitechShapes,
+  ounitechTrack,
+  ounitechStatusLog,
+  ounitechAppAction,
+  ounitechSettings,
+  ounitechObstacleImage,
+  ounitechMapVersion,
+  ounitechFloorMapHistory,
 } from "./.build/services/ounitech.adapter.mjs";
 
 /* --------------------------------------------------------------------------
@@ -121,6 +129,28 @@ const ALERTS = [
   { deviceFlag: 1, errCode: "621 - 右轮驱动器重置( 4)(Resolved)", errMsg: "621 - 右轮驱动器重置( 4)(Resolved)", createTime: "2025-10-20 14:23:45" },
 ];
 
+/* The ten read-only map-layer / log / settings replies, in the document's shapes (2025.10.22 §3083-3688, §6989-7204, §1478). */
+const WALLS = [{ wallId: 216395, wallName: "大门口", pointList: [[-1, -5], [1.5, -2.25], [9, 9]] }, { wallId: 216396, wallName: "", pointList: [[0, 0]] }];
+const SAFE = [{ zoneId: 1, zoneName: "test", pointList: [[0.1, 0.1], [0.5, 0.5], [0.9, 0.1]] }];
+const SLOW = [{ zoneId: 6, zoneName: "", pointList: [[-1, -5], [0, -5], [0, -4]] }];
+const PNG_B64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
+const TEACH = { since: "2025-03-04 11:29:10", offset: "2025-03-04 11:29:10", trackList: [{ x: 1, y: 1, theta: 0, mapid: 1 }, { x: 2, y: -1, theta: 0, mapid: 1 }, { x: 5, y: 5, theta: 0, mapid: 99 }] };
+const VERSIONS = [{ versionId: 11206, versionNo: 1, mapId: 1, latestFlag: true, partitionFileKey: "/z.png", mapFileKey: "", backgroundFileKey: "/b.png", creatorFlag: 0, creatorId: 0, createTime: "2025-05-28 19:06:48" }];
+const FLOOR_MAPS = [
+  { mapId: 2139, mapName: "欧亚学院 2F", sceneId: 94, backgroundFileKey: "/a.png", totalArea: 6106.217, floorNo: 2, latestFlag: true, enableFlag: true, createTime: "2024-08-20 16:26:45", updateTime: "2025-03-12 19:20:16" },
+  { mapId: 2071, mapName: "5楼会议室", sceneId: 94, totalArea: 22.585, floorNo: 2, latestFlag: false, enableFlag: false, createTime: "2024-07-26 14:22:18", updateTime: "2024-07-26 18:37:42" },
+];
+const ROBOT_LOG = [
+  { taskId: 1822883, robotId: 590, robotName: "2A7F25DE96E56", sceneId: 603, sceneName: "2A7F25DE96E56", typeFlag: "9", timeFrom: "2025-10-22 17:48:39", typeName: "充电完成" },
+  { taskId: 1822707, robotId: 590, sceneId: 603, typeFlag: "16", timeFrom: "2025-10-22 17:01:06", typeName: "断点充电中" },
+  { taskId: 1822460, robotId: 590, sceneId: 603, typeFlag: "2", timeFrom: "2025-10-22 15:55:21", typeName: "清洁中" },
+];
+const USER_LOG = [
+  { robotId: 318, actionId: 181630, actionName: "原地停止", createTime: "2025-10-20 14:22:32", userName: "梁家茂", userPhone: "17875645433" },
+  { robotId: 318, actionId: 181629, actionName: "下发清洁", createTime: "2025-10-20 14:22:07", userName: "梁家茂", userPhone: "17875645433" },
+];
+const SETTING = { fanLevel: 0, soundLevel: 80, enablePlanFlag: true, wifiName: "SiteWifi", wifiPwd: "wifi-secret-123", minCleanBatteryPerc: 50, language: "zh", timeZone: 8, clean_speed_mode: "standard", garbage_threshold: 15 };
+
 let server;
 let base;
 const seen = [];
@@ -200,6 +230,26 @@ before(async () => {
           return ok({ liftlist: [{ liftid: 45, liftno: 3701, liftname: "Lift A", floorno: 13, onlineflag: 1, enableflag: true, simno: "868327073829804" }] });
         case ROBOT_CLOUD_PATHS.mapList:
           return ok({ mapList: [{ floorNo: 1 }] });
+        case ROBOT_CLOUD_PATHS.wallList:
+          return ok({ wallList: body.mapId === 1 ? WALLS : [] });
+        case ROBOT_CLOUD_PATHS.safeZoneList:
+          return ok({ safeZoneList: body.mapId === 1 ? SAFE : [] });
+        case ROBOT_CLOUD_PATHS.slowZoneList:
+          return ok({ slowZoneList: body.mapId === 1 ? SLOW : [] });
+        case ROBOT_CLOUD_PATHS.obstacleLayer:
+          return ok({ version: 123123123123, image: PNG_B64 });
+        case ROBOT_CLOUD_PATHS.teachTrack:
+          return ok(TEACH);
+        case ROBOT_CLOUD_PATHS.mapVersions:
+          return ok({ total: 1, versionList: VERSIONS });
+        case ROBOT_CLOUD_PATHS.floorMapHistory:
+          return ok({ total: 2, mapList: FLOOR_MAPS });
+        case ROBOT_CLOUD_PATHS.robotLog:
+          return ok({ total: 342, logList: ROBOT_LOG });
+        case ROBOT_CLOUD_PATHS.userLog:
+          return ok({ actionList: USER_LOG, total: 38 });
+        case ROBOT_CLOUD_PATHS.cleaningSetting:
+          return ok(SETTING);
         default:
           return text(res, 404, "not found");
       }
@@ -267,11 +317,22 @@ test("status 7 costs one extra read, get-robot-state-v2.0 by robotId, to name th
   assert.deepEqual(ounitechFault([]), { code: "error", message: "The robot reports an error" });
 });
 
-test("maps: get-floor-maps by the robot's sceneId, latest only, walls left out", async () => {
+test("maps: get-floor-maps by the robot's sceneId, latest only, raw walls left out (drawn as zones)", async () => {
   clearOunitechCaches();
   seen.length = 0;
   const maps = await adapter().getMaps("F8FCA9A1B1C4C");
-  assert.deepEqual(seen.map((s) => s.path), [ROBOT_CLOUD_PATHS.homeRobotList, ROBOT_CLOUD_PATHS.floorMaps, ROBOT_CLOUD_PATHS.filePreview]);
+  assert.deepEqual(seen.map((s) => s.path), [
+    ROBOT_CLOUD_PATHS.homeRobotList,
+    ROBOT_CLOUD_PATHS.floorMaps,
+    ROBOT_CLOUD_PATHS.filePreview,
+    ROBOT_CLOUD_PATHS.wallList,
+    ROBOT_CLOUD_PATHS.safeZoneList,
+    ROBOT_CLOUD_PATHS.slowZoneList,
+    ROBOT_CLOUD_PATHS.teachTrack,
+  ]);
+  assert.equal(seen[3].body.mapId, 1);
+  assert.equal(seen[6].body.robotId, 424);
+  assert.match(seen[6].body.offset, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
   assert.equal(seen[1].body.sceneId, 438);
   assert.equal(seen[1].body.enableFlag, 1);
   assert.equal(maps.length, 1);
@@ -564,3 +625,80 @@ test("records: 'no station bound (e=59)' means no base station - no error shown"
   const r = await adapter().getRecords("OFFLINE1");
   assert.deepEqual(r.station, { items: [] });
 });
+
+test("map layers: walls, safe and slow zones and the taught route drawn on the robot's map (get-wall/safezone/slowzone-list, get-teach-track)", async () => {
+  clearOunitechCaches();
+  const [m] = await adapter().getMaps("F8FCA9A1B1C4C");
+  // Map: 200 x 100 px, origin (-1, -5), 0.05 m/px. (-1,-5) = bottom-left corner; (1.5,-2.25) = 25 %, 45 %; (9,9) past the edge -> clamped.
+  assert.deepEqual(m.zones[0], { kind: "wall", name: "大门口", points: [{ x: 0, y: 100 }, { x: 25, y: 45 }, { x: 100, y: 0 }] });
+  assert.equal(m.zones.filter((z) => z.kind === "wall").length, 1, "a one-point wall is not drawn");
+  assert.deepEqual(m.zones.find((z) => z.kind === "safe").name, "test");
+  assert.deepEqual(m.zones.find((z) => z.kind === "slow"), { kind: "slow", name: "Slow zone 1", points: [{ x: 0, y: 100 }, { x: 10, y: 100 }, { x: 10, y: 80 }] });
+  // Taught route: only points on this map (mapid 1); (1,1) -> 20 %, (1+5)/0.05=120 px up of 100 -> clamped top; (2,-1) -> 30 %, 20 %.
+  assert.deepEqual(m.taughtRoute, [{ x: 20, y: 0 }, { x: 30, y: 20 }]);
+});
+
+test("records: the ten slow reads - status log, app actions, settings (no Wi-Fi), obstacles, map versions, floor map history, zones", async () => {
+  clearOunitechCaches();
+  seen.length = 0;
+  const a = adapter();
+  const r = await a.getRecords("F8FCA9A1B1C4C");
+  assert.equal(seen.some((x) => COMMAND_PATHS.has(x.path)), false, "never a command");
+  assert.deepEqual(r.statusLog.items.map((x) => x.status), ["Charged", "Charging (mid-job)", "Cleaning"]);
+  assert.equal(r.statusLog.items[0].at, "2025-10-22T09:48:39.000Z");
+  const log = seen.find((x) => x.path === ROBOT_CLOUD_PATHS.robotLog).body;
+  assert.deepEqual([log.robotId, log.sceneId, log.pageSize], ["424", "438", 50], "robot log takes ids as strings (document)");
+  assert.deepEqual(r.appActions.items, [
+    { at: "2025-10-20T06:22:32.000Z", action: "Stopped in place", by: "梁家茂" },
+    { at: "2025-10-20T06:22:07.000Z", action: "Started a cleaning job", by: "梁家茂" },
+  ]);
+  const json = JSON.stringify(r);
+  assert.equal(json.includes("17875645433"), false, "app user's phone number left out");
+  assert.equal(json.includes("wifi-secret-123") || json.includes("SiteWifi"), false, "Wi-Fi name/password never passed on");
+  assert.ok(r.settings.items.some((x) => x.label === "Sound level" && x.value === "80 %"));
+  assert.ok(r.settings.items.some((x) => x.label === "Robot language" && x.value === "Chinese"));
+  assert.ok(r.settings.items.some((x) => x.label === "Robot time zone" && x.value === "UTC+8"));
+  assert.ok(r.settings.items.some((x) => x.group === "Other settings" && x.label === "garbage_threshold"));
+  assert.equal(r.obstacles.items[0].image, `data:image/png;base64,${PNG_B64}`);
+  assert.deepEqual(r.mapVersions.items, [{ version: 1, latest: true, createdAt: "2025-05-28T11:06:48.000Z" }]);
+  assert.equal(seen.find((x) => x.path === ROBOT_CLOUD_PATHS.mapVersions).body.mapId, 1);
+  assert.deepEqual(r.mapHistory.items.map((x) => [x.name, x.areaM2, x.latest, x.inUse]), [["欧亚学院 2F", 6106.2, true, true], ["5楼会议室", 22.6, false, false]]);
+  assert.deepEqual(seen.find((x) => x.path === ROBOT_CLOUD_PATHS.floorMapHistory).body.floorNo, 3);
+  assert.deepEqual(r.mapLayers.items[0].zones.map((z) => z.kind), ["wall", "safe", "slow"]);
+  assert.ok(r.tasks && r.alerts, "the fast records are still there");
+  const calls = seen.length;
+  await a.getRecords("F8FCA9A1B1C4C");
+  assert.equal(seen.length, calls, "both caches serve the second read");
+});
+
+test("the ten reads, pure mapping from the document's replies", () => {
+  assert.deepEqual(ounitechStatusLog({ typeFlag: "15", timeFrom: "2025-10-22 16:58:56", typeName: "断点回充" }), { at: "2025-10-22T08:58:56.000Z", status: "Returning to charge (mid-job)" });
+  assert.equal(ounitechStatusLog({ typeFlag: "77", typeName: "x" }).status, "x");
+  assert.equal(ounitechAppAction({ actionName: "示教路径控制" }).action, "Controlled a taught route");
+  assert.equal(ounitechAppAction({ actionName: "新动作" }).action, "App action: 新动作", "untranslated text is labelled, never bare Chinese");
+  assert.deepEqual(ounitechSettings({ wifiName: "a", wifiPwd: "b", ok: true, msg: null, enableWorkSound: true }), [
+    { key: "enableWorkSound", group: "Sound", label: "Sounds while working", value: "On", attention: false },
+  ]);
+  assert.equal(ounitechObstacleImage({ image: "" }), null);
+  assert.equal(ounitechObstacleImage({ image: "/9j/abc" }).image, "data:image/jpeg;base64,/9j/abc");
+  assert.equal(ounitechObstacleImage({ image: "A".repeat(1_500_001) }).tooLarge, true);
+  assert.deepEqual(ounitechMapVersion({ versionNo: 3, latestFlag: false, createTime: "2025-05-28 19:06:48" }), { version: 3, latest: false, createdAt: "2025-05-28T11:06:48.000Z" });
+  assert.equal(ounitechFloorMapHistory({ mapId: 5 }).name, "Map 5");
+  const frame = { width: 200, height: 100, resolution: 0.05, originX: -1, originY: -5 };
+  assert.deepEqual(ounitechShapes(frame, "safe", [{ zoneName: "", pointList: [[0.1, 0.1], [0.5, 0.5]] }])[0].name, "Safe zone 1");
+  assert.deepEqual(ounitechShapes(null, "wall", WALLS), [], "no frame, nothing drawn");
+  assert.equal(ounitechTrack({ ...frame, mapId: "1" }, Array.from({ length: 2000 }, () => ({ x: 0, y: 0, mapid: 1 }))).length, 500, "long routes thinned to 500 points");
+});
+
+test("diagnose: the ten reads each answered, no Wi-Fi password, no phone number", async () => {
+  clearOunitechCaches();
+  const steps = await adapter().diagnose("F8FCA9A1B1C4C");
+  for (const name of ["virtual walls", "safe zones", "slow zones", "map versions", "floor map history", "obstacle layer", "taught route", "robot status log", "app action log", "robot settings"]) {
+    const st = steps.find((x) => x.step.startsWith(name));
+    assert.ok(st, `step ${name}`);
+    assert.equal(st.code, 0, `${name}: ${st.message}`);
+  }
+  const json = JSON.stringify(steps);
+  assert.equal(json.includes("wifi-secret-123") || json.includes("17875645433"), false);
+  assert.equal(steps.find((x) => x.step.startsWith("obstacle layer")).data.imageChars, PNG_B64.length, "image size only, not the picture");
+});

package/test/robot-vendor-errors.test.mjs

@@ -233,6 +233,13 @@ test("diagnose: every step passes on a healthy account, with the vendor's clock"
     ["power schedule (halt-plan/get)", true],
     ["base station (get-station-detail-state)", true],
     ["lifts (get-lift-list)", true],
+    // This account's map has no numeric mapId, so the per-map layer reads (walls, zones, versions) are skipped.
+    ["floor map history (v2405/get-floor-maplist)", true],
+    ["obstacle layer (get-obstacle-layer)", true],
+    ["taught route (get-teach-track)", true],
+    ["robot status log, last 7 days (get-robot-log-list)", true],
+    ["app action log, last 7 days (get-user-logs)", true],
+    ["robot settings (get-cleaning-setting)", true],
     ["current job (robot list taskState)", true],
   ]);
   assert.equal(seen.slice(from).some((b) => /cleanTimes|areaList|pointList|actionNo/.test(b)), false, "no command body was sent");