@7365admin1/core 3.84.0 → 3.86.0

package/dist/index.mjs

@@ -19668,8 +19668,8 @@ function useDahuaService() {
         }
       }
     }
-    async function handleBuffer(chunk, onDetected2) {
-      partialBuffer = Buffer.concat([partialBuffer, chunk]);
+    async function handleBuffer(chunk2, onDetected2) {
+      partialBuffer = Buffer.concat([partialBuffer, chunk2]);
       while (true) {
         const boundaryIndex = partialBuffer.indexOf(Buffer.from(boundary));
         if (boundaryIndex === -1)
@@ -19920,12 +19920,12 @@ function useDahuaService() {
             resolve("aborted");
           };
           signal.addEventListener("abort", onAbort, { once: true });
-          response.res.on("data", (chunk) => {
+          response.res.on("data", (chunk2) => {
             if (signal.aborted) {
               response.res.destroy();
               return;
             }
-            bufferQueue.enqueue(chunk);
+            bufferQueue.enqueue(chunk2);
           });
           response.res.on("end", () => {
             signal.removeEventListener("abort", onAbort);
@@ -22529,10 +22529,10 @@ function buildAdapter(params) {
       return;
     let buffered = "";
     const decoder = new TextDecoder();
-    for await (const chunk of body) {
+    for await (const chunk2 of body) {
       if (params2.signal.aborted)
         return;
-      buffered += decoder.decode(chunk, { stream: true });
+      buffered += decoder.decode(chunk2, { stream: true });
       let at2 = buffered.indexOf(marker);
       while (at2 >= 0) {
         const next = buffered.indexOf(marker, at2 + marker.length);
@@ -22844,16 +22844,16 @@ function useCameraViewService() {
         () => finish(new Error("camera-timeout")),
         CAMERA_RTSP_TIMEOUT_MS
       );
-      child.stdout.on("data", (chunk) => {
-        bytes += chunk.length;
+      child.stdout.on("data", (chunk2) => {
+        bytes += chunk2.length;
         if (bytes > CAMERA_SNAPSHOT_MAX_BYTES) {
           finish(new Error("camera-picture-too-large"));
           return;
         }
-        chunks.push(chunk);
+        chunks.push(chunk2);
       });
-      child.stderr?.on("data", (chunk) => {
-        const text2 = carry + chunk.toString("latin1");
+      child.stderr?.on("data", (chunk2) => {
+        const text2 = carry + chunk2.toString("latin1");
         if (/401\s*unauthorized|\bunauthorized\b/i.test(text2))
           rejected = true;
         carry = text2.slice(-32);
@@ -32276,8 +32276,8 @@ function useOccurrenceBookRepo() {
       const chunkSize = 500;
       let totalInserted = 0;
       for (let i = 0; i < payloads.length; i += chunkSize) {
-        const chunk = payloads.slice(i, i + chunkSize);
-        const operations = chunk.map((item) => ({
+        const chunk2 = payloads.slice(i, i + chunkSize);
+        const operations = chunk2.map((item) => ({
           insertOne: {
             document: {
               ...item,
@@ -51702,9 +51702,9 @@ function useVisitorTransactionService() {
           expectedCheckIn
         } = value;
         for (let i = 0; i < value.members.length; i += chunkSize) {
-          const chunk = value.members.slice(i, i + chunkSize);
+          const chunk2 = value.members.slice(i, i + chunkSize);
           await Promise.all(
-            chunk.map(async (member) => {
+            chunk2.map(async (member) => {
               const clonedMember = structuredClone(member);
               const { visitorPass, passKeys, nric: nric2, name: name2, contact: contact2 } = clonedMember;
               if (/^(guest|walk-in|contractor|delivery)$/.test(type2 ?? "invalid") && site2) {
@@ -51946,9 +51946,9 @@ function useVisitorTransactionService() {
           unitName
         } = value;
         for (let i = 0; i < value.members.length; i += chunkSize) {
-          const chunk = value.members.slice(i, i + chunkSize);
+          const chunk2 = value.members.slice(i, i + chunkSize);
           await Promise.all(
-            chunk.map(async (member) => {
+            chunk2.map(async (member) => {
               const clonedMember = structuredClone(member);
               const { visitorPass, passKeys, nric: nric2, name: name2, contact: contact2 } = clonedMember;
               if (/^(guest|walk-in|contractor|delivery)$/.test(type2 ?? "invalid") && site2) {
@@ -56409,8 +56409,8 @@ function useAccessManagementSvc() {
     return new Promise((resolve, reject) => {
       const fileStream = Readable.from(bufferFile);
       let fileBuffer = Buffer.alloc(0);
-      fileStream.on("data", (chunk) => {
-        fileBuffer = Buffer.concat([fileBuffer, chunk]);
+      fileStream.on("data", (chunk2) => {
+        fileBuffer = Buffer.concat([fileBuffer, chunk2]);
       });
       fileStream.on("end", () => {
         try {
@@ -59266,10 +59266,10 @@ function parseRobotCommand(body) {
 function createSseParser() {
   let buffer = "";
   let dataLines = [];
-  function push(chunk) {
-    if (!chunk)
+  function push(chunk2) {
+    if (!chunk2)
       return { events: [], sawActivity: false };
-    buffer += chunk;
+    buffer += chunk2;
     const events = [];
     buffer = buffer.replace(/\r\n|\r/g, "\n");
     const lines = buffer.split("\n");
@@ -59535,26 +59535,44 @@ function commandSupported(capabilities, kind) {
     return false;
   return supports(capabilities, needed);
 }
-var adapters = /* @__PURE__ */ new Map();
-function registerRobotAdapter(adapter) {
-  if (!adapter?.brand)
-    throw new Error("A robot adapter must name its brand.");
-  adapters.set(adapter.brand, adapter);
+var brands = /* @__PURE__ */ new Map();
+function registerRobotBrand(brand) {
+  if (!brand?.brand)
+    throw new Error("A robot brand must name itself.");
+  if (typeof brand.create !== "function") {
+    throw new Error(`Robot brand "${brand.brand}" has no way to build an adapter.`);
+  }
+  brands.set(brand.brand, brand);
 }
-function robotAdapterFor(brand) {
+function robotBrandFor(brand) {
   if (typeof brand !== "string" || !brand)
     return null;
-  return adapters.get(brand) ?? null;
+  return brands.get(brand) ?? null;
+}
+function adapterForRobot(robot) {
+  const brandName = (robot?.brand ?? "").trim();
+  const brand = robotBrandFor(brandName);
+  if (!brand) {
+    throw new Error(
+      brandName ? `No robot adapter is registered for the brand "${brandName}".` : `Robot "${robot?.name ?? "unknown"}" does not say which brand it is.`
+    );
+  }
+  const appid = (robot.appKey ?? "").trim();
+  const secret = (robot.appToken ?? "").trim();
+  if (!appid || !secret) {
+    throw new Error(`Robot "${robot?.name ?? brandName}" has no cloud credentials saved.`);
+  }
+  return brand.create({ appid, secret });
 }
 function registeredRobotBrands() {
-  return [...adapters.values()].map((a) => ({
-    brand: a.brand,
-    displayName: a.displayName,
-    tier: robotTier(a.capabilities)
+  return [...brands.values()].map((b) => ({
+    brand: b.brand,
+    displayName: b.displayName,
+    tier: robotTier(b.capabilities)
   }));
 }
-function clearRobotAdapters() {
-  adapters.clear();
+function clearRobotBrands() {
+  brands.clear();
 }
 
 // src/utils/lift-contract.util.ts
@@ -60010,122 +60028,6 @@ function useRobotCloudService(credentials, options = {}) {
   };
 }
 
-// src/services/robot-fleet.service.ts
-function credentialsOf(robot) {
-  const appid = (robot.appKey ?? "").trim();
-  const secret = (robot.appToken ?? "").trim();
-  if (!appid || !secret) {
-    throw new BadRequestError134(
-      `Robot "${robot.name}" has no cloud credentials saved.`
-    );
-  }
-  return { appid, secret };
-}
-function useRobotFleetService(deps) {
-  const cloudFor = deps?.cloudFor ?? useRobotCloudService;
-  function clientFor(robot) {
-    return cloudFor(credentialsOf(robot));
-  }
-  async function resolveRobotSn(robot) {
-    const stored = (robot.robotSn ?? "").trim();
-    if (stored)
-      return stored;
-    const fleet = await clientFor(robot).getRobots();
-    if (fleet.length === 0) {
-      throw new NotFoundError43(
-        `Robot "${robot.name}": the cloud reports no robots for these credentials.`
-      );
-    }
-    if (fleet.length > 1) {
-      throw new BadRequestError134(
-        `Robot "${robot.name}": these credentials cover ${fleet.length} robots, so the serial cannot be determined automatically. Set it explicitly.`
-      );
-    }
-    const robotSn = fleet[0].robotSn;
-    if (!robotSn) {
-      throw new BadRequestError134(
-        `Robot "${robot.name}": the cloud returned a robot with no serial.`
-      );
-    }
-    const id = robot._id ? String(robot._id) : "";
-    if (id && deps?.saveRobotSn) {
-      await deps.saveRobotSn(id, robotSn).catch(() => void 0);
-    }
-    return robotSn;
-  }
-  async function getFleetRobot(robot) {
-    const robotSn = await resolveRobotSn(robot);
-    const fleet = await clientFor(robot).getRobots();
-    const match = fleet.find(
-      (r) => r.robotSn === robotSn
-    );
-    if (!match) {
-      return {
-        id: robot._id ? String(robot._id) : "",
-        name: robot.name,
-        robotSn,
-        statusFlag: null,
-        statusName: "Not found in the robot cloud",
-        mode: "UNAVAILABLE",
-        online: false,
-        dispatchable: false
-      };
-    }
-    const mode = robotModeFromList(match);
-    return {
-      id: robot._id ? String(robot._id) : "",
-      name: robot.name,
-      robotSn,
-      statusFlag: typeof match.statusFlag === "number" ? match.statusFlag : null,
-      statusName: match.statusName ?? "",
-      mode,
-      online: match.onlineFlag !== false,
-      dispatchable: mode === "IDLE" || mode === "CHARGED"
-    };
-  }
-  async function getMaps(robot) {
-    const robotSn = await resolveRobotSn(robot);
-    return clientFor(robot).getMaps(robotSn);
-  }
-  async function getMapImages(robot, fileKeys) {
-    const robotSn = await resolveRobotSn(robot);
-    return clientFor(robot).getFileUrls(robotSn, fileKeys);
-  }
-  async function dispatch(robot, command) {
-    const robotSn = await resolveRobotSn(robot);
-    const cloud = clientFor(robot);
-    if (command.kind === "return") {
-      return cloud.returnToBase(robotSn);
-    }
-    const state = await getFleetRobot(robot);
-    if (!state.dispatchable) {
-      throw new BadRequestError134(
-        `Robot "${robot.name}" is ${state.statusName || state.mode} and cannot take a new job.`
-      );
-    }
-    switch (command.kind) {
-      case "full":
-        return cloud.startFullCleaning(robotSn, command.options);
-      case "area":
-        return cloud.startAreaCleaning(robotSn, command.areas, command.options);
-      case "spot":
-        return cloud.startSpotCleaning(robotSn, command.points, command.options);
-    }
-  }
-  async function getPlans(robot) {
-    const robotSn = await resolveRobotSn(robot);
-    return clientFor(robot).getPlans(robotSn);
-  }
-  return {
-    resolveRobotSn,
-    getFleetRobot,
-    getMaps,
-    getMapImages,
-    dispatch,
-    getPlans
-  };
-}
-
 // src/services/ounitech.adapter.ts
 var OUNITECH_BRAND = "ounitech";
 var OUNITECH_CAPABILITIES = {
@@ -60229,24 +60131,550 @@ function createOunitechAdapter(credentials, options) {
     async getMaps(robotSn) {
       return cloud.getMaps(robotSn);
     },
+    async getMapImages(robotSn, fileKeys) {
+      return cloud.getFileUrls(robotSn, fileKeys);
+    },
     async getPlans(robotSn) {
       return cloud.getPlans(robotSn);
     }
   };
 }
 function registerOunitechBrand() {
-  const unconfigured = () => {
-    throw new Error(
-      "No Ounitech credentials for this robot. Add the app key and token on the robot's record."
-    );
-  };
-  registerRobotAdapter({
+  registerRobotBrand({
     brand: OUNITECH_BRAND,
     displayName: "Ounitech (Q3-G / Q3-W)",
     capabilities: OUNITECH_CAPABILITIES,
-    listRobots: async () => unconfigured(),
-    getRobot: async () => unconfigured()
+    create: (credentials) => createOunitechAdapter(credentials)
+  });
+}
+registerOunitechBrand();
+
+// src/utils/png-encoder.util.ts
+import { deflateSync } from "zlib";
+function crc32(buffer) {
+  let crc = ~0;
+  for (let i = 0; i < buffer.length; i++) {
+    crc ^= buffer[i];
+    for (let bit = 0; bit < 8; bit++) {
+      crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+    }
+  }
+  return ~crc >>> 0;
+}
+function chunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const typed = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(typed), 0);
+  return Buffer.concat([length, typed, crc]);
+}
+function encodeGreyscalePng(pixels, width, height) {
+  if (width <= 0 || height <= 0)
+    throw new Error("A PNG needs a positive size.");
+  if (pixels.length < width * height) {
+    throw new Error("A PNG needs one byte per pixel.");
+  }
+  const raw = Buffer.alloc((width + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (width + 1)] = 0;
+    for (let x = 0; x < width; x++) {
+      raw[y * (width + 1) + 1 + x] = pixels[y * width + x];
+    }
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 0;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw)),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function greyscalePngDataUri(pixels, width, height) {
+  return `data:image/png;base64,${encodeGreyscalePng(pixels, width, height).toString("base64")}`;
+}
+
+// src/services/demo.adapter.ts
+var DEMO_BRAND = "demo";
+var DEMO_CAPABILITIES = {
+  readLocation: true,
+  navigateToPoint: true,
+  pauseResume: true,
+  pathAndEta: true,
+  battery: true,
+  sendToDock: true,
+  relocalize: true,
+  startProcess: true,
+  pauseProcess: true,
+  processCompletion: true,
+  floorReporting: true,
+  multiFloor: true
+};
+var SCALE = 0.05;
+var PLAN_W = 260;
+var PLAN_H = 180;
+var DEMO_ROBOTS = [
+  { robotSn: "DEMO-0001", name: "Demo Cleaner 01", model: "Demo S1", floorNo: 1, phase: 0 },
+  { robotSn: "DEMO-0002", name: "Demo Cleaner 02", model: "Demo S1", floorNo: 1, phase: 0.37 },
+  { robotSn: "DEMO-0003", name: "Demo Scrubber 03", model: "Demo X2", floorNo: 2, phase: 0.68 }
+];
+var commanded = /* @__PURE__ */ new Map();
+function demoPlanPixels(floorNo) {
+  const px = new Uint8Array(PLAN_W * PLAN_H).fill(255);
+  const set = (x, y) => {
+    if (x >= 0 && x < PLAN_W && y >= 0 && y < PLAN_H)
+      px[y * PLAN_W + x] = 0;
+  };
+  for (let x = 0; x < PLAN_W; x++) {
+    for (const t of [0, 1]) {
+      set(x, t);
+      set(x, PLAN_H - 1 - t);
+    }
+  }
+  for (let y = 0; y < PLAN_H; y++) {
+    for (const t of [0, 1]) {
+      set(t, y);
+      set(PLAN_W - 1 - t, y);
+    }
+  }
+  const wallX = Math.floor(PLAN_W * (floorNo === 1 ? 0.45 : 0.6));
+  for (let y = 2; y < PLAN_H - 2; y++) {
+    if (y > PLAN_H * 0.45 && y < PLAN_H * 0.6)
+      continue;
+    set(wallX, y);
+    set(wallX + 1, y);
+  }
+  if (floorNo === 2) {
+    const wallY = Math.floor(PLAN_H * 0.5);
+    for (let x = 2; x < wallX; x++) {
+      if (x > PLAN_W * 0.15 && x < PLAN_W * 0.25)
+        continue;
+      set(x, wallY);
+      set(x, wallY + 1);
+    }
+  }
+  return px;
+}
+function demoPosition(robot, now) {
+  const t = (now / 9e4 + robot.phase) % 1;
+  const angle = t * Math.PI * 2;
+  const cx = PLAN_W * 0.5 * SCALE;
+  const cy = PLAN_H * 0.5 * SCALE;
+  const rx = PLAN_W * 0.28 * SCALE;
+  const ry = PLAN_H * 0.28 * SCALE;
+  return {
+    x: cx + Math.cos(angle) * rx,
+    y: cy + Math.sin(angle) * ry,
+    // Facing along the direction of travel, which is the tangent.
+    theta: angle + Math.PI / 2
+  };
+}
+function demoBattery(robot, now) {
+  const t = (now / 36e5 + robot.phase) % 1;
+  return Math.round(t < 0.8 ? 100 - t / 0.8 * 75 : 25 + (t - 0.8) / 0.2 * 75);
+}
+function demoState(robot, now) {
+  const order = commanded.get(robot.robotSn);
+  const active = order && order.until > now ? order.mode : null;
+  const battery = demoBattery(robot, now);
+  const mode = battery <= 25 ? "CHARGING_CYCLE" : active ?? "IDLE";
+  return {
+    robotSn: robot.robotSn,
+    name: robot.name,
+    model: robot.model,
+    online: true,
+    mode,
+    statusName: mode === "WORKING" ? "Cleaning" : mode === "CHARGING_CYCLE" ? "Charging" : "Idle",
+    batteryPercent: battery,
+    floorNo: robot.floorNo,
+    // The demo DOES know its floor - unlike Ounitech today - so the map can
+    // draw it. That contrast is part of what the demo shows.
+    floorKnown: true,
+    position: demoPosition(robot, now)
+  };
+}
+function createDemoAdapter(options) {
+  const now = options?.now ?? Date.now;
+  return {
+    brand: DEMO_BRAND,
+    displayName: "Demo robots (simulated)",
+    capabilities: DEMO_CAPABILITIES,
+    async listRobots() {
+      const at2 = now();
+      return DEMO_ROBOTS.map((r) => demoState(r, at2));
+    },
+    async getRobot(robotSn) {
+      const robot = DEMO_ROBOTS.find((r) => r.robotSn === robotSn);
+      return robot ? demoState(robot, now()) : null;
+    },
+    async sendCommand(robotSn, command) {
+      const robot = DEMO_ROBOTS.find((r) => r.robotSn === robotSn);
+      if (!robot)
+        throw new Error(`No demo robot with serial ${robotSn}.`);
+      const at2 = now();
+      switch (command.kind) {
+        case "full":
+        case "area":
+        case "spot":
+          commanded.set(robotSn, { mode: "WORKING", until: at2 + 10 * 6e4 });
+          return;
+        case "return":
+          commanded.set(robotSn, { mode: "CHARGING_CYCLE", until: at2 + 5 * 6e4 });
+          return;
+        case "pause":
+          commanded.set(robotSn, { mode: "PAUSED", until: at2 + 10 * 6e4 });
+          return;
+        case "resume":
+          commanded.set(robotSn, { mode: "WORKING", until: at2 + 10 * 6e4 });
+          return;
+        case "cancel":
+          commanded.delete(robotSn);
+          return;
+        case "navigate":
+        case "relocalize":
+          commanded.set(robotSn, { mode: "WORKING", until: at2 + 6e4 });
+          return;
+      }
+    },
+    async getMaps() {
+      return DEMO_ROBOTS.map((r) => r.floorNo).filter((floorNo, i, all) => all.indexOf(floorNo) === i).sort((a, b) => a - b).map((floorNo) => ({
+        floorNo,
+        mapName: `Demo Building L${floorNo}`,
+        backgroundFileKey: `demo/L${floorNo}.png`,
+        partitionFileKey: `demo/L${floorNo}.png`,
+        originX: 0,
+        originY: 0,
+        resolution: SCALE,
+        totalArea: Math.round(PLAN_W * PLAN_H * SCALE * SCALE),
+        baseX: 12,
+        baseY: 3,
+        baseTheta: 0,
+        createTime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        areaList: [
+          { areaName: `L${floorNo}-LOBBY`, rgba: "FF0B0B83", x: 60, y: 60 },
+          { areaName: `L${floorNo}-OFFICE`, rgba: "B7CAEFFF", x: 190, y: 60 },
+          { areaName: `L${floorNo}-CORRIDOR`, rgba: "BA144BFF", x: 120, y: 140 }
+        ]
+      }));
+    },
+    /**
+     * Data URIs rather than signed links.
+     *
+     * A demo must work with no storage account and no network, and a `data:`
+     * URI is same-origin so the canvas is not tainted — which matters, because
+     * the layout is built by reading these pixels back.
+     */
+    async getMapImages(_robotSn, fileKeys) {
+      return fileKeys.map((fileKey) => {
+        const floorNo = fileKey.includes("L2") ? 2 : 1;
+        return {
+          fileKey,
+          url: greyscalePngDataUri(demoPlanPixels(floorNo), PLAN_W, PLAN_H)
+        };
+      });
+    },
+    async getPlans() {
+      return [
+        {
+          planId: 1,
+          dateList: [1, 2, 3, 4, 5],
+          startTime: "08:00",
+          endTime: "10:00",
+          enableFlag: true,
+          jobList: [
+            {
+              floorNo: 1,
+              rangeFlag: 3,
+              cleanTimes: 1,
+              pointList: [],
+              colorList: [{ r: 255, g: 11, b: 11, a: 131 }],
+              modeFlag: 1,
+              subModeFlag: 0,
+              levelFlag: 1
+            }
+          ]
+        }
+      ];
+    }
+  };
+}
+function registerDemoBrand() {
+  registerRobotBrand({
+    brand: DEMO_BRAND,
+    displayName: "Demo robots (simulated)",
+    capabilities: DEMO_CAPABILITIES,
+    create: () => createDemoAdapter()
+  });
+}
+registerDemoBrand();
+
+// src/services/robot-fleet.service.ts
+function useRobotFleetService(deps) {
+  const adapterFor = deps?.adapterFor ?? ((robot) => adapterForRobot(robot));
+  function capabilitiesOf(robot) {
+    return robotBrandFor(robot.brand ?? "")?.capabilities ?? {};
+  }
+  async function resolveRobotSn(robot) {
+    const stored = (robot.robotSn ?? "").trim();
+    if (stored)
+      return stored;
+    const fleet = await adapterFor(robot).listRobots();
+    if (fleet.length === 0) {
+      throw new NotFoundError43(
+        `Robot "${robot.name}": the robot cloud reports no robots for these credentials.`
+      );
+    }
+    if (fleet.length > 1) {
+      throw new BadRequestError134(
+        `Robot "${robot.name}": these credentials cover ${fleet.length} robots, so the serial cannot be determined automatically. Set it explicitly.`
+      );
+    }
+    const robotSn = fleet[0].robotSn;
+    if (!robotSn) {
+      throw new BadRequestError134(`Robot "${robot.name}": the cloud returned a robot with no serial.`);
+    }
+    const id = robot._id ? String(robot._id) : "";
+    if (id && deps?.saveRobotSn) {
+      await deps.saveRobotSn(id, robotSn).catch(() => void 0);
+    }
+    return robotSn;
+  }
+  async function getFleetRobot(robot) {
+    const adapter = adapterFor(robot);
+    const robotSn = await resolveRobotSn(robot);
+    const found = await adapter.getRobot(robotSn);
+    const id = robot._id ? String(robot._id) : "";
+    const brand = adapter.brand;
+    if (!found) {
+      return {
+        id,
+        name: robot.name,
+        brand,
+        robotSn,
+        statusName: "Not found in the robot cloud",
+        mode: "UNAVAILABLE",
+        online: false,
+        dispatchable: false,
+        batteryPercent: null,
+        floorNo: null,
+        floorKnown: false,
+        position: null
+      };
+    }
+    const free = found.mode === "IDLE" || found.mode === "CHARGED";
+    return {
+      id,
+      name: robot.name,
+      brand,
+      robotSn,
+      statusName: found.statusName ?? "",
+      mode: found.mode,
+      online: found.online,
+      dispatchable: found.online && free && commandSupported(adapter.capabilities, "full"),
+      batteryPercent: found.batteryPercent ?? null,
+      floorNo: found.floorNo ?? null,
+      floorKnown: found.floorKnown === true,
+      position: found.position ?? null
+    };
+  }
+  async function getMaps(robot) {
+    const adapter = adapterFor(robot);
+    if (!adapter.getMaps)
+      return [];
+    return adapter.getMaps(await resolveRobotSn(robot));
+  }
+  async function getMapImages(robot, fileKeys) {
+    const adapter = adapterFor(robot);
+    if (!adapter.getMapImages || !fileKeys.length)
+      return [];
+    return adapter.getMapImages(await resolveRobotSn(robot), fileKeys);
+  }
+  async function getPlans(robot) {
+    const adapter = adapterFor(robot);
+    if (!adapter.getPlans)
+      return [];
+    return adapter.getPlans(await resolveRobotSn(robot));
+  }
+  async function dispatch(robot, command) {
+    const adapter = adapterFor(robot);
+    if (!adapter.sendCommand) {
+      throw new BadRequestError134(
+        `${adapter.displayName} robots cannot be commanded through their API.`
+      );
+    }
+    if (!commandSupported(adapter.capabilities, command.kind)) {
+      throw new BadRequestError134(
+        `${adapter.displayName} does not support "${command.kind}" through its API yet.`
+      );
+    }
+    const robotSn = await resolveRobotSn(robot);
+    if (command.kind === "return") {
+      return adapter.sendCommand(robotSn, command);
+    }
+    const state = await getFleetRobot(robot);
+    if (!state.dispatchable) {
+      throw new BadRequestError134(
+        `Robot "${robot.name}" is ${state.statusName || state.mode} and cannot take a new job.`
+      );
+    }
+    return adapter.sendCommand(robotSn, command);
+  }
+  return {
+    adapterFor,
+    capabilitiesOf,
+    resolveRobotSn,
+    getFleetRobot,
+    getMaps,
+    getMapImages,
+    getPlans,
+    dispatch
+  };
+}
+
+// src/services/robot-tracking.service.ts
+import axios4 from "axios";
+async function openWithAxios(url, body) {
+  const response = await axios4.post(url, body, {
+    responseType: "stream",
+    // No read timeout: this connection is SUPPOSED to stay open and mostly
+    // silent. A request timeout here would sever a healthy stream on a quiet
+    // robot. The idle watchdog is what decides a stream is dead, because it can
+    // tell silence from a closed socket.
+    timeout: 0,
+    headers: { "Content-Type": "application/json", Accept: "text/event-stream" }
   });
+  return response.data;
+}
+function startRobotTracking(options) {
+  const {
+    credentials,
+    robotSn,
+    onEvent,
+    baseUrl = ROBOT_CLOUD_BASE_URL,
+    idleTimeoutMs = TRACKING_IDLE_TIMEOUT_MS,
+    openStream = openWithAxios,
+    now = Date.now
+  } = options;
+  if (!baseUrl)
+    throw new Error("Robot cloud: ROBOT_CLOUD_BASE_URL is not configured.");
+  let stopped = false;
+  let attempt = 0;
+  let current = null;
+  let watchdog = null;
+  let retry = null;
+  let lastActivityAt = now();
+  let everConnected = false;
+  const parser = createSseParser();
+  function clearTimers() {
+    if (watchdog) {
+      clearInterval(watchdog);
+      watchdog = null;
+    }
+    if (retry) {
+      clearTimeout(retry);
+      retry = null;
+    }
+  }
+  function dropUpstream() {
+    if (!current)
+      return;
+    try {
+      current.destroy();
+    } catch {
+    }
+    current = null;
+  }
+  function lose(reason) {
+    if (stopped)
+      return;
+    onEvent({ type: "lost", reason, at: now() });
+    dropUpstream();
+    scheduleReconnect();
+  }
+  function scheduleReconnect() {
+    if (stopped)
+      return;
+    clearTimers();
+    const delay2 = trackingBackoffMs(attempt++);
+    retry = setTimeout(connect2, delay2);
+  }
+  async function connect2() {
+    if (stopped)
+      return;
+    const body = robotCloudBody(
+      credentials.appid,
+      credentials.secret,
+      ROBOT_CLOUD_PATHS.tracking,
+      { robotSn }
+    );
+    let stream;
+    try {
+      stream = await openStream(
+        `${baseUrl.replace(/\/+$/, "")}${ROBOT_CLOUD_PATHS.tracking}`,
+        body
+      );
+    } catch (error) {
+      lose(error?.message ?? "Could not open the robot's tracking stream.");
+      return;
+    }
+    if (stopped) {
+      try {
+        stream.destroy();
+      } catch {
+      }
+      return;
+    }
+    parser.reset();
+    current = stream;
+    lastActivityAt = now();
+    if (everConnected)
+      onEvent({ type: "reconnected", at: now() });
+    everConnected = true;
+    attempt = 0;
+    stream.on("data", (chunk2) => {
+      if (stopped)
+        return;
+      const { events, sawActivity } = parser.push(chunk2.toString("utf8"));
+      if (sawActivity)
+        lastActivityAt = now();
+      for (const event of events) {
+        const pose = decodeTrackingFrame(event.data);
+        if (pose)
+          onEvent({ type: "pose", pose, at: now() });
+      }
+    });
+    stream.on("error", (error) => lose(error?.message ?? "The tracking stream failed."));
+    stream.on("end", () => lose("The robot cloud closed the tracking stream."));
+    stream.on("close", () => {
+      if (!stopped && current === stream)
+        lose("The tracking stream closed.");
+    });
+    clearTimers();
+    watchdog = setInterval(() => {
+      if (stopped)
+        return;
+      if (now() - lastActivityAt >= idleTimeoutMs) {
+        lose("The robot stopped reporting.");
+      }
+    }, Math.max(1e3, Math.floor(idleTimeoutMs / 3)));
+  }
+  void connect2();
+  return {
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      clearTimers();
+      dropUpstream();
+    }
+  };
 }
 
 // src/controllers/robot-fleet.controller.ts
@@ -60327,7 +60755,62 @@ function useRobotFleetController(deps) {
       fail(next, error);
     }
   }
-  return { getState, getMaps, getMapImages, getPlans, sendCommand: sendCommand2 };
+  async function trackRobot(req, res, next) {
+    let robot;
+    let robotSn;
+    try {
+      robot = await entitleRobot(req, req.params.id);
+      robotSn = await getFleet().resolveRobotSn(robot);
+    } catch (error) {
+      fail(next, error);
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      // Nginx buffers proxied responses by default, which holds an SSE stream
+      // until the buffer fills - the stream appears dead for minutes.
+      "X-Accel-Buffering": "no"
+    });
+    res.flushHeaders?.();
+    const send2 = (event) => {
+      if (res.writableEnded)
+        return;
+      res.write(`data: ${JSON.stringify(event)}
+
+`);
+    };
+    const handle = startRobotTracking({
+      credentials: {
+        appid: (robot.appKey ?? "").trim(),
+        secret: (robot.appToken ?? "").trim()
+      },
+      robotSn,
+      onEvent: send2
+    });
+    const keepAlive = setInterval(() => {
+      if (!res.writableEnded)
+        res.write(": keep-alive\n\n");
+    }, 15e3);
+    const close = () => {
+      clearInterval(keepAlive);
+      handle.stop();
+      if (!res.writableEnded)
+        res.end();
+    };
+    req.on("close", close);
+    req.on("aborted", close);
+    res.on("error", close);
+  }
+  async function getBrands(_req, res, next) {
+    try {
+      res.json({ items: registeredRobotBrands() });
+    } catch (error) {
+      fail(next, error);
+    }
+  }
+  return { getState, getMaps, getMapImages, getPlans, sendCommand: sendCommand2, trackRobot, getBrands };
 }
 
 // src/models/patrol-question.model.ts
@@ -80953,7 +81436,7 @@ import {
 } from "@7365admin1/node-server-utils";
 
 // src/utils/hrmlabs-attendance.util.ts
-import axios4 from "axios";
+import axios5 from "axios";
 import moment8 from "moment-timezone";
 var default_early_checkIn = 4;
 async function hrmLabsAuthentication({
@@ -80962,7 +81445,7 @@ async function hrmLabsAuthentication({
   password,
   domain
 }) {
-  const res = await axios4.post(
+  const res = await axios5.post(
     authUrl,
     {
       grant_type: "password",
@@ -80992,7 +81475,7 @@ async function fetchAttendanceData({
   search
 }) {
   try {
-    const res = await axios4.post(
+    const res = await axios5.post(
       attendanceUrl,
       {
         start: startDate,
@@ -81192,7 +81675,7 @@ async function fetchSites({ siteUrl, token }) {
   do {
     try {
       attempt++;
-      const res = await axios4.get(siteUrl, {
+      const res = await axios5.get(siteUrl, {
         headers: { Authorization: `Bearer ${token}` },
         timeout: 15e3
       });
@@ -84840,7 +85323,7 @@ async function manpowerEvents(io) {
 }
 
 // src/services/reddot-payment.service.ts
-import axios5 from "axios";
+import axios6 from "axios";
 
 // src/utils/payment-signature.util.ts
 import * as crypto9 from "crypto";
@@ -85482,7 +85965,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_PAYMENT;
-      const response = await axios5.post(url, dataString, { headers });
+      const response = await axios6.post(url, dataString, { headers });
       const result = response.data;
       return result;
     } catch (error) {
@@ -85516,7 +85999,7 @@ var useRedDotPaymentSvc = () => {
         );
       }
       const url = process.env.MERCHANT_ENQUIRY;
-      const response = await axios5.post(url, dataString, { headers });
+      const response = await axios6.post(url, dataString, { headers });
       const result = response.data;
       const transactionId = result.transaction_id;
       const amount = result.request_amount || 0;
@@ -94165,6 +94648,8 @@ export {
   DEFAULT_RING_SECONDS,
   DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE,
+  DEMO_BRAND,
+  DEMO_CAPABILITIES,
   DEVICE_STATUS,
   DOBStatus,
   DUPLICATE_TERMS_VERSION_MESSAGE,
@@ -94334,6 +94819,7 @@ export {
   ROBOT_CAPABILITIES,
   ROBOT_CLOUD_DOC_CONFIRMATIONS,
   ROBOT_CLOUD_PATHS,
+  ROBOT_CLOUD_TIMEOUT_MS,
   ROBOT_MODULE,
   ROBOT_PERMISSIONS,
   ROBOT_STATUS_NAMES,
@@ -94385,6 +94871,7 @@ export {
   VisitorStatus,
   WALL_HEIGHT_M,
   WALL_THICKNESS_M,
+  adapterForRobot,
   addressSchema,
   allowedFieldsSite,
   allowedNatures,
@@ -94424,13 +94911,14 @@ export {
   chatSchema,
   claimReadsAsStale,
   clampPtzSpeed,
-  clearRobotAdapters,
+  clearRobotBrands,
   clockDriftSeconds,
   commandSupported,
   consoleRoleAllows,
   consoleRoleAllowsAll,
   consoleSpellings,
   console_audit_namespace_collection,
+  createDemoAdapter,
   createLiftSimulator,
   createManpowerRemarksDaily,
   createOunitechAdapter,
@@ -94454,6 +94942,7 @@ export {
   disconnectedState,
   emitNotificationCreated,
   emptyPersonalEmergencyChain,
+  encodeGreyscalePng,
   encodeHidPacsCard,
   entitledSiteScope,
   events_namespace_collection,
@@ -94472,6 +94961,7 @@ export {
   getIO,
   getSessionIdFromRequest,
   grabWithSubStreamFallback,
+  greyscalePngDataUri,
   guests_namespace_collection,
   hasAnyCapability,
   hasAnyPermission,
@@ -94573,8 +95063,9 @@ export {
   recordConsoleAction,
   refuseServiceProviderInviteAction,
   registerCameraTransport,
+  registerDemoBrand,
   registerOunitechBrand,
-  registerRobotAdapter,
+  registerRobotBrand,
   registeredRobotBrands,
   relayForRecorder,
   remarksSchema,
@@ -94593,7 +95084,7 @@ export {
   resolveSiteTimezone,
   resolveStaffRole,
   robotActionsFor,
-  robotAdapterFor,
+  robotBrandFor,
   robotCloudBody,
   robotCloudSign,
   robotCloudSigningString,
@@ -94772,6 +95263,7 @@ export {
   snapshotEndpoint,
   snapshotRefusalReason,
   staffMayBypass,
+  startRobotTracking,
   startTodaysBookForSite,
   stringifyHidJson,
   stripFacialImageMetadata,