@7365admin1/core 3.68.0 → 3.68.1

package/dist/index.mjs

@@ -21257,6 +21257,7 @@ import { promises as fsAsync } from "fs";
 import Joi26 from "joi";
 import * as path2 from "path";
 import { request } from "urllib";
+import { createHash as createHash2 } from "crypto";
 
 // src/repositories/visitor-transaction.repo.ts
 import {
@@ -23773,6 +23774,69 @@ function useVehicleRepo() {
       throw error;
     }
   }
+  async function getLivePlatesBySite(site) {
+    let siteId;
+    try {
+      siteId = new ObjectId47(site);
+    } catch (error) {
+      throw new BadRequestError46("Invalid site ID format.");
+    }
+    try {
+      return await collection.aggregate([
+        {
+          $match: {
+            site: siteId,
+            status: "active" /* ACTIVE */,
+            plateNumber: { $nin: [null, ""] }
+          }
+        },
+        { $sort: { name: 1, plateNumber: 1 } },
+        {
+          $lookup: {
+            from: "buildings",
+            localField: "block",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "blockDoc"
+          }
+        },
+        {
+          $lookup: {
+            from: "building-levels",
+            localField: "level",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "levelDoc"
+          }
+        },
+        {
+          $lookup: {
+            from: "building-units",
+            localField: "unit",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "unitDoc"
+          }
+        },
+        {
+          $project: {
+            plateNumber: 1,
+            name: 1,
+            start: 1,
+            end: 1,
+            type: 1,
+            blockedFrom: 1,
+            seasonPassType: 1,
+            blockName: { $ifNull: [{ $arrayElemAt: ["$blockDoc.name", 0] }, ""] },
+            levelName: { $ifNull: [{ $arrayElemAt: ["$levelDoc.name", 0] }, ""] },
+            unitName: { $ifNull: [{ $arrayElemAt: ["$unitDoc.name", 0] }, ""] }
+          }
+        }
+      ]).toArray();
+    } catch (error) {
+      throw new InternalServerError24("Failed to list the site's vehicles.");
+    }
+  }
   async function getAllExpiredVehicles() {
     try {
       const items = await collection.find(expiredVehicleSweepFilter()).toArray();
@@ -23977,6 +24041,7 @@ function useVehicleRepo() {
     getVehicleByPlateNumber,
     getVehiclesByNRIC,
     deleteExpiredVehicles,
+    getLivePlatesBySite,
     getAllVehiclesByUnitId,
     getAllExpiredVehicles,
     bulkUpsertVehicles,
@@ -24176,6 +24241,73 @@ function classifyDahuaFailure(message) {
   }
   return "transient";
 }
+var DAHUA_COMMAND_ATTEMPTS = 10;
+var DAHUA_COMMAND_DEADLINE_MS = 45e3;
+var DAHUA_LOGIN_PROVEN_FOR_MS = 10 * 6e4;
+var COMMAND_RETRY_DELAYS_MS = [1e3, 2e3, 3e3, 4e3, 5e3];
+function dahuaCommandRetryDelayMs(failedAttempt) {
+  const index = Math.min(
+    Math.max(Math.floor(failedAttempt), 1),
+    COMMAND_RETRY_DELAYS_MS.length
+  );
+  return COMMAND_RETRY_DELAYS_MS[index - 1];
+}
+var NOT_SENT_PATTERN = /ECONNREFUSED|EHOSTUNREACH|ENETUNREACH|EAI_AGAIN|ENOTFOUND|UND_ERR_CONNECT_TIMEOUT|connect ?timeout|ConnectTimeout/i;
+function classifyDahuaAttempt(attempt) {
+  if (attempt.error !== void 0 && attempt.error !== null) {
+    const error = attempt.error;
+    const message = [error?.name, error?.code, error?.cause?.code, error?.message ?? error].filter(Boolean).join(" ");
+    if (/invalid authority|\b401\b|unauthori[sz]ed/i.test(message)) {
+      return "login-refused";
+    }
+    if (/\b403\b|forbidden/i.test(message))
+      return "forbidden";
+    if (NOT_SENT_PATTERN.test(message))
+      return "not-sent";
+    return "maybe-sent";
+  }
+  const status = attempt.statusCode;
+  if (status === 401 || /invalid authority/i.test(String(attempt.text ?? ""))) {
+    return "login-refused";
+  }
+  if (status === 403)
+    return "forbidden";
+  if (status === 502 || status === 503 || status === 504)
+    return "busy";
+  if (status === void 0)
+    return "maybe-sent";
+  return "answered";
+}
+function shouldRetryDahuaCommand(options) {
+  const {
+    kind,
+    attempt,
+    loginFailures,
+    loginProven,
+    repeatable,
+    elapsedMs,
+    nextDelayMs,
+    maxAttempts = DAHUA_COMMAND_ATTEMPTS,
+    deadlineMs = DAHUA_COMMAND_DEADLINE_MS
+  } = options;
+  if (kind === "answered" || kind === "forbidden")
+    return false;
+  if (attempt >= maxAttempts)
+    return false;
+  if (elapsedMs + nextDelayMs > deadlineMs)
+    return false;
+  switch (kind) {
+    case "login-refused":
+      return loginProven || loginFailures < DAHUA_AUTH_ATTEMPTS_BEFORE_ALERT;
+    case "busy":
+    case "not-sent":
+      return true;
+    case "maybe-sent":
+      return repeatable;
+    default:
+      return false;
+  }
+}
 var enc = (value) => encodeURIComponent(String(value));
 function buildPlateUpdateEndpoint(value) {
   return `/cgi-bin/recordUpdater.cgi?action=update&name=${enc(value.mode)}&recno=${enc(value.recno)}&PlateNumber=${enc(value.plateNumber)}&BeginTime=${enc(value.start)}&CancelTime=${enc(value.end)}&+OpenGate=${value.openGate}&MasterOfCar=${enc(value.owner)}`;
@@ -24186,6 +24318,13 @@ function buildPlateInsertEndpoint(value) {
 function buildPlateRemoveEndpoint(value) {
   return `/cgi-bin/recordUpdater.cgi?action=remove&recno=${enc(value.recno)}&name=${enc(value.mode)}`;
 }
+var CLEARABLE_PLATE_LISTS = ["TrafficRedList", "TrafficBlackList"];
+function buildPlateClearEndpoint(value) {
+  if (!CLEARABLE_PLATE_LISTS.includes(value.mode)) {
+    throw new Error(`Refusing to clear record set ${JSON.stringify(value.mode)}.`);
+  }
+  return `/cgi-bin/recordUpdater.cgi?action=clear&name=${enc(value.mode)}`;
+}
 
 // src/utils/anpr-revoke.util.ts
 function anprRevokeOutcome(response) {
@@ -24311,6 +24450,148 @@ function anprNoCameraRefusal(outcome) {
   return `There is no ANPR camera set up at this site, so the plate cannot be registered on a barrier. The vehicle has NOT been ${outcome}. Add a camera in Settings first, then try again.`;
 }
 
+// src/utils/anpr-plate.util.ts
+var ALLOW_CAMERA_DIRECTIONS = ["entry", "both", "residents"];
+var BLOCK_CAMERA_DIRECTIONS = ["entry", "both", "residents", "visitors"];
+function isAllowCameraDirection(direction) {
+  return ALLOW_CAMERA_DIRECTIONS.includes(
+    String(direction ?? "").trim().toLowerCase()
+  );
+}
+function isBlockCameraDirection(direction) {
+  return BLOCK_CAMERA_DIRECTIONS.includes(
+    String(direction ?? "").trim().toLowerCase()
+  );
+}
+function listsFilledByDirectionChange(from, to) {
+  const before = String(from ?? "").trim().toLowerCase();
+  const after = String(to ?? "").trim().toLowerCase();
+  if (!after || after === before)
+    return { allow: false, block: false };
+  return {
+    allow: isAllowCameraDirection(after) && !isAllowCameraDirection(before),
+    block: isBlockCameraDirection(after) && !isBlockCameraDirection(before)
+  };
+}
+function listsClearedByDirectionChange(from, to) {
+  const before = String(from ?? "").trim().toLowerCase();
+  const after = String(to ?? "").trim().toLowerCase();
+  if (!after || after === before)
+    return { allow: false, block: false };
+  if (after === "exit")
+    return { allow: true, block: true };
+  return {
+    allow: isAllowCameraDirection(before) && !isAllowCameraDirection(after),
+    block: false
+  };
+}
+function mustRevokeFrom(direction, list, vehicleIsBlocked = false) {
+  if (list === "allowed")
+    return isAllowCameraDirection(direction);
+  if (isBlockCameraDirection(direction))
+    return true;
+  return vehicleIsBlocked;
+}
+function normalisePlate(plate) {
+  return String(plate ?? "").replace(/\s+/g, "").toUpperCase();
+}
+function samePlate(a, b) {
+  const left = normalisePlate(a);
+  return left !== "" && left === normalisePlate(b);
+}
+function parseDahuaFindRecords(text2) {
+  const body = String(text2 ?? "");
+  const found = Number(body.match(/found=(\d+)/i)?.[1] || 0);
+  const byIndex = /* @__PURE__ */ new Map();
+  const pattern = /records\[(\d+)\]\.(RecNo|PlateNumber|BeginTime|CancelTime|MasterOfCar)=([^\r\n]*)/gi;
+  for (const match of body.matchAll(pattern)) {
+    const index = Number(match[1]);
+    const key = match[2].toLowerCase();
+    const value = match[3].trim();
+    const record = byIndex.get(index) ?? { recNo: "", plateNumber: "" };
+    if (key === "recno")
+      record.recNo = value;
+    else if (key === "platenumber")
+      record.plateNumber = value;
+    else if (key === "begintime")
+      record.beginTime = value;
+    else if (key === "canceltime")
+      record.cancelTime = value;
+    else
+      record.owner = value;
+    byIndex.set(index, record);
+  }
+  const records = Array.from(byIndex.entries()).sort(([a], [b]) => a - b).map(([, record]) => record).filter((record) => record.recNo !== "");
+  return { found, records };
+}
+function matchingPlateRecords(text2, plateNumber) {
+  return parseDahuaFindRecords(text2).records.filter(
+    (record) => record.plateNumber === "" || samePlate(record.plateNumber, plateNumber)
+  );
+}
+function listsHeldBy(vehicle) {
+  const type = String(vehicle?.type ?? "");
+  return {
+    allow: type === "whitelist" || String(vehicle?.blockedFrom ?? "") === "whitelist",
+    block: type === "blocklist"
+  };
+}
+function listsToRevoke(othersStillLive) {
+  const others = (othersStillLive ?? []).map(listsHeldBy);
+  return {
+    allow: !others.some((held) => held.allow),
+    block: !others.some((held) => held.block)
+  };
+}
+var DEFAULT_CAMERA_TIMEZONE = "Asia/Singapore";
+function usableTimezone(timezone) {
+  const zone = String(timezone ?? "").trim();
+  if (!zone)
+    return DEFAULT_CAMERA_TIMEZONE;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: zone });
+    return zone;
+  } catch {
+    return DEFAULT_CAMERA_TIMEZONE;
+  }
+}
+var WALL_CLOCK = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})(?::(\d{2}))?$/;
+function dahuaWallClock(value, timezone) {
+  if (value === null || value === void 0 || value === "")
+    return null;
+  if (typeof value === "string") {
+    const wall = value.trim().match(WALL_CLOCK);
+    if (wall) {
+      const [, y, mo, d, h, mi, se] = wall;
+      return `${y}-${mo}-${d} ${h}:${mi}:${se ?? "00"}`;
+    }
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime()))
+    return null;
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: usableTimezone(timezone),
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const part = (type) => parts.find((entry) => entry.type === type)?.value ?? "00";
+  return `${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")}:${part("second")}`;
+}
+function plateWindowMatches(record, wanted) {
+  const same = (held, want) => {
+    const a = dahuaWallClock(held);
+    return a !== null && a === dahuaWallClock(want);
+  };
+  if (!wanted.start || !wanted.end)
+    return false;
+  return same(record.beginTime, wanted.start) && same(record.cancelTime, wanted.end);
+}
+
 // src/services/dahua.service.ts
 function notifyCameraFault(camera, message) {
   NotificationService.cameraFault({
@@ -24382,12 +24663,14 @@ async function useDahuaDigestWithRetry({
       const statusCode = getDahuaStatusCode(response);
       if (streaming) {
         if (statusCode === 200) {
+          markLoginProven(host, username, password);
           return response;
         }
       } else {
         const text2 = getDahuaResponseText(response);
         const isOk = statusCode === 200 && text2.includes("OK");
         if (isOk) {
+          markLoginProven(host, username, password);
           return response;
         }
       }
@@ -24421,6 +24704,123 @@ async function useDahuaDigestWithRetry({
   }
   throw lastError;
 }
+var provenLogins = /* @__PURE__ */ new Map();
+function loginKey(host, username, password) {
+  return createHash2("sha256").update(`${host ?? ""}
+${username ?? ""}
+${password ?? ""}`).digest("hex");
+}
+function markLoginProven(host, username, password) {
+  provenLogins.set(loginKey(host, username, password), Date.now());
+}
+function forgetLogin(host, username, password) {
+  provenLogins.delete(loginKey(host, username, password));
+}
+function isLoginProven(host, username, password) {
+  const at2 = provenLogins.get(loginKey(host, username, password));
+  return at2 !== void 0 && Date.now() - at2 < DAHUA_LOGIN_PROVEN_FOR_MS;
+}
+var ATTEMPT_WORDS = {
+  "login-refused": "login refused",
+  forbidden: "credentials refused",
+  busy: "camera busy",
+  "not-sent": "could not connect",
+  "maybe-sent": "connection lost"
+};
+async function sendCameraCommand({
+  host,
+  username,
+  password,
+  endpoint,
+  timeout = 1e4,
+  repeatable = true,
+  label = "command",
+  deadlineMs = DAHUA_COMMAND_DEADLINE_MS
+}) {
+  const startedAt = Date.now();
+  let loginFailures = 0;
+  for (let attempt = 1; ; attempt++) {
+    let response;
+    let error;
+    try {
+      response = await useDahuaDigest({
+        host,
+        username,
+        password,
+        endpoint,
+        headers: { Connection: "close" },
+        timeout
+      });
+    } catch (thrown) {
+      error = thrown ?? new Error("the request failed with no error");
+    }
+    const kind = classifyDahuaAttempt(
+      error ? { error } : {
+        statusCode: getDahuaStatusCode(response),
+        text: getDahuaResponseText(response)
+      }
+    );
+    if (kind === "answered") {
+      markLoginProven(host, username, password);
+      if (attempt > 1) {
+        loggerDahua.info(`[${host}] ${label}: went through on try ${attempt}`);
+      }
+      return response;
+    }
+    if (kind === "login-refused")
+      loginFailures++;
+    if (kind === "forbidden")
+      forgetLogin(host, username, password);
+    const nextDelayMs = dahuaCommandRetryDelayMs(attempt);
+    const retry = shouldRetryDahuaCommand({
+      kind,
+      attempt,
+      loginFailures,
+      loginProven: isLoginProven(host, username, password),
+      repeatable,
+      elapsedMs: Date.now() - startedAt,
+      nextDelayMs,
+      deadlineMs
+    });
+    const why = ATTEMPT_WORDS[kind] ?? kind;
+    if (!retry) {
+      if (attempt > 1 || kind !== "forbidden") {
+        loggerDahua.warn(
+          `[${host}] ${label}: ${why} on try ${attempt}/${DAHUA_COMMAND_ATTEMPTS}; giving up`
+        );
+      }
+      if (error)
+        throw error;
+      return response;
+    }
+    loggerDahua.warn(
+      `[${host}] ${label}: ${why} on try ${attempt}/${DAHUA_COMMAND_ATTEMPTS}; trying again in ${nextDelayMs} ms`
+    );
+    await sleep(nextDelayMs);
+  }
+}
+async function sendCameraCommandExpectingOk(options) {
+  const response = await sendCameraCommand(options);
+  const statusCode = getDahuaStatusCode(response);
+  const text2 = getDahuaResponseText(response);
+  if (statusCode === 200 && text2.includes("OK"))
+    return response;
+  const error = new Error(`Dahua response: ${text2 || `HTTP ${statusCode}`}`);
+  error.answeredByCamera = true;
+  throw error;
+}
+function anprOwnerName(owner) {
+  return String(owner ?? "").replace(/['"]/g, "").replace(/[\/\\]/g, " - ").substring(0, 15).trim() || "unknown";
+}
+function plateWindowOnCamera(value) {
+  const tenMinutesAgo = new Date(Date.now() - 10 * 6e4);
+  const tenYearsOn = new Date(tenMinutesAgo);
+  tenYearsOn.setFullYear(tenYearsOn.getFullYear() + 10);
+  return {
+    start: dahuaWallClock(value.start, value.timezone) ?? dahuaWallClock(tenMinutesAgo, value.timezone),
+    end: dahuaWallClock(value.end, value.timezone) ?? dahuaWallClock(tenYearsOn, value.timezone)
+  };
+}
 function createFileNameFromEvent(utcSeconds, utcMilliseconds) {
   const date = new Date(utcSeconds * 1e3 + utcMilliseconds);
   const year = date.getUTCFullYear();
@@ -25022,111 +25422,115 @@ function useDahuaService() {
       start: Joi26.string().isoDate().optional().allow("", null),
       end: Joi26.string().isoDate().optional().allow("", null),
       owner: Joi26.string().optional().allow("", null),
-      isOpenGate: Joi26.boolean().optional().allow(null)
+      isOpenGate: Joi26.boolean().optional().allow(null),
+      timezone: Joi26.string().optional().allow("", null)
     });
     const { error: validationError } = validation.validate(value);
     if (validationError) {
       throw new BadRequestError47(`Validation error: ${validationError.message}`);
     }
     try {
-      value.owner = String(value.owner ?? "").replace(/['"]/g, "").replace(/[\/\\]/g, " - ").substring(0, 15).trim() || "unknown";
-      const formatDahuaDate3 = (dateStr, fallbackYearsAhead = 0) => {
-        const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date();
-        if (!dateStr) {
-          date.setMinutes(date.getMinutes() - 10);
-        }
-        if (fallbackYearsAhead > 0 && !dateStr) {
-          date.setFullYear(date.getFullYear() + fallbackYearsAhead);
-        }
-        const pad = (num) => String(num).padStart(2, "0");
-        return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-      };
-      const formattedStart = formatDahuaDate3(value.start);
-      const formattedEnd = formatDahuaDate3(value.end, 10);
+      value.owner = anprOwnerName(value.owner);
+      const { start: formattedStart, end: formattedEnd } = plateWindowOnCamera(value);
       const beginTime = encodeURIComponent(formattedStart);
       const cancelTime = encodeURIComponent(formattedEnd);
       const plateNumber = encodeURIComponent(value.plateNumber);
       const ownerName = encodeURIComponent(value.owner);
       const endpoint = `/cgi-bin/recordUpdater.cgi?action=insert&name=${value.mode}&PlateNumber=${plateNumber}&BeginTime=${beginTime}&CancelTime=${cancelTime}&MasterOfCar=${ownerName}`;
-      try {
-        const insertResponse = await useDahuaDigestWithRetry({
-          host: value.host,
-          username: value.username,
-          password: value.password,
-          endpoint,
-          retries: 10,
-          retryDelayMs: 0
-        });
-        const insertText = getDahuaResponseText(insertResponse);
-        const insertedId = insertText.match(/\d+/)?.[0] || "unknown";
-        return {
-          ...insertResponse,
-          statusCode: 200,
-          data: Buffer.from(`recno=${insertedId}`)
-        };
-      } catch (insertError) {
-        const errorMessage = insertError?.message || String(insertError);
-        if (/recno=/i.test(errorMessage)) {
-          loggerDahua.info(`[${value.host}] Insert confirmed successfully via raw RecNo response text.`);
-          const insertedId = errorMessage.match(/\d+/)?.[0] || "unknown";
+      const INSERT_ROUNDS = 3;
+      for (let round = 1; ; round++) {
+        try {
+          const insertResponse = await sendCameraCommandExpectingOk({
+            host: value.host,
+            username: value.username,
+            password: value.password,
+            endpoint,
+            repeatable: false,
+            label: `add plate to ${value.mode}`
+          });
+          const insertText = getDahuaResponseText(insertResponse);
+          const insertedId = insertText.match(/\d+/)?.[0] || "unknown";
           return {
+            ...insertResponse,
             statusCode: 200,
             data: Buffer.from(`recno=${insertedId}`)
           };
-        }
-        if (errorMessage.includes("Bad Request") || errorMessage.includes("Dahua response: Error")) {
-          loggerDahua.info(`[${value.host}] Insert failed (duplicate). Checking if plate ${value.plateNumber} already exists...`);
-          const findEndpoint = `/cgi-bin/recordFinder.cgi?action=find&name=${value.mode}&condition.PlateNumber=${plateNumber}`;
-          try {
-            const findResponse = await useDahuaDigestWithRetry({
-              host: value.host,
-              username: value.username,
-              password: value.password,
-              endpoint: findEndpoint,
-              retries: 5
-            });
-            const textData = getDahuaResponseText(findResponse);
-            recno = extractRecNo(textData);
-          } catch (findError) {
-            const findErrorMessage = findError?.message || String(findError);
-            recno = extractRecNo(findErrorMessage);
-            if (!recno) {
-              loggerDahua.error(`[${value.host}] Failed handling existing duplicate plate flow`, findError);
-            }
+        } catch (insertError) {
+          const errorMessage = insertError?.message || String(insertError);
+          if (/recno=/i.test(errorMessage)) {
+            loggerDahua.info(`[${value.host}] Insert confirmed successfully via raw RecNo response text.`);
+            const insertedId = errorMessage.match(/\d+/)?.[0] || "unknown";
+            return {
+              statusCode: 200,
+              data: Buffer.from(`recno=${insertedId}`)
+            };
           }
-          if (recno) {
-            loggerDahua.info(`[${value.host}] Found existing record ID: ${recno}. Updating registration instead...`);
-            const updateEndpoint = `/cgi-bin/recordUpdater.cgi?action=update&name=${value.mode}&recno=${recno}&PlateNumber=${plateNumber}&BeginTime=${beginTime}&CancelTime=${cancelTime}&MasterOfCar=${ownerName}`;
+          const duplicate = errorMessage.includes("Bad Request") || errorMessage.includes("Dahua response: Error");
+          const lostInFlight = !insertError?.answeredByCamera && classifyDahuaAttempt({ error: insertError }) === "maybe-sent";
+          if (duplicate || lostInFlight) {
+            loggerDahua.info(
+              `[${value.host}] Insert ${duplicate ? "failed (duplicate)" : "lost its connection"}. Checking if the plate is already on ${value.mode}...`
+            );
+            const findEndpoint = `/cgi-bin/recordFinder.cgi?action=find&name=${value.mode}&condition.PlateNumber=${plateNumber}`;
             try {
-              const updateResponse = await useDahuaDigestWithRetry({
+              const findResponse = await sendCameraCommand({
                 host: value.host,
                 username: value.username,
                 password: value.password,
-                endpoint: updateEndpoint,
-                retries: 5
+                endpoint: findEndpoint,
+                label: `find plate on ${value.mode}`
               });
-              return {
-                ...updateResponse,
-                statusCode: 200,
-                data: Buffer.from(`recno=${recno}`)
-              };
-            } catch (updateError) {
-              const updateErrorMessage = updateError?.message || String(updateError);
-              if (/recno=/i.test(updateErrorMessage) || /ok/i.test(updateErrorMessage)) {
-                loggerDahua.info(`[${value.host}] Update confirmed successfully despite wrapper omission.`);
-                if (!recno) {
-                  recno = extractRecNo(updateErrorMessage);
-                }
+              if (getDahuaStatusCode(findResponse) === 200) {
+                recno = extractRecNo(getDahuaResponseText(findResponse));
+              } else {
+                loggerDahua.error(
+                  `[${value.host}] Plate lookup after a failed insert answered HTTP ${getDahuaStatusCode(findResponse)}`
+                );
+              }
+            } catch (findError) {
+              loggerDahua.error(`[${value.host}] Failed handling existing duplicate plate flow`, findError);
+            }
+            if (recno) {
+              loggerDahua.info(`[${value.host}] Found existing record ID: ${recno}. Updating registration instead...`);
+              const updateEndpoint = `/cgi-bin/recordUpdater.cgi?action=update&name=${value.mode}&recno=${recno}&PlateNumber=${plateNumber}&BeginTime=${beginTime}&CancelTime=${cancelTime}&MasterOfCar=${ownerName}`;
+              try {
+                const updateResponse = await sendCameraCommandExpectingOk({
+                  host: value.host,
+                  username: value.username,
+                  password: value.password,
+                  endpoint: updateEndpoint,
+                  label: `update plate on ${value.mode}`
+                });
                 return {
+                  ...updateResponse,
                   statusCode: 200,
                   data: Buffer.from(`recno=${recno}`)
                 };
+              } catch (updateError) {
+                const updateErrorMessage = updateError?.message || String(updateError);
+                if (/recno=/i.test(updateErrorMessage) || /ok/i.test(updateErrorMessage)) {
+                  loggerDahua.info(`[${value.host}] Update confirmed successfully despite wrapper omission.`);
+                  if (!recno) {
+                    recno = extractRecNo(updateErrorMessage);
+                  }
+                  return {
+                    statusCode: 200,
+                    data: Buffer.from(`recno=${recno}`)
+                  };
+                }
+                throw updateError;
               }
-              throw updateError;
+            }
+            if (lostInFlight && round < INSERT_ROUNDS) {
+              loggerDahua.warn(
+                `[${value.host}] Plate not found after a lost insert; sending the insert again (round ${round + 1}/${INSERT_ROUNDS})`
+              );
+              await sleep(dahuaCommandRetryDelayMs(round));
+              continue;
             }
           }
+          throw insertError;
         }
-        throw insertError;
       }
     } catch (finalError) {
       loggerDahua.error(
@@ -25146,7 +25550,8 @@ function useDahuaService() {
       start: Joi26.string().isoDate().optional().allow("", null),
       end: Joi26.string().isoDate().optional().allow("", null),
       owner: Joi26.string().optional().allow("", null),
-      isOpenGate: Joi26.boolean().optional()
+      isOpenGate: Joi26.boolean().optional(),
+      timezone: Joi26.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
@@ -25162,17 +25567,20 @@ function useDahuaService() {
       mode: value.mode,
       recno: value.recno,
       plateNumber: value.plateNumber,
-      start: value.start,
-      end: value.end,
+      // On the camera's clock (see `dahuaWallClock`); a time already written
+      // for the camera passes through unchanged.
+      start: dahuaWallClock(value.start, value.timezone) ?? value.start,
+      end: dahuaWallClock(value.end, value.timezone) ?? value.end,
       owner: value.owner,
       openGate: _isOpenGate
     });
     try {
-      const response = await useDahuaDigest({
+      const response = await sendCameraCommand({
         host: value.host,
         username: value.username,
         password: value.password,
-        endpoint
+        endpoint,
+        label: `update plate on ${value.mode}`
       });
       return response;
     } catch (error2) {
@@ -25195,14 +25603,16 @@ function useDahuaService() {
       throw new BadRequestError47(`Validation error: ${error.message}`);
     }
     try {
-      const response = await useDahuaDigest({
+      const response = await sendCameraCommand({
         host: value.host,
         username: value.username,
         password: value.password,
         endpoint: buildPlateRemoveEndpoint({
           recno: value.recno,
           mode: value.mode
-        })
+        }),
+        repeatable: false,
+        label: `remove plate from ${value.mode}`
       });
       return anprRevokeOutcome(response);
     } catch (error2) {
@@ -25224,11 +25634,18 @@ function useDahuaService() {
       throw new BadRequestError47(`Validation error: ${error.message}`);
     }
     try {
-      const response = await useDahuaDigest({
+      const findEndpoint = `/cgi-bin/recordFinder.cgi?action=find&name=${value.mode}&condition.PlateNumber=${encodeURIComponent(value.plateNumber)}`;
+      const response = value.requireOk ? await sendCameraCommand({
         host: value.host,
         username: value.username,
         password: value.password,
-        endpoint: `/cgi-bin/recordFinder.cgi?action=find&name=${value.mode}&condition.PlateNumber=${encodeURIComponent(value.plateNumber)}`
+        endpoint: findEndpoint,
+        label: `find plate on ${value.mode}`
+      }) : await useDahuaDigest({
+        host: value.host,
+        username: value.username,
+        password: value.password,
+        endpoint: findEndpoint
       });
       if (value.requireOk) {
         const statusCode = getDahuaStatusCode(response);
@@ -25255,7 +25672,8 @@ function useDahuaService() {
       owner: Joi26.string().optional().allow("", null),
       isOpenGate: Joi26.boolean().optional().allow(null),
       vehicleType: Joi26.string().optional().allow("", null),
-      vehicleColor: Joi26.string().optional().allow("", null)
+      vehicleColor: Joi26.string().optional().allow("", null),
+      timezone: Joi26.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
@@ -25271,17 +25689,20 @@ function useDahuaService() {
       plateNumber: value.plateNumber,
       vehicleType: value.vehicleType,
       vehicleColor: value.vehicleColor,
-      start: value.start,
-      end: value.end,
+      // On the camera's clock (see `dahuaWallClock`).
+      start: dahuaWallClock(value.start, value.timezone) ?? value.start,
+      end: dahuaWallClock(value.end, value.timezone) ?? value.end,
       owner: value.owner,
       openGate: isOpenGateString
     });
     try {
-      const response = await useDahuaDigest({
+      const response = await sendCameraCommand({
         host: value.host,
         username: value.username,
         password: value.password,
-        endpoint
+        endpoint,
+        repeatable: false,
+        label: `bulk add plate to ${value.mode}`
       });
       return response;
     } catch (error2) {
@@ -25335,11 +25756,91 @@ function useDahuaService() {
       throw error2;
     }
   }
+  async function setPlateWindow(value) {
+    const validation = Joi26.object({
+      host: Joi26.string().required(),
+      username: Joi26.string().required(),
+      password: Joi26.string().required(),
+      mode: Joi26.string().valid(...Object.values(ANPRMode)).required(),
+      recno: Joi26.string().required(),
+      plateNumber: Joi26.string().required(),
+      owner: Joi26.string().optional().allow("", null),
+      start: Joi26.string().isoDate().optional().allow("", null),
+      end: Joi26.string().isoDate().optional().allow("", null),
+      timezone: Joi26.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      throw new BadRequestError47(`Validation error: ${error.message}`);
+    }
+    const window = plateWindowOnCamera(value);
+    const endpoint = `/cgi-bin/recordUpdater.cgi?action=update&name=${encodeURIComponent(value.mode)}&recno=${encodeURIComponent(value.recno)}&PlateNumber=${encodeURIComponent(value.plateNumber)}&BeginTime=${encodeURIComponent(window.start)}&CancelTime=${encodeURIComponent(window.end)}&MasterOfCar=${encodeURIComponent(anprOwnerName(value.owner))}`;
+    try {
+      return await sendCameraCommandExpectingOk({
+        host: value.host,
+        username: value.username,
+        password: value.password,
+        endpoint,
+        label: `set plate window on ${value.mode}`
+      });
+    } catch (error2) {
+      loggerDahua.error(
+        `[${value.host}] Error setting plate window: ${error2?.message || error2}`
+      );
+      throw new BadRequestError47(anprWriteReason(error2));
+    }
+  }
+  async function clearPlateList(value) {
+    const validation = Joi26.object({
+      host: Joi26.string().required(),
+      username: Joi26.string().required(),
+      password: Joi26.string().required(),
+      mode: Joi26.string().valid(...Object.values(ANPRMode)).required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      return anprRevokeThrew(`Validation error: ${error.message}`);
+    }
+    loggerDahua.info(`clearPlateList called for host ${value.host} mode ${value.mode}`);
+    try {
+      const response = await sendCameraCommand({
+        host: value.host,
+        username: value.username,
+        password: value.password,
+        endpoint: buildPlateClearEndpoint({ mode: value.mode }),
+        // A long list takes the device a while to empty.
+        timeout: 6e4,
+        deadlineMs: 9e4,
+        label: `clear ${value.mode}`
+      });
+      const outcome = anprRevokeOutcome(response);
+      if (!outcome.ok)
+        return outcome;
+      const text2 = getDahuaResponseText(response);
+      if (!/\bOK\b/i.test(text2)) {
+        loggerDahua.error(
+          `[${value.host}] clearPlateList ${value.mode} answered 200 without OK: ${text2.slice(0, 200)}`
+        );
+        return {
+          ok: false,
+          statusCode: 200,
+          reason: "the camera did not accept the command to clear its list",
+          detail: `the camera answered 200 without OK: ${text2.slice(0, 200)}`
+        };
+      }
+      return outcome;
+    } catch (error2) {
+      loggerDahua.error(`[${value.host}] Error clearing ${value.mode}:`, error2);
+      return anprRevokeThrew(error2);
+    }
+  }
   return {
     getSnapshot,
     listenToCamera,
     addPlateNumber,
     removePlateNumber,
+    clearPlateList,
+    setPlateWindow,
     updatePlateNumber,
     getPlateNumber,
     bulkInsertPlateNumber,
@@ -25781,6 +26282,11 @@ function useSiteCameraRepo() {
         {
           $match: query2
         },
+        // A fixed order, so paging through a site's cameras 20 at a time
+        // cannot skip one camera and return another twice.
+        {
+          $sort: { _id: 1 }
+        },
         {
           $skip: value.page * value.limit
         },
@@ -26743,7 +27249,7 @@ function formatCapabilityTrace(trace) {
 }
 
 // src/services/camera-device-http.service.ts
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash3, randomBytes } from "crypto";
 var DIGEST_UNAUTHORIZED = 401;
 var DIGEST_FORBIDDEN = 403;
 function parseDigestChallenge(header) {
@@ -26759,7 +27265,7 @@ function parseDigestChallenge(header) {
   return out;
 }
 function md5(input) {
-  return createHash2("md5").update(input, "utf8").digest("hex");
+  return createHash3("md5").update(input, "utf8").digest("hex");
 }
 function buildDigestAuthorization(params) {
   const realm = params.challenge.realm ?? "";
@@ -36421,6 +36927,7 @@ import Joi50 from "joi";
 import {
   BadRequestError as BadRequestError90,
   logger as logger66,
+  NotFoundError as NotFoundError25,
   useAtlas as useAtlas54
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId72 } from "mongodb";
@@ -37632,6 +38139,7 @@ function useVehicleService() {
     getVehicleByPlateNumber: _getVehicleByPlateNumber,
     getAllExpiredVehicles: _getAllExpiredVehicles,
     bulkUpsertVehicles: _bulkUpsertVehicles,
+    getLivePlatesBySite: _getLivePlatesBySite,
     findOne
   } = useVehicleRepo();
   const {
@@ -37642,12 +38150,441 @@ function useVehicleService() {
     bulkInsertPlateNumber: _bulkInsertPlateNumber
   } = useDahuaService();
   const { getAllCameraWithPassword: _getAllSiteCameras } = useSiteCameraRepo();
+  const { setPlateWindow: _setPlateWindow } = useDahuaService();
   const { getById: _getById } = useOrgRepo();
   const {
     pushVehicleById: _pushVehicleById,
     pullVehicleByRecNo: _pullVehicleByRecNo
   } = usePersonRepo();
   const { getUnitByBlockLevelUnitNumber: _getUnitByBlockLevelUnitNumber } = useBuildingUnitRepo();
+  async function camerasAt(site, options = {}) {
+    const siteId = String(site ?? "");
+    if (!siteId)
+      return [];
+    const cameras = [];
+    let page = 1;
+    let pages = 1;
+    const limit = 20;
+    do {
+      const siteCameraReq = await _getAllSiteCameras({
+        site: siteId,
+        type: "anpr",
+        ...options.directions ? { direction: options.directions } : {},
+        ...options.activeOnly ? { status: "active" } : {},
+        page,
+        limit
+      });
+      pages = siteCameraReq.pages || 1;
+      cameras.push(...siteCameraReq.items);
+      page++;
+    } while (page <= pages);
+    return cameras;
+  }
+  function allowCamerasAt(site) {
+    return camerasAt(site, {
+      directions: ALLOW_CAMERA_DIRECTIONS,
+      activeOnly: true
+    });
+  }
+  function blockCamerasAt(site) {
+    return camerasAt(site, {
+      directions: BLOCK_CAMERA_DIRECTIONS,
+      activeOnly: true
+    });
+  }
+  function listOf(mode) {
+    return mode === "TrafficBlackList" /* TRAFFIC_BLACKLIST */ ? "blocked" : "allowed";
+  }
+  function listMode(type) {
+    return type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */;
+  }
+  function validDate(value) {
+    if (value === null || value === void 0 || value === "")
+      return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  function cameraWindow(start, end) {
+    const startDate = validDate(start);
+    const endDate = validDate(end);
+    return {
+      ...startDate ? { start: startDate.toISOString() } : {},
+      ...endDate ? { end: endDate.toISOString() } : {}
+    };
+  }
+  const siteZones = /* @__PURE__ */ new Map();
+  async function siteTimezone(site) {
+    const key = String(site ?? "");
+    const cached = siteZones.get(key);
+    if (cached && Date.now() - cached.at < 5 * 6e4)
+      return cached.zone;
+    let zone = resolveSiteTimezone(null);
+    if (key) {
+      try {
+        const found = await useSiteRepo().getSiteById(key);
+        zone = resolveSiteTimezone(found);
+      } catch {
+        zone = resolveSiteTimezone(null);
+      }
+    }
+    siteZones.set(key, { zone, at: Date.now() });
+    return zone;
+  }
+  function blockWindow(vehicleEnd) {
+    const now = /* @__PURE__ */ new Date();
+    let end = validDate(vehicleEnd);
+    if (!end || end.getTime() <= now.getTime()) {
+      end = new Date(now);
+      end.setFullYear(end.getFullYear() + 10);
+    }
+    return { start: now.toISOString(), end: end.toISOString() };
+  }
+  async function findPlateOnCamera(camera, mode, plateNumber) {
+    const text2 = await _getPlateNumber({
+      host: camera.host,
+      username: camera.username,
+      password: camera.password,
+      mode,
+      plateNumber,
+      requireOk: true
+    });
+    return matchingPlateRecords(text2 ?? "", plateNumber);
+  }
+  async function removePlateFromCamera(camera, mode, plateNumber) {
+    if (!normalisePlate(plateNumber)) {
+      return { ...ANPR_NOTHING_TO_REVOKE, changed: false };
+    }
+    let changed = false;
+    const MAX_PASSES = 3;
+    for (let pass = 0; pass <= MAX_PASSES; pass++) {
+      let records;
+      try {
+        records = await findPlateOnCamera(camera, mode, plateNumber);
+      } catch (error) {
+        const outcome = anprRevokeThrew(error);
+        logCameraFailure("plate lookup", camera, outcome.detail);
+        return { ...outcome, changed };
+      }
+      if (!records.length)
+        return { ok: true, reason: "", changed };
+      if (pass === MAX_PASSES)
+        break;
+      for (const record of records) {
+        const outcome = await _removePlateNumber({
+          host: camera.host,
+          username: camera.username,
+          password: camera.password,
+          recno: record.recNo,
+          mode
+        }).catch((error) => anprRevokeThrew(error));
+        if (!outcome?.ok) {
+          logCameraFailure(
+            "plate remove",
+            camera,
+            outcome?.detail ?? "no outcome returned"
+          );
+          return {
+            ...outcome ?? anprRevokeThrew("no outcome returned"),
+            changed
+          };
+        }
+        changed = true;
+      }
+    }
+    logCameraFailure(
+      "plate remove",
+      camera,
+      `plate still listed after ${MAX_PASSES} rounds of removal`
+    );
+    return {
+      ok: false,
+      reason: "the camera did not remove the plate number",
+      detail: `plate still listed after ${MAX_PASSES} rounds of removal`,
+      changed
+    };
+  }
+  async function insertPlateOnCamera(camera, write) {
+    const response = await _addPlateNumber({
+      host: camera.host,
+      username: camera.username,
+      password: camera.password,
+      plateNumber: write.plateNumber,
+      mode: write.mode,
+      owner: write.owner,
+      ...write.start ? { start: write.start } : {},
+      ...write.end ? { end: write.end } : {},
+      timezone: await siteTimezone(camera.site)
+    });
+    const status = response?.statusCode ?? response?.status ?? response?.res?.status;
+    if (status !== 200)
+      throw new Error(`HTTP ${status ?? "none"}`);
+    return String(
+      response?.data?.toString("utf-8")?.split("=")[1]?.trim() ?? ""
+    );
+  }
+  async function ensurePlateOnCamera(camera, write) {
+    const existing = await findPlateOnCamera(
+      camera,
+      write.mode,
+      write.plateNumber
+    );
+    if (!existing.length) {
+      await insertPlateOnCamera(camera, write);
+      return { inserted: true };
+    }
+    const timezone = await siteTimezone(camera.site);
+    const [keep, ...extra] = existing;
+    const now = dahuaWallClock(/* @__PURE__ */ new Date(), timezone);
+    const wanted = {
+      start: dahuaWallClock(write.start, timezone),
+      end: dahuaWallClock(write.end, timezone)
+    };
+    const windowIsRight = wanted.start && wanted.end ? plateWindowMatches(keep, wanted) : (
+      // No dates of its own: any copy that lets it in now will do.
+      Boolean(
+        keep.beginTime && keep.cancelTime && now && (dahuaWallClock(keep.beginTime) ?? "") <= now && (dahuaWallClock(keep.cancelTime) ?? "") > now
+      )
+    );
+    if (!windowIsRight) {
+      await _setPlateWindow({
+        host: camera.host,
+        username: camera.username,
+        password: camera.password,
+        mode: write.mode,
+        recno: keep.recNo,
+        plateNumber: write.plateNumber,
+        owner: write.owner,
+        ...write.start ? { start: write.start } : {},
+        ...write.end ? { end: write.end } : {},
+        timezone
+      });
+    }
+    for (const copy of extra) {
+      const outcome = await _removePlateNumber({
+        host: camera.host,
+        username: camera.username,
+        password: camera.password,
+        recno: copy.recNo,
+        mode: write.mode
+      }).catch((error) => anprRevokeThrew(error));
+      if (!outcome?.ok) {
+        throw new Error(
+          outcome?.reason || "the camera did not remove an old copy of the plate"
+        );
+      }
+    }
+    return { inserted: false };
+  }
+  function cameraJournal() {
+    const steps = [];
+    return {
+      /** A plate was inserted; undo = take it off again. */
+      inserted(camera, mode, plateNumber) {
+        steps.push({
+          camera,
+          undo: () => removePlateFromCamera(camera, mode, plateNumber).then(
+            (outcome) => outcome.ok,
+            () => false
+          )
+        });
+      },
+      /** A plate was removed; undo = put it back as it was. */
+      removed(camera, previous) {
+        steps.push({
+          camera,
+          undo: () => insertPlateOnCamera(camera, previous).then(
+            () => true,
+            () => false
+          )
+        });
+      },
+      /**
+       * Undo everything, newest first. Never throws. Returns the cameras that
+       * could not be put back, so the operator can be told which barrier is
+       * now wrong.
+       */
+      async rollback() {
+        const stranded = [];
+        for (const step of steps.reverse()) {
+          if (!await step.undo())
+            stranded.push(cameraLabel(step.camera));
+        }
+        steps.length = 0;
+        return Array.from(new Set(stranded));
+      }
+    };
+  }
+  function strandedWarning(stranded) {
+    if (!stranded.length)
+      return "";
+    return ` WARNING: ${stranded.join(", ")} could not be put back the way ${stranded.length === 1 ? "it was" : "they were"} - check this plate on ${stranded.length === 1 ? "that camera" : "those cameras"} by hand.`;
+  }
+  async function rollbackCameras(journal, error) {
+    const stranded = await journal.rollback().catch(() => []);
+    if (stranded.length) {
+      logger66.error(
+        `vehicle camera rollback could not restore: ${stranded.join(", ")}`
+      );
+      if (error && typeof error === "object") {
+        error.message = `${error.message ?? ""}${strandedWarning(stranded)}`;
+      }
+    }
+  }
+  async function revokableModes(site, plateNumber, exclude) {
+    const others = [];
+    let siteId = null;
+    try {
+      siteId = new ObjectId72(String(site));
+    } catch {
+      siteId = null;
+    }
+    if (siteId && plateNumber) {
+      const excludeIds = exclude.map((id) => {
+        try {
+          return new ObjectId72(String(id));
+        } catch {
+          return null;
+        }
+      }).filter((id) => id !== null);
+      const base = {
+        site: siteId,
+        plateNumber,
+        status: "active" /* ACTIVE */,
+        _id: { $nin: excludeIds }
+      };
+      const [allowHolder, blockHolder] = await Promise.all([
+        findOne({
+          ...base,
+          $or: [
+            { type: "whitelist" /* WHITELIST */ },
+            { blockedFrom: "whitelist" /* WHITELIST */ }
+          ]
+        }),
+        findOne({ ...base, type: "blocklist" /* BLOCKLIST */ })
+      ]);
+      if (allowHolder)
+        others.push(allowHolder);
+      if (blockHolder)
+        others.push(blockHolder);
+    }
+    const lists = listsToRevoke(others);
+    return [
+      ...lists.allow ? ["TrafficRedList" /* TRAFFIC_REDLIST */] : [],
+      ...lists.block ? ["TrafficBlackList" /* TRAFFIC_BLACKLIST */] : []
+    ];
+  }
+  async function removeFromCameras(cameras, modes, plateNumber, previous, journal, vehicleIsBlocked = false) {
+    const failures = [];
+    for (const camera of cameras) {
+      for (const mode of modes) {
+        if (!mustRevokeFrom(camera.direction, listOf(mode), vehicleIsBlocked)) {
+          continue;
+        }
+        const outcome = await removePlateFromCamera(camera, mode, plateNumber);
+        if (outcome.changed) {
+          journal.removed(camera, { ...previous, plateNumber, mode });
+        }
+        if (!outcome.ok) {
+          failures.push({
+            camera: cameraLabel(camera),
+            reason: outcome.reason || "the camera could not be reached"
+          });
+        }
+      }
+    }
+    return failures;
+  }
+  async function writeToCameras(cameras, write, journal, options = {}) {
+    const failures = [];
+    let recNo = "";
+    for (const camera of cameras) {
+      try {
+        if (options.onlyIfMissing) {
+          const { inserted } = await ensurePlateOnCamera(camera, write);
+          if (inserted)
+            journal.inserted(camera, write.mode, write.plateNumber);
+        } else {
+          recNo = await insertPlateOnCamera(camera, write) || recNo;
+          journal.inserted(camera, write.mode, write.plateNumber);
+        }
+      } catch (error) {
+        logCameraFailure(`write ${write.mode}`, camera, error);
+        failures.push({
+          camera: cameraLabel(camera),
+          reason: anprWriteReason(error)
+        });
+      }
+    }
+    return { failures, recNo };
+  }
+  async function blockOnCameras(vehicle, site, owner, journal) {
+    const plateNumber = String(vehicle.plateNumber ?? "");
+    if (!plateNumber)
+      return;
+    const cameras = await blockCamerasAt(site);
+    if (!cameras.length) {
+      throw new BadRequestError90(anprNoCameraRefusal("blocked"));
+    }
+    const { failures } = await writeToCameras(
+      cameras,
+      {
+        plateNumber,
+        mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+        owner,
+        ...blockWindow(vehicle.end)
+      },
+      journal,
+      { onlyIfMissing: true }
+    );
+    if (failures.length) {
+      throw new BadRequestError90(anprBlockFailureMessage(failures));
+    }
+  }
+  async function unblockOnCameras(vehicle, site, options, journal) {
+    const plateNumber = String(vehicle.plateNumber ?? "");
+    if (!plateNumber)
+      return;
+    const window = cameraWindow(vehicle.start, vehicle.end);
+    if (options.restore) {
+      const allowCameras = await allowCamerasAt(site);
+      const { failures: failures2 } = await writeToCameras(
+        allowCameras,
+        {
+          plateNumber,
+          mode: "TrafficRedList" /* TRAFFIC_REDLIST */,
+          owner: options.owner,
+          ...window
+        },
+        journal,
+        { onlyIfMissing: true }
+      );
+      if (failures2.length) {
+        throw new BadRequestError90(
+          cameraFailureSentence({
+            failures: failures2,
+            operation: "added to",
+            outcome: "unblocked",
+            consequence: "it is still blocked at the barrier"
+          })
+        );
+      }
+    }
+    const revokable = await revokableModes(site, plateNumber, [vehicle._id]);
+    const modes = options.restore ? revokable.filter((mode) => mode === "TrafficBlackList" /* TRAFFIC_BLACKLIST */) : revokable;
+    if (!modes.length)
+      return;
+    const failures = await removeFromCameras(
+      await camerasAt(site, { activeOnly: true }),
+      modes,
+      plateNumber,
+      { owner: options.owner, ...window },
+      journal,
+      true
+    );
+    if (failures.length) {
+      throw new BadRequestError90(anprUnblockFailureMessage(failures));
+    }
+  }
   async function add(value, session, user) {
     const isExternalSession = !!session;
     if (!session) {
@@ -37702,18 +38639,18 @@ function useVehicleService() {
       endDate.setFullYear(endDate.getFullYear() + 10);
       start = startDate.toISOString();
       end = endDate.toISOString();
-      startDateDahua = formatDahuaDate(startDate);
-      endDateDahua = formatDahuaDate(endDate);
+      startDateDahua = start;
+      endDateDahua = end;
     } else {
       if (hasStart) {
         startDate = new Date(value.start);
         start = startDate.toISOString();
-        startDateDahua = formatDahuaDate(startDate);
+        startDateDahua = start;
       }
       if (hasEnd) {
         endDate = new Date(value.end);
         end = endDate.toISOString();
-        endDateDahua = formatDahuaDate(endDate);
+        endDateDahua = end;
       }
     }
     const owner = value.name;
@@ -37726,22 +38663,7 @@ function useVehicleService() {
       let message = "Vehicle plate number needs approval from property management.";
       let siteCameras = [];
       if (value.status && value.status !== "pending" /* PENDING */) {
-        let page = 1;
-        let pages = 1;
-        const limit = 20;
-        do {
-          const siteCameraReq = await _getAllSiteCameras({
-            site: value.site,
-            type: "anpr",
-            direction: ["both", "entry", "residents"],
-            page,
-            limit,
-            status: "active"
-          });
-          pages = siteCameraReq.pages || 1;
-          siteCameras.push(...siteCameraReq.items);
-          page++;
-        } while (page <= pages);
+        siteCameras = isBlocklist ? await blockCamerasAt(value.site) : await allowCamerasAt(value.site);
         logger66.info(
           `addVehicle resolved ${siteCameras.length} site camera(s) for site ${value?.site}`
         );
@@ -37776,7 +38698,10 @@ function useVehicleService() {
               mode: _mode,
               owner,
               ...startDateDahua ? { start: startDateDahua } : {},
-              ...endDateDahua ? { end: endDateDahua } : {}
+              ...endDateDahua ? { end: endDateDahua } : {},
+              // The camera enforces the season pass window on its own clock,
+              // in the site's zone.
+              timezone: await siteTimezone(camera.site ?? value.site)
             };
             try {
               const dahuaResponse = await _addPlateNumber(dahuaPayload);
@@ -37796,8 +38721,7 @@ function useVehicleService() {
               }
               const recNo = String(responseData.split("=")[1]?.trim() ?? "");
               vehicleValue.recNo = recNo;
-              if (recNo)
-                written.push({ camera, recno: recNo, mode: _mode });
+              written.push({ camera, recno: recNo, mode: _mode, plateNumber: plateNumber2 });
               if (value.peopleId && recNo) {
                 await _pushVehicleById(
                   value.peopleId,
@@ -37827,13 +38751,18 @@ function useVehicleService() {
     } catch (error) {
       const stranded = [];
       for (const entry of written) {
-        const outcome = await _removePlateNumber({
+        const usableId = entry.recno && /^\d+$/.test(entry.recno);
+        const outcome = usableId ? await _removePlateNumber({
           host: entry.camera.host,
           username: entry.camera.username,
           password: entry.camera.password,
           recno: entry.recno,
           mode: entry.mode
-        }).catch((removeError) => anprRevokeThrew(removeError));
+        }).catch((removeError) => anprRevokeThrew(removeError)) : await removePlateFromCamera(
+          entry.camera,
+          entry.mode,
+          entry.plateNumber
+        );
         if (!outcome?.ok)
           stranded.push(cameraLabel(entry.camera));
       }
@@ -37859,80 +38788,28 @@ function useVehicleService() {
     if (!session) {
       throw new Error("Unable to start session for vehicle service.");
     }
-    const _mode = type !== "whitelist" /* WHITELIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */;
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      const siteCameras = [];
-      let page = 1;
-      let pages = 1;
-      const limit = 20;
-      do {
-        const siteCameraReq = await _getAllSiteCameras({
-          site,
-          type: "anpr",
-          page,
-          limit
-        });
-        pages = siteCameraReq.pages || 1;
-        siteCameras.push(...siteCameraReq.items);
-        page++;
-      } while (page <= pages);
-      logger66.info(
-        `deleteVehicle resolved ${siteCameras.length} ANPR camera(s) for site ${site}`
-      );
       const vehicle = await findOne({ _id: new ObjectId72(_id) });
       const plateNumber = String(vehicle?.plateNumber ?? "");
-      const failures = [];
-      for (const camera of siteCameras) {
-        const host = camera.host;
-        const username = camera.username;
-        const password = camera.password;
-        const label = cameraLabel(camera);
-        let recnoForCamera = recno;
-        if (plateNumber) {
-          try {
-            const found = parseDahuaFind(
-              await _getPlateNumber({
-                host,
-                username,
-                password,
-                mode: _mode,
-                plateNumber,
-                requireOk: true
-              }) ?? ""
-            );
-            if (!found.exists)
-              continue;
-            if (found.recNo)
-              recnoForCamera = found.recNo;
-          } catch (error) {
-            const outcome2 = anprRevokeThrew(error);
-            logCameraFailure("deleteVehicle lookup", camera, outcome2.detail);
-            failures.push({ camera: label, reason: outcome2.reason });
-            continue;
-          }
-        }
-        if (!recnoForCamera)
-          continue;
-        const outcome = await _removePlateNumber({
-          host,
-          username,
-          password,
-          recno: recnoForCamera,
-          mode: _mode
-        });
-        if (!outcome?.ok) {
-          logCameraFailure(
-            "deleteVehicle revoke",
-            camera,
-            outcome?.detail ?? "no outcome returned"
-          );
-          failures.push({
-            camera: label,
-            reason: outcome?.reason || "the camera could not be reached"
-          });
-        }
-      }
+      const cameraSite = vehicle?.site ?? site;
+      const siteCameras = await camerasAt(cameraSite, { activeOnly: true });
+      logger66.info(
+        `deleteVehicle resolved ${siteCameras.length} ANPR camera(s) for site ${cameraSite}`
+      );
+      const modes = plateNumber ? await revokableModes(cameraSite, plateNumber, [_id]) : [];
+      const failures = await removeFromCameras(
+        siteCameras,
+        modes,
+        plateNumber,
+        {
+          owner: String(vehicle?.name ?? ""),
+          ...cameraWindow(vehicle?.start, vehicle?.end)
+        },
+        journal,
+        vehicle?.type === "blocklist" /* BLOCKLIST */
+      );
       if (failures.length) {
         const message = anprRevokeFailureMessage(failures);
         if (!bypass)
@@ -37942,13 +38819,14 @@ function useVehicleService() {
       await _deleteVehicle(_id, session);
       await _pullVehicleByRecNo(
         recno,
-        { peopleId: vehicle?.peopleId, site, plateNumber },
+        { peopleId: vehicle?.peopleId, site: cameraSite, plateNumber },
         session
       );
       await session.commitTransaction();
       return `Vehicle plate number deleted from ${type} record successfully.`;
     } catch (error) {
       logger66.error("Error in vehicle service delete:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -37963,13 +38841,14 @@ function useVehicleService() {
     const org = await _getById(orgId);
     if (!org)
       throw new BadRequestError90("Org not found");
-    const vehicle = await _getVehicleById(id);
-    const plate = vehicle.plates.find((p) => p._id.toString() === id);
-    const _plateNumber = plate?.plateNumber;
+    const vehicle = await findOne({ _id: new ObjectId72(id) });
     if (!vehicle) {
-      throw new BadRequestError90("Vehicle not found");
+      throw new NotFoundError25("Vehicle not found.");
     }
+    const _plateNumber = String(vehicle.plateNumber ?? "");
     const owner = vehicle.name;
+    const isBlocklist = vehicle.type === "blocklist" /* BLOCKLIST */;
+    const mode = listMode(vehicle.type);
     const hasStart = typeof vehicle.start === "string" ? vehicle.start.trim() !== "" : !!vehicle.start;
     const hasEnd = typeof vehicle.end === "string" ? vehicle.end.trim() !== "" : !!vehicle.end;
     let startDate = null;
@@ -37987,70 +38866,48 @@ function useVehicleService() {
         endDate.setFullYear(endDate.getFullYear() + 10);
       }
     }
-    const startDahua = startDate ? formatDahuaDate(startDate) : "";
-    const endDahua = endDate ? formatDahuaDate(endDate) : "";
+    const startDahua = startDate ? startDate.toISOString() : "";
+    const endDahua = endDate ? endDate.toISOString() : "";
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      const siteCameras = [];
-      let page = 1;
-      let pages = 1;
-      const limit = 20;
-      let value = {};
-      do {
-        const siteCameraReq = await _getAllSiteCameras({
-          site: siteId,
-          type: "anpr",
-          direction: ["both", "entry", "residents"],
-          page,
-          limit
-        });
-        pages = siteCameraReq.pages || 1;
-        siteCameras.push(...siteCameraReq.items);
-        page++;
-      } while (page <= pages);
+      const cameraSite = vehicle.site ?? siteId;
+      const siteCameras = isBlocklist ? await blockCamerasAt(cameraSite) : await allowCamerasAt(cameraSite);
       if (!siteCameras.length) {
         throw new BadRequestError90(anprNoCameraRefusal("approved"));
       }
-      for (const camera of siteCameras) {
-        const { host, username, password } = camera;
-        const dahuaPayload = {
-          host,
-          username,
-          password,
+      const { failures, recNo } = await writeToCameras(
+        siteCameras,
+        {
           plateNumber: _plateNumber,
-          mode: "TrafficRedList" /* TRAFFIC_REDLIST */,
+          mode,
+          owner,
           start: startDahua,
-          end: endDahua,
-          owner
-        };
-        const dahuaResponse = await _addPlateNumber(dahuaPayload);
-        if (dahuaResponse?.statusCode != 200) {
-          logCameraFailure(
-            "approveVehicleById",
-            camera,
-            `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-          );
-          throw new BadRequestError90(
-            anprWriteFailureMessage([
-              {
-                camera: cameraLabel(camera),
-                reason: anprWriteReason(
-                  `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                )
-              }
-            ])
-          );
-        }
-        const responseData = dahuaResponse?.data.toString("utf-8");
-        value.recNo = responseData.split("=")[1]?.trim();
+          end: endDahua
+        },
+        journal
+      );
+      if (failures.length) {
+        throw new BadRequestError90(
+          cameraFailureSentence({
+            failures,
+            operation: "added to",
+            outcome: "approved",
+            consequence: isBlocklist ? "it would still open the barrier" : "it would not open the barrier"
+          })
+        );
       }
-      value.status = "active" /* ACTIVE */;
-      if (vehicle.peopleId && value.recNo) {
+      const value = {
+        status: "active" /* ACTIVE */,
+        // Kept for older readers only - one camera's number, never replayed.
+        ...recNo ? { recNo } : {}
+      };
+      if (vehicle.peopleId && _plateNumber) {
         await _pushVehicleById(
           vehicle.peopleId,
           {
             plateNumber: _plateNumber,
-            recNo: value.recNo
+            recNo
           },
           session
         );
@@ -38065,6 +38922,7 @@ function useVehicleService() {
       return "Vehicle plate number approved and added successfully.";
     } catch (error) {
       logger66.error("Error in vehicle service approving and adding:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -38073,71 +38931,38 @@ function useVehicleService() {
   }
   async function processDeletingExpiredVehicles() {
     const vehicles = await _getAllExpiredVehicles();
+    const sweptIds = vehicles.map((vehicle) => vehicle?._id);
+    const modesByVehicle = /* @__PURE__ */ new Map();
     const { deletableIds, skipped } = await sweepExpiredVehicles(vehicles, {
-      camerasForSite: async (site) => {
-        const cameras = [];
-        let page = 1;
-        let pages = 1;
-        const limit = 20;
-        do {
-          const siteCameraReq = await _getAllSiteCameras({
-            site,
-            type: "anpr",
-            page,
-            limit
-          });
-          pages = siteCameraReq.pages || 1;
-          cameras.push(...siteCameraReq.items);
-          page++;
-        } while (page <= pages);
-        return cameras;
-      },
+      // Every ACTIVE ANPR camera at the site (an inactive one is skipped, as
+      // by every add and update); which of them each list is taken off is
+      // `mustRevokeFrom`.
+      camerasForSite: (site) => camerasAt(site, { activeOnly: true }),
       revoke: async (camera, vehicle) => {
-        const host = camera.host;
-        const username = camera.username;
-        const password = camera.password;
-        const mode = vehicle?.type !== "whitelist" /* WHITELIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */;
         const plateNumber = String(vehicle?.plateNumber ?? "");
-        let recnoForCamera = String(vehicle?.recNo ?? "");
-        if (plateNumber) {
-          try {
-            const found = parseDahuaFind(
-              await _getPlateNumber({
-                host,
-                username,
-                password,
-                mode,
-                plateNumber,
-                requireOk: true
-              }) ?? ""
-            );
-            if (!found.exists)
-              return ANPR_NOTHING_TO_REVOKE;
-            if (found.recNo)
-              recnoForCamera = found.recNo;
-          } catch (error) {
-            const outcome2 = anprRevokeThrew(error);
-            logCameraFailure("expiredVehicle lookup", camera, outcome2.detail);
-            return outcome2;
-          }
-        }
-        if (!recnoForCamera)
+        if (!plateNumber)
           return ANPR_NOTHING_TO_REVOKE;
-        const outcome = await _removePlateNumber({
-          host,
-          username,
-          password,
-          recno: recnoForCamera,
-          mode
-        }).catch((error) => anprRevokeThrew(error));
-        if (!outcome?.ok) {
-          logCameraFailure(
-            "expiredVehicle revoke",
-            camera,
-            outcome?.detail ?? "no outcome returned"
-          );
+        const key = String(vehicle?._id ?? plateNumber);
+        let modes = modesByVehicle.get(key);
+        if (!modes) {
+          modes = revokableModes(vehicle?.site, plateNumber, sweptIds);
+          modesByVehicle.set(key, modes);
+        }
+        let resolved;
+        try {
+          resolved = await modes;
+        } catch (error) {
+          return anprRevokeThrew(error);
+        }
+        for (const mode of resolved) {
+          const blocked = vehicle?.type === "blocklist" /* BLOCKLIST */;
+          if (!mustRevokeFrom(camera.direction, listOf(mode), blocked))
+            continue;
+          const outcome = await removePlateFromCamera(camera, mode, plateNumber);
+          if (!outcome.ok)
+            return outcome;
         }
-        return outcome ?? anprRevokeThrew("no outcome returned");
+        return ANPR_NOTHING_TO_REVOKE;
       },
       cameraLabel
     });
@@ -38164,90 +38989,83 @@ function useVehicleService() {
         "Only property management can reactivate vehicles."
       );
     }
-    const vehicle = await _getVehicleById(id);
-    const plate = vehicle.plates.find((p) => p._id.toString() === id);
-    const _plateNumber = plate?.plateNumber;
+    const vehicle = await findOne({ _id: new ObjectId72(id) });
     if (!vehicle) {
-      throw new BadRequestError90("Vehicle not found");
+      throw new NotFoundError25("Vehicle not found.");
     }
+    const _plateNumber = String(vehicle.plateNumber ?? "");
     const owner = vehicle.name;
-    let startDate = /* @__PURE__ */ new Date();
-    let endDate = new Date(startDate);
-    endDate.setFullYear(endDate.getFullYear() + 10);
-    const startIso = startDate ? startDate.toISOString() : "";
-    const endIso = endDate ? endDate.toISOString() : "";
-    const startDahua = startDate ? formatDahuaDate(startDate) : "";
-    const endDahua = endDate ? formatDahuaDate(endDate) : "";
+    const isBlocklist = vehicle.type === "blocklist" /* BLOCKLIST */;
+    const mode = listMode(vehicle.type);
+    const ownStart = validDate(vehicle.start);
+    const ownEnd = validDate(vehicle.end);
+    let startDate;
+    let endDate;
+    if (ownEnd) {
+      if (ownEnd.getTime() <= Date.now()) {
+        throw new BadRequestError90(
+          `This vehicle's expiry date (${dahuaWallClock(
+            ownEnd,
+            await siteTimezone(vehicle.site ?? siteId)
+          )}) has already passed, so it cannot be restored as it is. Add it again with new dates.`
+        );
+      }
+      startDate = ownStart ?? /* @__PURE__ */ new Date();
+      endDate = ownEnd;
+    } else {
+      startDate = ownStart ?? /* @__PURE__ */ new Date();
+      endDate = new Date(startDate);
+      endDate.setFullYear(endDate.getFullYear() + 10);
+    }
+    const startDahua = startDate.toISOString();
+    const endDahua = endDate.toISOString();
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      let value = {};
-      const siteCameras = [];
-      let page = 1;
-      let pages = 1;
-      const limit = 20;
-      do {
-        const siteCameraReq = await _getAllSiteCameras({
-          site: siteId,
-          type: "anpr",
-          direction: ["both", "entry"],
-          page,
-          limit
-        });
-        pages = siteCameraReq.pages || 1;
-        siteCameras.push(...siteCameraReq.items);
-        page++;
-      } while (page <= pages);
+      const cameraSite = vehicle.site ?? siteId;
+      const siteCameras = isBlocklist ? await blockCamerasAt(cameraSite) : await allowCamerasAt(cameraSite);
       if (!siteCameras.length) {
         throw new BadRequestError90(anprNoCameraRefusal("restored"));
       }
-      for (const camera of siteCameras) {
-        const { host, username, password } = camera;
-        const dahuaPayload = {
-          host,
-          username,
-          password,
+      const { failures, recNo } = await writeToCameras(
+        siteCameras,
+        {
           plateNumber: _plateNumber,
-          mode: "TrafficRedList" /* TRAFFIC_REDLIST */,
+          mode,
+          owner,
           start: startDahua,
-          end: endDahua,
-          owner
-        };
-        const dahuaResponse = await _addPlateNumber(dahuaPayload);
-        if (dahuaResponse?.statusCode !== 200) {
-          logCameraFailure(
-            "reactivateVehicleById",
-            camera,
-            `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-          );
-          throw new BadRequestError90(
-            anprRestoreFailureMessage([
-              {
-                camera: cameraLabel(camera),
-                reason: anprWriteReason(
-                  `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                )
-              }
-            ])
-          );
-        }
-        const responseData = dahuaResponse?.data.toString("utf-8");
-        value.recNo = responseData.split("=")[1]?.trim();
+          end: endDahua
+        },
+        journal
+      );
+      if (failures.length) {
+        throw new BadRequestError90(
+          isBlocklist ? cameraFailureSentence({
+            failures,
+            operation: "added to",
+            outcome: "restored",
+            consequence: "it would still open the barrier"
+          }) : anprRestoreFailureMessage(failures)
+        );
       }
-      value.status = "active" /* ACTIVE */;
-      if (vehicle.peopleId && value.recNo) {
+      if (vehicle.peopleId && _plateNumber) {
         await _pushVehicleById(
           vehicle.peopleId,
           {
             plateNumber: _plateNumber,
-            recNo: value.recNo
+            recNo
           },
           session
         );
       }
       const formattedValue = {
-        ...value,
-        start: startIso,
-        end: endIso,
+        status: "active" /* ACTIVE */,
+        // Kept for older readers only - one camera's number, never replayed.
+        ...recNo ? { recNo } : {},
+        // Dates, not ISO strings: the expiry sweep only matches a BSON Date
+        // (see `expiredVehicleSweepFilter`), so a string here never expired.
+        start: startDate,
+        end: endDate,
         deletedAt: ""
       };
       await _updateVehicleById(id, formattedValue, session);
@@ -38255,21 +39073,62 @@ function useVehicleService() {
       return "Vehicle reactivated successfully.";
     } catch (error) {
       logger66.error("Error in vehicle service reactivation:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
       session.endSession();
     }
   }
-  async function restorePlateOnCamera(payload) {
-    try {
-      const response = await _addPlateNumber(payload);
-      return (response?.statusCode ?? response?.status) === 200;
-    } catch (error) {
-      logger66.error(
-        `Failed to restore plate on camera ${payload.host}: ${error?.message || error}`
+  async function rewriteOnCameras(vehicle, site, next, journal) {
+    const oldPlate = String(vehicle.plateNumber ?? "");
+    const held = listsHeldBy(vehicle);
+    const targets = [];
+    if (held.allow) {
+      targets.push({
+        mode: "TrafficRedList" /* TRAFFIC_REDLIST */,
+        cameras: await allowCamerasAt(site)
+      });
+    }
+    if (held.block) {
+      targets.push({
+        mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+        cameras: await blockCamerasAt(site)
+      });
+    }
+    if (!targets.some((target) => target.cameras.length)) {
+      throw new BadRequestError90(anprNoCameraRefusal("updated"));
+    }
+    const removeModes = next.plateNumber !== oldPlate ? await revokableModes(site, oldPlate, [vehicle._id]) : targets.map((target) => target.mode);
+    const removeFailures = await removeFromCameras(
+      await camerasAt(site, { activeOnly: true }),
+      removeModes,
+      oldPlate,
+      {
+        owner: String(vehicle.name ?? ""),
+        ...cameraWindow(vehicle.start, vehicle.end)
+      },
+      journal,
+      held.block
+    );
+    if (removeFailures.length) {
+      throw new BadRequestError90(
+        anprRevokeFailureMessage(removeFailures, "updated")
+      );
+    }
+    const writeFailures = [];
+    for (const target of targets) {
+      const { failures } = await writeToCameras(
+        target.cameras,
+        { ...next, mode: target.mode },
+        journal
+      );
+      writeFailures.push(...failures);
+    }
+    if (writeFailures.length) {
+      throw new BadRequestError90(
+        anprWriteFailureMessage(writeFailures, "updated")
       );
-      return false;
     }
   }
   async function updateVehicleById(_id, value) {
@@ -38277,241 +39136,75 @@ function useVehicleService() {
     if (!session) {
       throw new Error("Unable to start session for vehicle service.");
     }
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      const vehicle = await _getVehicleById(_id);
-      const plate = vehicle.plates.find((p) => p._id.toString() === _id);
-      const _name = vehicle.name;
-      const _plateNumber = plate?.plateNumber;
-      const _start = vehicle.start;
-      const _end = vehicle.end;
-      const _recNo = plate.recNo;
-      const _type = value.type ? value.type : plate.type;
+      const vehicle = await findOne({ _id: new ObjectId72(_id) });
+      if (!vehicle) {
+        throw new NotFoundError25("Vehicle not found.");
+      }
       if (value.peopleId) {
         value.peopleId = new ObjectId72(value.peopleId);
       }
       const { name, plateNumber, start, end, recNo, type, unit, site, block, level, ...rest } = value;
-      if (_name != name || _plateNumber != plateNumber) {
-        const startDahua = value.start ? formatDahuaDate(new Date(value.start)) : formatDahuaDate(new Date(_start));
-        const endDahua = value.end ? formatDahuaDate(new Date(value.end)) : formatDahuaDate(new Date(_end));
-        if (name || plateNumber || start || end) {
-          const siteCameras = [];
-          let page = 1;
-          let pages = 1;
-          const limit = 20;
-          do {
-            const siteCameraReq = await _getAllSiteCameras({
-              site,
-              type: "anpr",
-              direction: ["both", "entry", "residents"],
-              page,
-              limit
-            });
-            pages = siteCameraReq.pages || 1;
-            siteCameras.push(...siteCameraReq.items);
-            page++;
-          } while (page <= pages);
-          if (!siteCameras.length) {
-            throw new BadRequestError90(anprNoCameraRefusal("updated"));
+      const oldPlate = String(vehicle.plateNumber ?? "");
+      const oldName = String(vehicle.name ?? "");
+      const oldType = String(vehicle.type || "whitelist" /* WHITELIST */);
+      const newPlate = plateNumber ? String(plateNumber).trim() : oldPlate;
+      const newName = name ? String(name) : oldName;
+      const newType = type ? String(type) : oldType;
+      const cameraSite = vehicle.site ?? site;
+      const startDate = validDate(start);
+      const endDate = validDate(end);
+      const datesChanged = !!startDate && startDate.getTime() !== validDate(vehicle.start)?.getTime() || !!endDate && endDate.getTime() !== validDate(vehicle.end)?.getTime();
+      const isLive = vehicle.status === "active" /* ACTIVE */;
+      let typeFields = {};
+      if (newType !== oldType) {
+        if (newPlate !== oldPlate) {
+          throw new BadRequestError90(
+            "Change the plate number and the vehicle type in two separate steps."
+          );
+        }
+        if (newType === "blocklist" /* BLOCKLIST */) {
+          if (isLive) {
+            await blockOnCameras(vehicle, cameraSite, newName, journal);
           }
-          for (const camera of siteCameras) {
-            const { host, username, password } = camera;
-            if (_plateNumber != plateNumber) {
-              const removePlateNumber = {
-                host,
-                username,
-                password,
-                mode: plate.type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-                //whitelist or blocklist
-                recno: _recNo
-              };
-              const responseForDeletion = await _removePlateNumber(
-                removePlateNumber
-              );
-              if (!responseForDeletion?.ok) {
-                logCameraFailure(
-                  "updateVehicleById revoke",
-                  camera,
-                  responseForDeletion?.detail ?? "no outcome returned"
-                );
-                throw new BadRequestError90(
-                  anprRevokeFailureMessage(
-                    [
-                      {
-                        camera: cameraLabel(camera),
-                        reason: responseForDeletion?.reason || "the camera could not be reached"
-                      }
-                    ],
-                    "updated"
-                  )
-                );
-              }
-              const dahuaPayload = {
-                host,
-                username,
-                password,
-                plateNumber,
-                mode: value.type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-                //whitelist or blocklist
-                owner: name,
-                ...startDahua ? { start: startDahua } : {},
-                ...endDahua ? { end: endDahua } : {}
-              };
-              let dahuaResponse;
-              try {
-                dahuaResponse = await _addPlateNumber(dahuaPayload);
-              } catch (error) {
-                logCameraFailure("updateVehicleById write", camera, error);
-                const restored = await restorePlateOnCamera({
-                  ...removePlateNumber,
-                  plateNumber: _plateNumber,
-                  owner: _name,
-                  ...startDahua ? { start: startDahua } : {},
-                  ...endDahua ? { end: endDahua } : {}
-                });
-                throw new BadRequestError90(
-                  anprWriteFailureMessage(
-                    [{ camera: cameraLabel(camera), reason: anprWriteReason(error) }],
-                    "updated"
-                  ) + (restored ? ` The previous plate number ${_plateNumber} is still registered, so nothing has changed.` : ` WARNING: ${_plateNumber} was taken off this camera and could not be put back - it will NOT open the barrier until someone restores it.`)
-                );
-              }
-              if (dahuaResponse?.statusCode !== 200) {
-                logCameraFailure(
-                  "updateVehicleById write",
-                  camera,
-                  `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                );
-                throw new BadRequestError90(
-                  anprWriteFailureMessage(
-                    [
-                      {
-                        camera: cameraLabel(camera),
-                        reason: anprWriteReason(
-                          `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                        )
-                      }
-                    ],
-                    "updated"
-                  )
-                );
-              }
-              const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              value.recNo = responseData.split("=")[1]?.trim();
-              if (value.peopleId && value.recNo) {
-                await _pushVehicleById(
-                  value.peopleId,
-                  {
-                    plateNumber,
-                    recNo: value.recNo
-                  },
-                  session
-                );
-              }
-            } else {
-              const existing = parseDahuaFind(
-                await _getPlateNumber({
-                  host,
-                  username,
-                  password,
-                  mode: _type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-                  plateNumber,
-                  requireOk: true
-                }) ?? ""
-              );
-              if (existing.exists) {
-                const outcome = await _removePlateNumber({
-                  host,
-                  username,
-                  password,
-                  mode: _type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-                  recno: existing.recNo || _recNo
-                });
-                if (!outcome?.ok) {
-                  logCameraFailure(
-                    "updateVehicleById revoke",
-                    camera,
-                    outcome?.detail ?? "no outcome returned"
-                  );
-                  throw new BadRequestError90(
-                    anprRevokeFailureMessage([
-                      {
-                        camera: cameraLabel(camera),
-                        reason: outcome?.reason || "the camera could not be reached"
-                      }
-                    ], "updated")
-                  );
-                }
-              }
-              const dahuaPayload = {
-                host,
-                username,
-                password,
-                plateNumber,
-                // recno: _recNo,
-                mode: _type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-                start: startDahua,
-                end: endDahua,
-                owner: name ? name : _name
-              };
-              let dahuaResponse;
-              try {
-                dahuaResponse = await _addPlateNumber(dahuaPayload);
-              } catch (error) {
-                logCameraFailure("updateVehicleById write", camera, error);
-                const restored = existing.exists ? await restorePlateOnCamera({
-                  ...dahuaPayload,
-                  owner: _name
-                }) : true;
-                throw new BadRequestError90(
-                  anprWriteFailureMessage(
-                    [{ camera: cameraLabel(camera), reason: anprWriteReason(error) }],
-                    "updated"
-                  ) + (restored ? " The vehicle is unchanged and still registered." : ` WARNING: ${plateNumber} was taken off this camera and could not be put back - it will NOT open the barrier until someone restores it.`)
-                );
-              }
-              if (dahuaResponse?.statusCode !== 200) {
-                logCameraFailure(
-                  "updateVehicleById write",
-                  camera,
-                  `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                );
-                throw new BadRequestError90(
-                  anprWriteFailureMessage(
-                    [
-                      {
-                        camera: cameraLabel(camera),
-                        reason: anprWriteReason(
-                          `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                        )
-                      }
-                    ],
-                    "updated"
-                  )
-                );
-              }
-              const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              value.recNo = responseData.split("=")[1]?.trim();
-              if (value.peopleId && value.recNo) {
-                await _pushVehicleById(
-                  value.peopleId,
-                  {
-                    plateNumber,
-                    recNo: value.recNo
-                  },
-                  session
-                );
-              }
-            }
+          typeFields = {
+            type: "blocklist" /* BLOCKLIST */,
+            blockedFrom: oldType === "whitelist" /* WHITELIST */ ? "whitelist" /* WHITELIST */ : String(vehicle.blockedFrom ?? "")
+          };
+        } else {
+          if (isLive) {
+            await unblockOnCameras(
+              vehicle,
+              cameraSite,
+              { restore: true, owner: newName },
+              journal
+            );
           }
+          typeFields = { type: "whitelist" /* WHITELIST */, blockedFrom: "" };
         }
+      } else if (isLive && (newPlate !== oldPlate || newName !== oldName || datesChanged)) {
+        await rewriteOnCameras(
+          vehicle,
+          cameraSite,
+          {
+            plateNumber: newPlate,
+            owner: newName,
+            ...cameraWindow(startDate ?? vehicle.start, endDate ?? vehicle.end)
+          },
+          journal
+        );
       }
       const formattedValue = {
         ...rest,
         ...name && { name },
-        ...plateNumber && { plateNumber },
-        ...start && { start },
-        ...end && { end },
+        ...plateNumber && { plateNumber: newPlate },
+        // Dates, not ISO strings: the expiry sweep only matches a BSON Date
+        // (see `expiredVehicleSweepFilter`), so an end date edited to a string
+        // never expired.
+        ...startDate && { start: startDate },
+        ...endDate && { end: endDate },
         ...block && {
           block: typeof block === "string" ? new ObjectId72(block) : block
         },
@@ -38521,13 +39214,27 @@ function useVehicleService() {
         ...unit && {
           unit: typeof unit === "string" ? new ObjectId72(unit) : unit
         },
-        ...value.recNo && { recNo: value.recNo },
-        ...type && { type: value.type }
+        ...type && { type },
+        ...typeFields
       };
       await _updateVehicleById(_id, formattedValue, session);
+      const peopleId = value.peopleId || vehicle.peopleId;
+      if (isLive && peopleId && newPlate !== oldPlate) {
+        await _pushVehicleById(
+          peopleId,
+          { plateNumber: newPlate, recNo: "" },
+          session
+        );
+        await _pullVehicleByRecNo(
+          "",
+          { peopleId, site: cameraSite, plateNumber: oldPlate },
+          session
+        );
+      }
       await session.commitTransaction();
     } catch (error) {
       logger66.error("Error in vehicle service update:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -38563,25 +39270,12 @@ function useVehicleService() {
       if (sanitizedValues.length === 0) {
         throw new Error("No valid vehicle plate numbers found.");
       }
-      let siteCameras = [];
-      if (site) {
-        let page = 1;
-        let pages = 1;
-        const limit = 20;
-        do {
-          const siteCameraReq = await _getAllSiteCameras({
-            site,
-            type: "anpr",
-            direction: ["both", "entry"],
-            page,
-            limit
-          });
-          pages = siteCameraReq.pages || 1;
-          siteCameras.push(...siteCameraReq.items);
-          page++;
-        } while (page <= pages);
-      }
-      if (!siteCameras.length) {
+      const isBlockRow = (row) => row.type !== "whitelist" /* WHITELIST */;
+      const allowCameras = site ? await allowCamerasAt(site) : [];
+      const blockCameras = site ? await blockCamerasAt(site) : [];
+      const hasAllowRows = sanitizedValues.some((row) => !isBlockRow(row));
+      const hasBlockRows = sanitizedValues.some((row) => isBlockRow(row));
+      if (hasAllowRows && !allowCameras.length || hasBlockRows && !blockCameras.length) {
         throw new Error("No site cameras found.");
       }
       const written = /* @__PURE__ */ new Map();
@@ -38590,58 +39284,63 @@ function useVehicleService() {
         site,
         plateNumber: value.plateNumber
       }));
-      const { deletableIds: savableIds, skipped } = await sweepExpiredVehicles(
-        sweepRows,
-        {
-          camerasForSite: async () => siteCameras,
-          cameraLabel,
-          revoke: async (camera, row) => {
-            const rowId = String(row._id);
-            const vehicleValue = sanitizedValues[Number(rowId)];
-            const plateNumber = vehicleValue.plateNumber;
-            const { host, username, password } = camera;
-            const dahuaPayload = {
-              host,
-              username,
-              password,
-              plateNumber,
-              mode: vehicleValue.type === "whitelist" /* WHITELIST */ ? "TrafficRedList" /* TRAFFIC_REDLIST */ : "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
-              ...vehicleValue.start ? { start: String(vehicleValue.start) } : {},
-              ...vehicleValue.end ? { end: String(vehicleValue.end) } : {},
-              ...vehicleValue.name ? { owner: vehicleValue.name } : {},
-              ...vehicleValue.vehicleModel ? { vehicleType: vehicleValue.vehicleModel } : {},
-              ...vehicleValue.vehicleColor ? { vehicleColor: vehicleValue.vehicleColor } : {}
+      const writeRow = async (camera, row) => {
+        const rowId = String(row._id);
+        const vehicleValue = sanitizedValues[Number(rowId)];
+        const plateNumber = vehicleValue.plateNumber;
+        const { host, username, password } = camera;
+        const dahuaPayload = {
+          host,
+          username,
+          password,
+          plateNumber,
+          mode: vehicleValue.type === "whitelist" /* WHITELIST */ ? "TrafficRedList" /* TRAFFIC_REDLIST */ : "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+          ...vehicleValue.start ? { start: String(vehicleValue.start) } : {},
+          ...vehicleValue.end ? { end: String(vehicleValue.end) } : {},
+          ...vehicleValue.name ? { owner: vehicleValue.name } : {},
+          ...vehicleValue.vehicleModel ? { vehicleType: vehicleValue.vehicleModel } : {},
+          ...vehicleValue.vehicleColor ? { vehicleColor: vehicleValue.vehicleColor } : {},
+          // Dates on the camera's clock, in the site's zone.
+          timezone: await siteTimezone(camera.site ?? site)
+        };
+        try {
+          const dahuaResponse = await _bulkInsertPlateNumber(dahuaPayload);
+          const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
+          const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
+          if (responseStatus !== 200) {
+            logCameraFailure(
+              "bulk add",
+              camera,
+              `HTTP ${responseStatus}: ${responseData.slice(0, 500)}`
+            );
+            return {
+              ok: false,
+              reason: anprWriteReason(`HTTP ${responseStatus}`)
             };
-            try {
-              const dahuaResponse = await _bulkInsertPlateNumber(dahuaPayload);
-              const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
-              const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              if (responseStatus !== 200) {
-                logCameraFailure(
-                  "bulk add",
-                  camera,
-                  `HTTP ${responseStatus}: ${responseData.slice(0, 500)}`
-                );
-                return {
-                  ok: false,
-                  reason: anprWriteReason(`HTTP ${responseStatus}`)
-                };
-              }
-              const recNo = String(responseData.split("=")[1]?.trim() ?? "");
-              if (recNo) {
-                vehicleValue.recNo = vehicleValue.recNo || recNo;
-                const entries = written.get(rowId) ?? [];
-                entries.push({ camera, recno: recNo });
-                written.set(rowId, entries);
-              }
-              return { ok: true, reason: "" };
-            } catch (error) {
-              logCameraFailure("bulk add", camera, error);
-              return { ok: false, reason: anprWriteReason(error) };
-            }
           }
+          const recNo = String(responseData.split("=")[1]?.trim() ?? "");
+          if (recNo) {
+            vehicleValue.recNo = vehicleValue.recNo || recNo;
+            const entries = written.get(rowId) ?? [];
+            entries.push({ camera, recno: recNo });
+            written.set(rowId, entries);
+          }
+          return { ok: true, reason: "" };
+        } catch (error) {
+          logCameraFailure("bulk add", camera, error);
+          return { ok: false, reason: anprWriteReason(error) };
         }
+      };
+      const allowPass = await sweepExpiredVehicles(
+        sweepRows.filter((row) => !isBlockRow(sanitizedValues[Number(row._id)])),
+        { camerasForSite: async () => allowCameras, cameraLabel, revoke: writeRow }
+      );
+      const blockPass = await sweepExpiredVehicles(
+        sweepRows.filter((row) => isBlockRow(sanitizedValues[Number(row._id)])),
+        { camerasForSite: async () => blockCameras, cameraLabel, revoke: writeRow }
       );
+      const savableIds = [...allowPass.deletableIds, ...blockPass.deletableIds];
+      const skipped = [...allowPass.skipped, ...blockPass.skipped];
       const failedRows = [];
       for (const entry of skipped) {
         const stranded = [];
@@ -38686,123 +39385,26 @@ function useVehicleService() {
     if (!session) {
       throw new Error("Unable to start session for vehicle service.");
     }
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      const vehicle = await _getVehicleById(_id);
-      const plate = vehicle.plates.find((p) => p._id.toString() === _id);
-      const _name = value.name ? value.name : vehicle.name;
-      const _plateNumber = plate?.plateNumber;
-      const _start = vehicle.start;
-      const _end = vehicle.end;
-      const _recNo = plate.recNo;
-      const _type = plate.type;
-      if (value.peopleId) {
-        value.peopleId = new ObjectId72(value.peopleId);
+      const vehicle = await findOne({ _id: new ObjectId72(_id) });
+      if (!vehicle) {
+        throw new NotFoundError25("Vehicle not found.");
       }
-      const { site } = value;
-      const startDahua = formatDahuaDate(_start);
-      const endPlus24Hours = _end ? _end : new Date(new Date(_end).getTime() + 24 * 60 * 60 * 1e3);
-      const endDahua = formatDahuaDate(endPlus24Hours);
-      if (_plateNumber) {
-        const siteCameras = [];
-        let page = 1;
-        let pages = 1;
-        const limit = 20;
-        do {
-          const siteCameraReq = await _getAllSiteCameras({
-            site,
-            type: "anpr",
-            direction: ["both", "entry"],
-            page,
-            limit
-          });
-          pages = siteCameraReq.pages || 1;
-          siteCameras.push(...siteCameraReq.items);
-          page++;
-        } while (page <= pages);
-        if (!siteCameras.length) {
-          throw new BadRequestError90(anprNoCameraRefusal("blocked"));
-        }
-        for (const camera of siteCameras) {
-          const { host, username, password } = camera;
-          const removePlateNumber = {
-            host,
-            username,
-            password,
-            mode: _type === "blocklist" /* BLOCKLIST */ ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
-            recno: _recNo
-          };
-          const responseForDeletion = await _removePlateNumber(
-            removePlateNumber
-          );
-          if (!responseForDeletion?.ok) {
-            logCameraFailure(
-              "blocklistVehicles revoke",
-              camera,
-              responseForDeletion?.detail ?? "no outcome returned"
-            );
-            throw new BadRequestError90(
-              anprRevokeFailureMessage(
-                [
-                  {
-                    camera: cameraLabel(camera),
-                    reason: responseForDeletion?.reason || "the camera could not be reached"
-                  }
-                ],
-                "updated"
-              )
-            );
-          }
-          const dahuaPayload = {
-            host,
-            username,
-            password,
-            plateNumber: _plateNumber,
-            mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
-            owner: _name,
-            ...startDahua ? { start: startDahua } : {},
-            ...endDahua ? { end: endDahua } : {}
-          };
-          const dahuaResponse = await _addPlateNumber(dahuaPayload);
-          if (dahuaResponse?.statusCode !== 200) {
-            logCameraFailure(
-              "blocklistVehicles write",
-              camera,
-              `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-            );
-            throw new BadRequestError90(
-              anprBlockFailureMessage([
-                {
-                  camera: cameraLabel(camera),
-                  reason: anprWriteReason(
-                    `HTTP ${dahuaResponse?.statusCode ?? "none"}`
-                  )
-                }
-              ])
-            );
-          }
-          const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-          value.recNo = responseData.split("=")[1]?.trim();
-          const normalizedPlateNumber = _plateNumber;
-          if (value.peopleId && value.recNo) {
-            await _pushVehicleById(
-              value.peopleId,
-              {
-                plateNumber: normalizedPlateNumber,
-                recNo: value.recNo
-              },
-              session
-            );
-          }
-        }
+      const owner = String(value.name || vehicle.name || "");
+      const cameraSite = vehicle.site ?? value.site;
+      if (vehicle.status === "active" /* ACTIVE */) {
+        await blockOnCameras(vehicle, cameraSite, owner, journal);
       }
       const formattedValue = {
         type: "blocklist" /* BLOCKLIST */,
-        recNo: value.recNo
+        blockedFrom: vehicle.type === "whitelist" /* WHITELIST */ ? "whitelist" /* WHITELIST */ : String(vehicle.blockedFrom ?? "")
       };
       await _updateVehicleById(_id, formattedValue, session);
       await session.commitTransaction();
     } catch (error) {
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -38814,85 +39416,222 @@ function useVehicleService() {
     if (!session) {
       throw new Error("Unable to start session for vehicle service.");
     }
+    const journal = cameraJournal();
     try {
       session.startTransaction();
-      const vehicle = await _getVehicleById(_id);
-      const plate = vehicle.plates.find((p) => p._id.toString() === _id);
-      const _plateNumber = plate?.plateNumber;
-      const _recNo = plate.recNo;
+      const vehicle = await findOne({ _id: new ObjectId72(_id) });
+      if (!vehicle) {
+        throw new NotFoundError25("Vehicle not found.");
+      }
+      if (vehicle.type !== "blocklist" /* BLOCKLIST */) {
+        throw new BadRequestError90("This vehicle is not on the blocklist.");
+      }
+      const _plateNumber = String(vehicle.plateNumber ?? "");
+      const cameraSite = vehicle.site ?? value.site;
+      const restore = vehicle.blockedFrom === "whitelist" /* WHITELIST */;
       if (value.peopleId) {
         value.peopleId = new ObjectId72(value.peopleId);
       }
-      const { site } = value;
-      if (_plateNumber) {
-        const siteCameras = [];
-        let page = 1;
-        let pages = 1;
-        const limit = 20;
-        do {
-          const siteCameraReq = await _getAllSiteCameras({
-            site,
-            type: "anpr",
-            direction: ["both", "entry"],
-            page,
-            limit
-          });
-          pages = siteCameraReq.pages || 1;
-          siteCameras.push(...siteCameraReq.items);
-          page++;
-        } while (page <= pages);
-        logger66.info(
-          `removeFromBlocklist resolved ${siteCameras.length} ANPR camera(s)`
+      if (vehicle.status === "active" /* ACTIVE */) {
+        await unblockOnCameras(
+          vehicle,
+          cameraSite,
+          { restore, owner: String(vehicle.name ?? "") },
+          journal
         );
-        for (const camera of siteCameras) {
-          const { host, username, password } = camera;
-          const removePlateNumber = {
-            host,
-            username,
-            password,
-            mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
-            recno: _recNo
-          };
-          const responseForDeletion = await _removePlateNumber(
-            removePlateNumber
-          );
-          if (!responseForDeletion?.ok) {
-            logCameraFailure(
-              "removeFromBlocklist revoke",
-              camera,
-              responseForDeletion?.detail ?? "no outcome returned"
-            );
-            throw new BadRequestError90(
-              anprUnblockFailureMessage([
-                {
-                  camera: cameraLabel(camera),
-                  reason: responseForDeletion?.reason || "the camera could not be reached"
-                }
-              ])
-            );
-          }
-        }
+      }
+      if (restore) {
+        await _updateVehicleById(
+          _id,
+          { type: "whitelist" /* WHITELIST */, blockedFrom: "" },
+          session
+        );
+        await session.commitTransaction();
+        return "Vehicle unblocked and restored to the whitelist.";
       }
       await _deleteVehicle(_id, session);
-      if ((value.peopleId || site) && (_plateNumber || _recNo)) {
+      const peopleId = value.peopleId || vehicle.peopleId;
+      if ((peopleId || cameraSite) && _plateNumber) {
         await _pullVehicleByRecNo(
-          String(_recNo ?? ""),
+          "",
           {
-            peopleId: value.peopleId,
-            site,
+            peopleId,
+            site: cameraSite,
             plateNumber: _plateNumber
           },
           session
         );
       }
       await session.commitTransaction();
+      return "Vehicle removed from the blocklist.";
     } catch (error) {
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
       session.endSession();
     }
   }
+  async function fillCameraLists(site, camera, lists) {
+    let target;
+    if (camera.id) {
+      const stored = (await camerasAt(site)).find(
+        (candidate) => String(candidate._id) === String(camera.id)
+      );
+      if (!stored)
+        throw new NotFoundError25("Camera not found.");
+      target = {
+        ...stored,
+        ...camera.host ? { host: camera.host } : {},
+        ...camera.username ? { username: camera.username } : {},
+        ...camera.password ? { password: camera.password } : {},
+        ...camera.direction ? { direction: camera.direction } : {}
+      };
+    } else {
+      target = {
+        host: String(camera.host ?? ""),
+        username: String(camera.username ?? ""),
+        password: String(camera.password ?? ""),
+        name: camera.name,
+        direction: camera.direction,
+        // Whose clock the season pass windows are written on.
+        site
+      };
+    }
+    const vehicles = await _getLivePlatesBySite(String(site));
+    const unique = (rows) => {
+      const seen = /* @__PURE__ */ new Set();
+      return rows.filter((row) => {
+        const key = normalisePlate(row.plateNumber);
+        if (!key || seen.has(key))
+          return false;
+        seen.add(key);
+        return true;
+      });
+    };
+    const blocked = lists.block ? unique(vehicles.filter((vehicle) => listsHeldBy(vehicle).block)) : [];
+    const allowed = lists.allow ? unique(vehicles.filter((vehicle) => listsHeldBy(vehicle).allow)) : [];
+    const writes = [
+      ...blocked.map((vehicle) => ({
+        plateNumber: String(vehicle.plateNumber),
+        mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+        owner: String(vehicle.name ?? ""),
+        ...blockWindow(vehicle.end)
+      })),
+      ...allowed.map((vehicle) => ({
+        plateNumber: String(vehicle.plateNumber),
+        mode: "TrafficRedList" /* TRAFFIC_REDLIST */,
+        owner: String(vehicle.name ?? ""),
+        ...cameraWindow(vehicle.start, vehicle.end)
+      }))
+    ];
+    const written = { allowed: 0, blocked: 0 };
+    for (const write of writes) {
+      try {
+        await insertPlateOnCamera(target, write);
+      } catch (error) {
+        logCameraFailure("fill camera", target, error);
+        throw new BadRequestError90(
+          `Only ${written.allowed + written.blocked} of ${writes.length} plates could be added to ${cameraLabel(target)} before it stopped: ${anprWriteReason(error)}.`
+        );
+      }
+      if (write.mode === "TrafficBlackList" /* TRAFFIC_BLACKLIST */)
+        written.blocked++;
+      else
+        written.allowed++;
+    }
+    logger66.info(
+      `fillCameraLists wrote ${written.allowed} allowed and ${written.blocked} blocked plate(s) for site ${String(site)}`
+    );
+    return written;
+  }
+  async function newCameraPlateRows(site, direction) {
+    const lists = listsFilledByDirectionChange("", direction);
+    if (!lists.allow && !lists.block)
+      return [];
+    const vehicles = await _getLivePlatesBySite(String(site));
+    const rowsFor = (list) => {
+      const seen = /* @__PURE__ */ new Set();
+      const rows = [];
+      for (const vehicle of vehicles) {
+        const held = listsHeldBy(vehicle);
+        if (list === "blocked" ? !held.block : !held.allow)
+          continue;
+        const key = normalisePlate(vehicle.plateNumber);
+        if (!key || seen.has(key))
+          continue;
+        seen.add(key);
+        rows.push({
+          id: `${list}:${String(vehicle._id)}`,
+          vehicle: String(vehicle._id),
+          list,
+          plateNumber: String(vehicle.plateNumber ?? ""),
+          name: String(vehicle.name ?? ""),
+          block: String(vehicle.blockName ?? ""),
+          level: String(vehicle.levelName ?? ""),
+          unit: String(vehicle.unitName ?? ""),
+          kind: list === "blocked" ? "Blocked" : vehicle.seasonPassType ? "Season pass" : "Whitelist"
+        });
+      }
+      return rows;
+    };
+    return [
+      ...lists.block ? rowsFor("blocked") : [],
+      ...lists.allow ? rowsFor("allowed") : []
+    ];
+  }
+  async function writeVehicleToNewCamera(site, device, vehicleId, list, options = {}) {
+    let siteId;
+    let id;
+    try {
+      siteId = new ObjectId72(String(site));
+      id = new ObjectId72(String(vehicleId));
+    } catch {
+      throw new BadRequestError90("Invalid vehicle or site ID.");
+    }
+    const vehicle = await findOne({
+      _id: id,
+      site: siteId,
+      status: "active" /* ACTIVE */
+    });
+    if (!vehicle)
+      throw new NotFoundError25("Vehicle not found.");
+    const held = listsHeldBy(vehicle);
+    if (list === "blocked" ? !held.block : !held.allow) {
+      throw new BadRequestError90(
+        "This vehicle no longer belongs on that list. Refresh and try again."
+      );
+    }
+    const write = {
+      plateNumber: String(vehicle.plateNumber ?? ""),
+      mode: list === "blocked" ? "TrafficBlackList" /* TRAFFIC_BLACKLIST */ : "TrafficRedList" /* TRAFFIC_REDLIST */,
+      owner: String(vehicle.name ?? ""),
+      ...list === "blocked" ? blockWindow(vehicle.end) : cameraWindow(vehicle.start, vehicle.end)
+    };
+    const target = {
+      host: device.host,
+      username: device.username,
+      password: device.password,
+      name: device.name,
+      direction: device.direction,
+      // Whose clock the season pass window is written on.
+      site: siteId
+    };
+    try {
+      if (options.onlyIfMissing)
+        await ensurePlateOnCamera(target, write);
+      else
+        await insertPlateOnCamera(target, write);
+      return { ok: true };
+    } catch (error) {
+      logCameraFailure("new camera plate", target, error);
+      return {
+        ok: false,
+        reason: anprWriteReason(error),
+        kind: classifyDahuaFailure(error?.message ?? error)
+      };
+    }
+  }
   return {
     add,
     deleteVehicle,
@@ -38902,7 +39641,10 @@ function useVehicleService() {
     updateVehicleById,
     bulkUpsertVehicles,
     blocklistVehicles,
-    removeFromBlocklist
+    removeFromBlocklist,
+    fillCameraLists,
+    newCameraPlateRows,
+    writeVehicleToNewCamera
   };
 }
 
@@ -39084,7 +39826,7 @@ import {
   AppError as AppError17,
   BadRequestError as BadRequestError92,
   logger as logger68,
-  NotFoundError as NotFoundError25,
+  NotFoundError as NotFoundError26,
   UnauthorizedError as UnauthorizedError12
 } from "@7365admin1/node-server-utils";
 
@@ -39231,7 +39973,7 @@ function siteModulesHandlers({
       const actor = await requireSiteWrite2(req, siteId);
       const site = await _getSiteById(siteId);
       if (!site)
-        throw new NotFoundError25("Site not found.");
+        throw new NotFoundError26("Site not found.");
       if (!ownsSite(actor, site))
         throw new UnauthorizedError12("Not authorized.");
       const org = site?.orgId ? await _getOrgById(site.orgId.toString()) : null;
@@ -40426,7 +41168,7 @@ function useBuildingRepo() {
 import {
   BadRequestError as BadRequestError98,
   logger as logger75,
-  NotFoundError as NotFoundError26,
+  NotFoundError as NotFoundError27,
   useAtlas as useAtlas59
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId77 } from "mongodb";
@@ -41039,7 +41781,7 @@ function useBuildingService() {
             session
           );
           if (!file) {
-            throw new NotFoundError26("File not found.");
+            throw new NotFoundError27("File not found.");
           }
         }
       }
@@ -41082,7 +41824,7 @@ function useBuildingService() {
       session.startTransaction();
       const building = await _getById(id);
       if (!building) {
-        throw new NotFoundError26("Building not found.");
+        throw new NotFoundError27("Building not found.");
       }
       const dataFiles = data?.buildingFiles || [];
       const buildingFiles = building?.buildingFiles || [];
@@ -42041,7 +42783,7 @@ import {
   BadRequestError as BadRequestError100,
   logger as logger77,
   useAtlas as useAtlas60,
-  NotFoundError as NotFoundError27
+  NotFoundError as NotFoundError28
 } from "@7365admin1/node-server-utils";
 function useBuildingUnitService() {
   const { add: _add, updateById: _updateById, getById } = useBuildingUnitRepo();
@@ -42063,7 +42805,7 @@ function useBuildingUnitService() {
             session
           );
           if (!file) {
-            throw new NotFoundError27("File not found.");
+            throw new NotFoundError28("File not found.");
           }
         }
       }
@@ -43124,40 +43866,42 @@ function useVehicleController() {
       }
       const { _id, ...rest } = value;
       await requireVehicleReach(req, _id);
-      await _blocklistVehicles(_id, rest);
-      res.json({ message: "Successfully blocked vehicle." });
-      return;
-    } catch (error) {
-      logger79.log({ level: "error", message: error.message });
-      next(error);
-      return;
-    }
-  }
-  async function removeFromBlocklist(req, res, next) {
-    try {
-      const schema2 = Joi57.object({
-        _id: Joi57.string().hex().length(24).required(),
-        site: Joi57.string().hex().length(24).required(),
-        peopleId: Joi57.string().hex().length(24).optional().allow(null, ""),
-        remarks: Joi57.string().optional().allow("", null)
+      await _blocklistVehicles(_id, rest);
+      res.json({ message: "Successfully blocked vehicle." });
+      return;
+    } catch (error) {
+      logger79.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function removeFromBlocklist(req, res, next) {
+    try {
+      const schema2 = Joi57.object({
+        _id: Joi57.string().hex().length(24).required(),
+        site: Joi57.string().hex().length(24).required(),
+        peopleId: Joi57.string().hex().length(24).optional().allow(null, ""),
+        remarks: Joi57.string().optional().allow("", null)
+      });
+      const { error, value } = schema2.validate(
+        {
+          _id: req.params.id,
+          ...req.body
+        },
+        { abortEarly: false }
+      );
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        logger79.log({ level: "error", message: messages });
+        next(new BadRequestError102(messages));
+        return;
+      }
+      const { _id, ...rest } = value;
+      await requireVehicleReach(req, _id);
+      const message = await _removeFromBlocklist(_id, rest);
+      res.json({
+        message: message || "Successfully removed vehicle from blocklist."
       });
-      const { error, value } = schema2.validate(
-        {
-          _id: req.params.id,
-          ...req.body
-        },
-        { abortEarly: false }
-      );
-      if (error) {
-        const messages = error.details.map((d) => d.message).join(", ");
-        logger79.log({ level: "error", message: messages });
-        next(new BadRequestError102(messages));
-        return;
-      }
-      const { _id, ...rest } = value;
-      await requireVehicleReach(req, _id);
-      await _removeFromBlocklist(_id, rest);
-      res.json({ message: "Successfully removed vehicle from blocklist." });
       return;
     } catch (error) {
       logger79.log({ level: "error", message: error.message });
@@ -43187,7 +43931,9 @@ function useVehicleController() {
 // src/services/site-camera.service.ts
 import {
   BadRequestError as BadRequestError103,
-  useAtlas as useAtlas61
+  NotFoundError as NotFoundError29,
+  useAtlas as useAtlas61,
+  logger as logger80
 } from "@7365admin1/node-server-utils";
 function useSiteCameraService() {
   const { add: _add, getAllCameraWithPassword: _getAllCameraWithPassword } = useSiteCameraRepo();
@@ -43260,15 +44006,74 @@ function useSiteCameraService() {
       session.endSession();
     }
   }
+  async function clearPlateLists(site, camera, lists, action = "type-change") {
+    let target;
+    const id = typeof camera === "string" ? camera : "";
+    if (typeof camera === "string") {
+      const cameras = [];
+      let page = 1;
+      let pages = 1;
+      const limit = 20;
+      do {
+        const siteCameraReq = await _getAllCameraWithPassword({
+          site: String(site ?? ""),
+          type: "anpr",
+          page,
+          limit
+        });
+        pages = siteCameraReq.pages || 1;
+        cameras.push(...siteCameraReq.items);
+        page++;
+      } while (page <= pages);
+      target = cameras.find((candidate) => String(candidate._id) === camera);
+      if (!target)
+        throw new NotFoundError29("Camera not found.");
+    } else {
+      target = camera;
+    }
+    const label = cameraLabel(target);
+    const notDone = action === "add" ? "The camera has NOT been added." : action === "sync" ? "No vehicles have been added to it." : "The camera type has NOT been changed.";
+    const cleared = [];
+    const steps = [
+      ...lists.allow ? [{ list: "allowed", mode: "TrafficRedList" /* TRAFFIC_REDLIST */ }] : [],
+      ...lists.block ? [{ list: "blocked", mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */ }] : []
+    ];
+    for (const [index, step] of steps.entries()) {
+      if (index > 0)
+        await new Promise((resolve) => setTimeout(resolve, 3e3));
+      const outcome = await dahuaService.clearPlateList({
+        host: target.host,
+        username: target.username,
+        password: target.password,
+        mode: step.mode
+      });
+      if (!outcome?.ok) {
+        logger80.error(
+          `clearPlateLists could not clear ${step.mode} on camera ${id || target.host}: ${outcome?.detail ?? "no outcome"}`
+        );
+        const listName = step.list === "allowed" ? "allowed list" : "blocklist";
+        const reason = outcome?.reason || "the camera could not be reached";
+        throw new BadRequestError103(
+          cleared.length ? `The allowed list on ${label} was cleared, but its blocklist could not be: ${reason}. ${notDone} Until it is sorted out, whitelist and season pass vehicles will not be let in through this camera. Please check the camera and try again.` : `The ${listName} on ${label} could not be cleared: ${reason}. Nothing on the camera has changed. ${notDone} Please check the camera and try again.`
+        );
+      }
+      cleared.push(step.list);
+    }
+    logger80.info(
+      `clearPlateLists cleared ${cleared.join(" and ") || "nothing"} on camera ${id || target.host}`
+    );
+    return cleared;
+  }
   return {
     add,
     listenToCapturedPlateNumber,
-    updateById
+    updateById,
+    clearPlateLists
   };
 }
 
 // src/controllers/site-camera.controller.ts
-import { BadRequestError as BadRequestError104, NotFoundError as NotFoundError28 } from "@7365admin1/node-server-utils";
+import { BadRequestError as BadRequestError104, NotFoundError as NotFoundError30 } from "@7365admin1/node-server-utils";
 import Joi58 from "joi";
 import { ObjectId as ObjectId78 } from "mongodb";
 
@@ -43399,8 +44204,29 @@ function summariseBulkCameraPlan(results) {
 }
 
 // src/controllers/site-camera.controller.ts
+var CLEARED_ONLY_NOTE = " The camera's plate lists were cleared.";
+function filledNote(filled, cleared = true) {
+  const parts = [
+    ...filled.allowed ? [`${filled.allowed} allowed`] : [],
+    ...filled.blocked ? [`${filled.blocked} blocked`] : []
+  ];
+  const total = filled.allowed + filled.blocked;
+  if (!total) {
+    return cleared ? " The camera's plate lists were cleared; there were no vehicle plates to add." : " There were no vehicle plates to add to the camera.";
+  }
+  const added = `${parts.join(" and ")} ${total === 1 ? "plate was" : "plates were"} added`;
+  return cleared ? ` The camera's plate lists were cleared and ${added} to it.` : ` ${added} to the camera.`;
+}
+function cameraListClearConfirmation(lists) {
+  const what = lists.allow && lists.block ? "its allowed list and its blocklist" : lists.block ? "its blocklist" : "its allowed list";
+  return `This change clears every plate on ${what}, on the camera itself - including plates added directly on the camera. Confirm the change to continue.`;
+}
 function useSiteCameraController() {
-  const { add: _add, updateById: _updateById } = useSiteCameraService();
+  const {
+    add: _add,
+    updateById: _updateById,
+    clearPlateLists: _clearPlateLists
+  } = useSiteCameraService();
   const {
     add: _addOne,
     activeHostsBySite: _activeHostsBySite,
@@ -43422,8 +44248,8 @@ function useSiteCameraController() {
         permissions: cameraManagePermissions(params.type)
       });
     } catch (error) {
-      if (error instanceof NotFoundError28) {
-        throw new NotFoundError28(params.notFound);
+      if (error instanceof NotFoundError30) {
+        throw new NotFoundError30(params.notFound);
       }
       throw error;
     }
@@ -43484,6 +44310,12 @@ function useSiteCameraController() {
     return null;
   }
   async function add(req, res, next) {
+    const clearCameraLists = req.body?.clearCameraLists === true;
+    const skipPlateSync = req.body?.skipPlateSync === true;
+    if (req.body && typeof req.body === "object") {
+      delete req.body.clearCameraLists;
+      delete req.body.skipPlateSync;
+    }
     const data = req.body;
     const refusal = applyDerivedHost(data);
     if (refusal) {
@@ -43502,6 +44334,52 @@ function useSiteCameraController() {
         type: value.type,
         notFound: "Site not found."
       });
+      const isActiveAnpr = !skipPlateSync && String(value.type ?? "").toLowerCase() === "anpr" && String(value.status ?? "active") === "active";
+      const lists = isActiveAnpr ? listsFilledByDirectionChange("", value.direction) : { allow: false, block: false };
+      const willClear = isActiveAnpr && clearCameraLists;
+      let cleared = false;
+      let filled = null;
+      if (willClear || lists.allow || lists.block) {
+        const taken = await _activeHostsBySite(value.site);
+        if (taken.includes(value.host)) {
+          throw new BadRequestError104("ANPR already exist.");
+        }
+        const device = {
+          host: value.host,
+          username: value.username,
+          password: value.password,
+          name: value.name,
+          direction: value.direction
+        };
+        const everything = { allow: true, block: true };
+        if (willClear) {
+          await _clearPlateLists(value.site, device, everything, "add");
+          cleared = true;
+        }
+        if (lists.allow || lists.block) {
+          try {
+            filled = await useVehicleService().fillCameraLists(
+              value.site,
+              device,
+              lists
+            );
+          } catch (error2) {
+            let undone = null;
+            if (willClear) {
+              try {
+                await _clearPlateLists(value.site, device, everything, "add");
+                undone = true;
+              } catch {
+                undone = false;
+              }
+            }
+            if (error2 && typeof error2 === "object") {
+              error2.message = `${error2.message ?? ""} The camera has NOT been added` + (undone === true ? ` and the plates written to it were cleared again.` : undone === false ? `, and the plates written to it could NOT be cleared again - clear them on the camera by hand.` : `. The plates already written to it stay on the camera.`) + ` Please check the camera and try again.`;
+            }
+            throw error2;
+          }
+        }
+      }
       const vehicle = await _add(value);
       await recordConsoleAction({
         action: "camera.added" /* CAMERA_ADDED */,
@@ -43511,8 +44389,10 @@ function useSiteCameraController() {
         after: pickAuditFields("camera.added" /* CAMERA_ADDED */, value)
       });
       res.status(201).json({
-        message: "ANPR(s) added successfully.",
-        data: { vehicle }
+        message: `ANPR(s) added successfully.` + (filled ? filledNote(filled, cleared) : cleared ? CLEARED_ONLY_NOTE : ""),
+        data: { vehicle },
+        ...filled ? { addedPlates: filled } : {},
+        ...cleared ? { clearedLists: ["allowed", "blocked"] } : {}
       });
     } catch (error2) {
       next(error2);
@@ -43608,8 +44488,8 @@ function useSiteCameraController() {
       try {
         await entitleSite({ siteId: site, userId: callerId5(req) });
       } catch (error2) {
-        if (error2 instanceof NotFoundError28) {
-          throw new NotFoundError28("Site not found.");
+        if (error2 instanceof NotFoundError30) {
+          throw new NotFoundError30("Site not found.");
         }
         throw error2;
       }
@@ -43621,6 +44501,12 @@ function useSiteCameraController() {
     }
   }
   async function updateById(req, res, next) {
+    const confirmClearCameraLists = req.body?.confirmClearCameraLists === true;
+    const skipPlateSync = req.body?.skipPlateSync === true;
+    if (req.body && typeof req.body === "object") {
+      delete req.body.confirmClearCameraLists;
+      delete req.body.skipPlateSync;
+    }
     const value = req.body;
     const id = req.params.id ?? "";
     const refusal = applyDerivedHost(value);
@@ -43640,7 +44526,7 @@ function useSiteCameraController() {
     try {
       const camera = await loadForWrite(id);
       if (!camera)
-        throw new NotFoundError28("Camera not found.");
+        throw new NotFoundError30("Camera not found.");
       let staffId = null;
       try {
         await authorizeWrite({
@@ -43655,6 +44541,43 @@ function useSiteCameraController() {
           throw error2;
       }
       const update = staffId ? staffUpdate(camera, value.status) : value;
+      const lists = String(camera.type ?? "").toLowerCase() === "anpr" ? listsClearedByDirectionChange(camera.direction, update?.direction) : { allow: false, block: false };
+      let clearedLists = null;
+      if (lists.allow || lists.block) {
+        if (!confirmClearCameraLists) {
+          throw new BadRequestError104(cameraListClearConfirmation(lists));
+        }
+        clearedLists = await _clearPlateLists(camera.site, id, lists);
+      }
+      const fill = !skipPlateSync && String(camera.type ?? "").toLowerCase() === "anpr" && String(update?.status ?? camera.status ?? "active") === "active" ? listsFilledByDirectionChange(camera.direction, update?.direction) : { allow: false, block: false };
+      let filled = null;
+      if (fill.allow || fill.block) {
+        await _clearPlateLists(camera.site, id, fill);
+        try {
+          filled = await useVehicleService().fillCameraLists(
+            camera.site,
+            {
+              id,
+              host: update?.host,
+              username: update?.username,
+              password: update?.password
+            },
+            fill
+          );
+        } catch (error2) {
+          let undone = false;
+          try {
+            await _clearPlateLists(camera.site, id, fill);
+            undone = true;
+          } catch {
+            undone = false;
+          }
+          if (error2 && typeof error2 === "object") {
+            error2.message = `${error2.message ?? ""} The camera type has NOT been changed` + (undone ? ` and the plates written to it were cleared again.` : `, and the plates written to it could NOT be cleared again - clear them on the camera by hand.`) + ` Please check the camera and try again.`;
+          }
+          throw error2;
+        }
+      }
       const message = await _updateById(id, update);
       if (staffId) {
         await recordConsoleAction({
@@ -43676,8 +44599,11 @@ function useSiteCameraController() {
           after: pickAuditFields("camera.updated" /* CAMERA_UPDATED */, update)
         });
       }
+      const clearedNote = clearedLists === null ? "" : clearedLists.length === 2 ? " The camera's allowed list and blocklist were cleared." : clearedLists[0] === "blocked" ? " The camera's blocklist was cleared." : " The camera's allowed list was cleared.";
       res.json({
-        message
+        message: `${message}${clearedNote}${filled ? filledNote(filled) : ""}`,
+        ...clearedLists === null ? {} : { clearedLists },
+        ...filled ? { addedPlates: filled } : {}
       });
     } catch (error2) {
       next(error2);
@@ -43696,7 +44622,7 @@ function useSiteCameraController() {
     try {
       const camera = await loadForWrite(id);
       if (!camera)
-        throw new NotFoundError28("Camera not found.");
+        throw new NotFoundError30("Camera not found.");
       await authorizeWrite({
         req,
         site: camera.site,
@@ -43718,12 +44644,216 @@ function useSiteCameraController() {
       next(error2);
     }
   }
+  const schemaNewCameraDevice = {
+    host: Joi58.string().trim().required(),
+    username: Joi58.string().required(),
+    password: Joi58.string().required(),
+    name: Joi58.string().optional().allow("", null),
+    direction: Joi58.string().required().valid("entry", "exit", "both", "visitors", "residents")
+  };
+  async function authorizeNewCamera(req, siteId, host) {
+    await authorizeWrite({
+      req,
+      site: siteId,
+      type: "anpr",
+      notFound: "Site not found."
+    });
+    const taken = await _activeHostsBySite(siteId);
+    if (taken.includes(host)) {
+      throw new BadRequestError104("ANPR already exist.");
+    }
+  }
+  async function newCameraPlates(req, res, next) {
+    const { error, value } = Joi58.object({
+      siteId: Joi58.string().hex().length(24).required(),
+      host: Joi58.string().trim().required(),
+      direction: schemaNewCameraDevice.direction
+    }).validate({
+      siteId: req.params.siteId,
+      host: req.query?.host,
+      direction: req.query?.direction
+    });
+    if (error) {
+      next(new BadRequestError104(error.message));
+      return;
+    }
+    try {
+      await authorizeNewCamera(req, value.siteId, value.host);
+      const items = await useVehicleService().newCameraPlateRows(
+        value.siteId,
+        value.direction
+      );
+      res.json({ items });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function clearNewCamera(req, res, next) {
+    const { error, value } = Joi58.object({
+      siteId: Joi58.string().hex().length(24).required(),
+      ...schemaNewCameraDevice
+    }).validate({ siteId: req.params.siteId, ...req.body ?? {} });
+    if (error) {
+      next(new BadRequestError104(error.message));
+      return;
+    }
+    try {
+      await authorizeNewCamera(req, value.siteId, value.host);
+      const { siteId, ...device } = value;
+      const cleared = await _clearPlateLists(
+        siteId,
+        device,
+        { allow: true, block: true },
+        "add"
+      );
+      res.json({
+        message: "The camera's allowed list and blocklist were cleared.",
+        clearedLists: cleared
+      });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function addNewCameraPlate(req, res, next) {
+    const { error, value } = Joi58.object({
+      siteId: Joi58.string().hex().length(24).required(),
+      ...schemaNewCameraDevice,
+      vehicle: Joi58.string().hex().length(24).required(),
+      list: Joi58.string().valid("allowed", "blocked").required(),
+      onlyIfMissing: Joi58.boolean().optional().default(false)
+    }).validate({ siteId: req.params.siteId, ...req.body ?? {} });
+    if (error) {
+      next(new BadRequestError104(error.message));
+      return;
+    }
+    try {
+      await authorizeNewCamera(req, value.siteId, value.host);
+      const { siteId, vehicle, list, onlyIfMissing, ...device } = value;
+      const outcome = await useVehicleService().writeVehicleToNewCamera(
+        siteId,
+        device,
+        vehicle,
+        list,
+        { onlyIfMissing }
+      );
+      res.json(outcome);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function loadForSync(req, id) {
+    if (!ObjectId78.isValid(id))
+      throw new NotFoundError30("Camera not found.");
+    const camera = await _findOne(
+      { _id: new ObjectId78(id) },
+      {
+        site: 1,
+        type: 1,
+        host: 1,
+        username: 1,
+        password: 1,
+        name: 1,
+        direction: 1,
+        status: 1
+      }
+    );
+    if (!camera)
+      throw new NotFoundError30("Camera not found.");
+    await authorizeWrite({
+      req,
+      site: camera.site,
+      type: camera.type,
+      notFound: "Camera not found."
+    });
+    if (String(camera.type ?? "").toLowerCase() !== "anpr") {
+      throw new BadRequestError104("Only ANPR cameras hold vehicle plates.");
+    }
+    if (String(camera.status ?? "active") !== "active") {
+      throw new BadRequestError104(
+        "This camera is inactive. Switch it on before adding vehicles to it."
+      );
+    }
+    const lists = listsFilledByDirectionChange("", camera.direction);
+    if (!lists.allow && !lists.block) {
+      throw new BadRequestError104("Exit cameras receive no vehicle plates.");
+    }
+    return {
+      site: String(camera.site ?? ""),
+      device: {
+        host: String(camera.host ?? ""),
+        username: String(camera.username ?? ""),
+        password: String(camera.password ?? ""),
+        name: camera.name ?? "",
+        direction: String(camera.direction ?? "")
+      }
+    };
+  }
+  async function cameraPlates(req, res, next) {
+    try {
+      const { site, device } = await loadForSync(req, String(req.params.id));
+      const items = await useVehicleService().newCameraPlateRows(
+        site,
+        device.direction
+      );
+      res.json({ items });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function clearCamera(req, res, next) {
+    try {
+      const { site, device } = await loadForSync(req, String(req.params.id));
+      const cleared = await _clearPlateLists(
+        site,
+        device,
+        { allow: true, block: true },
+        "sync"
+      );
+      res.json({
+        message: "The camera's allowed list and blocklist were cleared.",
+        clearedLists: cleared
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function addCameraPlate(req, res, next) {
+    const { error, value } = Joi58.object({
+      vehicle: Joi58.string().hex().length(24).required(),
+      list: Joi58.string().valid("allowed", "blocked").required(),
+      onlyIfMissing: Joi58.boolean().optional().default(true)
+    }).validate(req.body ?? {});
+    if (error) {
+      next(new BadRequestError104(error.message));
+      return;
+    }
+    try {
+      const { site, device } = await loadForSync(req, String(req.params.id));
+      const outcome = await useVehicleService().writeVehicleToNewCamera(
+        site,
+        device,
+        value.vehicle,
+        value.list,
+        // Absent means look first: a saved camera may already hold the plate.
+        { onlyIfMissing: value.onlyIfMissing !== false }
+      );
+      res.json(outcome);
+    } catch (error2) {
+      next(error2);
+    }
+  }
   return {
     add,
     addBulk,
     getAll,
     updateById,
-    deleteById
+    deleteById,
+    newCameraPlates,
+    clearNewCamera,
+    addNewCameraPlate,
+    cameraPlates,
+    clearCamera,
+    addCameraPlate
   };
 }
 
@@ -43888,7 +45018,7 @@ function useCameraViewController() {
 import {
   BadRequestError as BadRequestError106,
   useAtlas as useAtlas62,
-  NotFoundError as NotFoundError29
+  NotFoundError as NotFoundError31
 } from "@7365admin1/node-server-utils";
 
 // src/utils/site-name.util.ts
@@ -43995,7 +45125,7 @@ function useCustomerSiteService() {
       const siteIdStr = siteId.toString();
       const orgData = await _getByOrgId(value.siteOrg);
       if (!orgData) {
-        throw new NotFoundError29("Organization not found.");
+        throw new NotFoundError31("Organization not found.");
       }
       if (!orgData.defaultSite) {
         const updateOrgField = await _updateFieldById(
@@ -44029,7 +45159,7 @@ function useCustomerSiteService() {
     try {
       const verification = await getVerificationById(invite);
       if (!verification) {
-        throw new NotFoundError29("Invite not found.");
+        throw new NotFoundError31("Invite not found.");
       }
       const siteId = verification.metadata?.siteId?.toString() ?? "";
       if (!siteId) {
@@ -44041,17 +45171,17 @@ function useCustomerSiteService() {
       }
       const org = await _getByOrgId(orgId);
       if (!org) {
-        throw new NotFoundError29("Organization not found.");
+        throw new NotFoundError31("Organization not found.");
       }
       const site = await getSiteById(siteId);
       if (!site) {
-        throw new NotFoundError29("Site not found.");
+        throw new NotFoundError31("Site not found.");
       }
       const serviceProvider = await getOrgByEmail(
         String(verification.email ?? "").trim().toLowerCase()
       );
       if (!serviceProvider) {
-        throw new NotFoundError29("Organization not found.");
+        throw new NotFoundError31("Organization not found.");
       }
       const providerOrgId = serviceProvider._id?.toString() ?? "";
       const alreadyEngaged = await _countActiveByOrgAndSite(
@@ -44066,7 +45196,7 @@ function useCustomerSiteService() {
         return "This site is already on your list.";
       }
       if (verification.status === "awaiting-approval") {
-        throw new NotFoundError29("Invite not found.");
+        throw new NotFoundError31("Invite not found.");
       }
       if (verification.status && verification.status !== "pending") {
         throw new BadRequestError106(
@@ -44112,7 +45242,7 @@ function useCustomerSiteService() {
     try {
       const customerSite = await _getById(customerSiteId);
       if (!customerSite) {
-        throw new NotFoundError29("Customer site not found.");
+        throw new NotFoundError31("Customer site not found.");
       }
       const siteId = customerSite.site;
       await updateSiteById(
@@ -44442,7 +45572,7 @@ import {
   useCache as useCache34,
   logger as logger83,
   makeCacheKey as makeCacheKey29,
-  NotFoundError as NotFoundError30
+  NotFoundError as NotFoundError32
 } from "@7365admin1/node-server-utils";
 function useAttendanceSettingsRepository() {
   const db2 = useAtlas63.getDb();
@@ -44544,7 +45674,7 @@ function useAttendanceSettingsRepository() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError30("Attendance settings not found for this site.");
+        throw new NotFoundError32("Attendance settings not found for this site.");
       }
       delNamespace().then(() => {
         logger83.info(`Cache cleared for namespace: ${namespace_collection3}`);
@@ -44729,7 +45859,7 @@ import {
   useCache as useCache35,
   logger as logger87,
   makeCacheKey as makeCacheKey30,
-  NotFoundError as NotFoundError31
+  NotFoundError as NotFoundError33
 } from "@7365admin1/node-server-utils";
 function useAttendanceRepository() {
   const db2 = useAtlas65.getDb();
@@ -45074,7 +46204,7 @@ function useAttendanceRepository() {
         }
       ]).toArray();
       if (!data || data.length === 0) {
-        throw new NotFoundError31("Attendance not found.");
+        throw new NotFoundError33("Attendance not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger87.info(`Cache set for key: ${cacheKey}`);
@@ -45108,7 +46238,7 @@ function useAttendanceRepository() {
     try {
       const data = await collection.aggregate([{ $match: query2 }]).toArray();
       if (!data || data.length === 0) {
-        throw new NotFoundError31("Attendance not found.");
+        throw new NotFoundError33("Attendance not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger87.info(`Cache set for key: ${cacheKey}`);
@@ -45539,7 +46669,7 @@ import { ObjectId as ObjectId90 } from "mongodb";
 import {
   BadRequestError as BadRequestError118,
   logger as logger90,
-  NotFoundError as NotFoundError34,
+  NotFoundError as NotFoundError36,
   useAtlas as useAtlas68,
   hashPassword as hashPassword3,
   useMailer as useMailer3,
@@ -45552,14 +46682,14 @@ import { ObjectId as ObjectId85 } from "mongodb";
 import {
   BadRequestError as BadRequestError117,
   InternalServerError as InternalServerError42,
-  NotFoundError as NotFoundError33
+  NotFoundError as NotFoundError35
 } from "@7365admin1/node-server-utils";
 
 // src/repositories/platform-terms.repo.ts
 import {
   BadRequestError as BadRequestError116,
   InternalServerError as InternalServerError41,
-  NotFoundError as NotFoundError32,
+  NotFoundError as NotFoundError34,
   useAtlas as useAtlas67
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId84 } from "mongodb";
@@ -45658,7 +46788,7 @@ function usePlatformTermsRepo() {
     try {
       _id = new ObjectId84(id);
     } catch {
-      throw new NotFoundError32("Terms version not found.");
+      throw new NotFoundError34("Terms version not found.");
     }
     let data;
     try {
@@ -45667,7 +46797,7 @@ function usePlatformTermsRepo() {
       throw new InternalServerError41("Failed to retrieve terms version.");
     }
     if (!data) {
-      throw new NotFoundError32("Terms version not found.");
+      throw new NotFoundError34("Terms version not found.");
     }
     return data;
   }
@@ -45680,7 +46810,7 @@ function usePlatformTermsRepo() {
       throw new InternalServerError41("Failed to retrieve latest terms.");
     }
     if (!data) {
-      throw new NotFoundError32("No terms version found.");
+      throw new NotFoundError34("No terms version found.");
     }
     return data;
   }
@@ -45777,14 +46907,14 @@ function usePlatformTermsService() {
     const latest = await _getLatest();
     const record = await _getAcceptedTerms(userId);
     if (!record) {
-      throw new NotFoundError33("User not found.");
+      throw new NotFoundError35("User not found.");
     }
     return buildStatus(latest, record);
   }
   async function acceptByUserId(userId, termsId, session) {
     const latest = await assertLatestTerms(termsId);
     if (!await _getAcceptedTerms(userId, session)) {
-      throw new NotFoundError33("User not found.");
+      throw new NotFoundError35("User not found.");
     }
     await _setAcceptedTerms(userId, latest._id, session);
     return { acceptedTerms: latest._id, version: latest.version };
@@ -45792,7 +46922,7 @@ function usePlatformTermsService() {
   async function resolveTermsPrincipal(personId) {
     const person = await _getPersonById(personId);
     if (!person || person.status === "deleted") {
-      throw new NotFoundError33("Person not found.");
+      throw new NotFoundError35("Person not found.");
     }
     return person.user ? { userId: person.user } : { userId: null };
   }
@@ -45804,7 +46934,7 @@ function usePlatformTermsService() {
     const latest = await _getLatest();
     const record = await _getPersonAcceptedTerms(personId);
     if (!record) {
-      throw new NotFoundError33("Person not found.");
+      throw new NotFoundError35("Person not found.");
     }
     return buildStatus(latest, record);
   }
@@ -45827,7 +46957,7 @@ function usePlatformTermsService() {
     if (version) {
       const found = await _getByVersion(version);
       if (!found) {
-        throw new NotFoundError33("Terms version not found.");
+        throw new NotFoundError35("Terms version not found.");
       }
       terms = found._id;
     }
@@ -45920,7 +47050,7 @@ function usePersonService() {
             session
           );
           if (!file) {
-            throw new NotFoundError34("File not found.");
+            throw new NotFoundError36("File not found.");
           }
         }
       }
@@ -46274,7 +47404,7 @@ function usePersonService() {
       session.startTransaction();
       const person = await _getByUserId(id.toString());
       if (!person)
-        throw new NotFoundError34("Person not found.");
+        throw new NotFoundError36("Person not found.");
       await _updateById(person._id, { status: "deleted" }, session);
       if (person.user) {
         await _updateUserFieldById(
@@ -47377,7 +48507,7 @@ import axios from "axios";
 import {
   BadRequestError as BadRequestError121,
   InternalServerError as InternalServerError44,
-  NotFoundError as NotFoundError35,
+  NotFoundError as NotFoundError37,
   UnauthorizedError as UnauthorizedError14,
   logger as logger93
 } from "@7365admin1/node-server-utils";
@@ -50932,14 +52062,14 @@ function useHidAmicoService() {
     try {
       reader = await repo.getById(readerId, options);
     } catch {
-      throw new NotFoundError35(HID_READER_NOT_FOUND);
+      throw new NotFoundError37(HID_READER_NOT_FOUND);
     }
     try {
       await authorizeSiteForCaller(String(reader.site || ""), userId);
     } catch (error) {
       if (error instanceof UnauthorizedError14)
         throw error;
-      throw new NotFoundError35(HID_READER_NOT_FOUND);
+      throw new NotFoundError37(HID_READER_NOT_FOUND);
     }
     return reader;
   }
@@ -50948,7 +52078,7 @@ function useHidAmicoService() {
     try {
       reader = await repo.getById(readerId);
     } catch {
-      throw new NotFoundError35(HID_READER_NOT_FOUND);
+      throw new NotFoundError37(HID_READER_NOT_FOUND);
     }
     try {
       await useCameraViewService().entitleSite({
@@ -50956,7 +52086,7 @@ function useHidAmicoService() {
         userId
       });
     } catch {
-      throw new NotFoundError35(HID_READER_NOT_FOUND);
+      throw new NotFoundError37(HID_READER_NOT_FOUND);
     }
     return reader;
   }
@@ -54926,7 +56056,7 @@ function useVisitorTransactionService() {
 import Joi69 from "joi";
 import moment5 from "moment-timezone";
 import { ObjectId as ObjectId93 } from "mongodb";
-import { BadRequestError as BadRequestError124, NotFoundError as NotFoundError37, InternalServerError as InternalServerError46, UnauthorizedError as UnauthorizedError15, logger as logger97 } from "@7365admin1/node-server-utils";
+import { BadRequestError as BadRequestError124, NotFoundError as NotFoundError39, InternalServerError as InternalServerError46, UnauthorizedError as UnauthorizedError15, logger as logger97 } from "@7365admin1/node-server-utils";
 
 // src/models/visitor-invite.model.ts
 import Joi67 from "joi";
@@ -59181,7 +60311,7 @@ function useVisitorTransactionController() {
       const status = onboardingSettings?.enabled ? "approved" /* APPROVED */ : "pending" /* PENDING */;
       const site = await _getSiteById(siteId);
       if (!site) {
-        next(new NotFoundError37("Site not found."));
+        next(new NotFoundError39("Site not found."));
         return;
       }
       const { error, value } = schemaSelfServiceVisitor.validate(req.body, {
@@ -59280,7 +60410,7 @@ function useVisitorTransactionController() {
       }
       const data = await _getSelfServiceVisitorPreview(id);
       if (!data) {
-        next(new NotFoundError37("Registration not found."));
+        next(new NotFoundError39("Registration not found."));
         return;
       }
       res.status(200).json({
@@ -59337,7 +60467,7 @@ function useVisitorTransactionController() {
       });
       if (!decision.ok) {
         if (decision.httpStatus === 404) {
-          next(new NotFoundError37(decision.reason));
+          next(new NotFoundError39(decision.reason));
           return;
         }
         if (decision.httpStatus === 429) {
@@ -60277,7 +61407,22 @@ function useGuestManagementController() {
 // src/controllers/person.controller.ts
 import Joi72 from "joi";
 import { BadRequestError as BadRequestError127, logger as logger100 } from "@7365admin1/node-server-utils";
-import { NotFoundError as NotFoundError38, UnauthorizedError as UnauthorizedError16 } from "@7365admin1/node-server-utils";
+import { NotFoundError as NotFoundError40, UnauthorizedError as UnauthorizedError16 } from "@7365admin1/node-server-utils";
+
+// src/utils/people-create-gate.util.ts
+var PEOPLE_CREATE_REACH_MODE_DEFAULT = "log";
+function peopleCreateReachMode(env2 = process.env) {
+  return gateMode(
+    env2.PEOPLE_CREATE_REACH_MODE,
+    ["log", "enforce", "off"],
+    PEOPLE_CREATE_REACH_MODE_DEFAULT
+  );
+}
+function peopleCreateVerdict(params) {
+  if (params.mode === "off" || params.reachable)
+    return { refuse: false, record: false };
+  return { refuse: params.mode === "enforce", record: true };
+}
 
 // src/utils/self-signup-files.util.ts
 function dropUnsentFiles(body) {
@@ -60321,7 +61466,7 @@ function usePersonController() {
       return actor;
     const person = await _getById(_id);
     if (!person)
-      throw new NotFoundError38("Person not found.");
+      throw new NotFoundError40("Person not found.");
     const site = person.site?.toString() ?? "";
     if (site) {
       await useCameraViewService().entitleSite({ siteId: site, userId: actor.id });
@@ -60387,6 +61532,41 @@ function usePersonController() {
       next(new BadRequestError127(messages));
       return;
     }
+    try {
+      const mode = peopleCreateReachMode();
+      if (mode !== "off") {
+        const actor = await resolveInviteActor(callerId(req));
+        let reachable = true;
+        if (!staffMayBypass(actor)) {
+          const site = payload?.site ? String(payload.site) : "";
+          const org = payload?.org ? String(payload.org) : "";
+          if (site) {
+            reachable = await useCameraViewService().entitleSite({ siteId: site, userId: actor.id }).then(
+              () => true,
+              () => false
+            );
+          } else if (org) {
+            reachable = actor.orgIds.includes(org);
+          }
+        }
+        const verdict = peopleCreateVerdict({ mode, reachable });
+        if (verdict.record) {
+          logger100.log({
+            level: "info",
+            message: `[people-create] ${verdict.refuse ? "refused" : "would-refuse"} caller=${actor.id} site=${payload?.site ?? ""} org=${payload?.org ?? ""} mode=${mode}`
+          });
+        }
+        if (verdict.refuse) {
+          next(new UnauthorizedError16("Not authorized."));
+          return;
+        }
+      }
+    } catch (gateError) {
+      logger100.log({
+        level: "warn",
+        message: `[people-create] reach check failed open: ${gateError?.message}`
+      });
+    }
     try {
       const data = await _add(payload);
       res.status(201).json({ message: data });
@@ -61714,10 +62894,10 @@ import {
 import { ObjectId as ObjectId101 } from "mongodb";
 
 // src/utils/update-result.util.ts
-import { NotFoundError as NotFoundError39 } from "@7365admin1/node-server-utils";
+import { NotFoundError as NotFoundError41 } from "@7365admin1/node-server-utils";
 function assertUpdateMatched(result, message) {
   if (result?.matchedCount === 0) {
-    throw new NotFoundError39(message);
+    throw new NotFoundError41(message);
   }
   return result;
 }
@@ -62879,7 +64059,7 @@ function usePatrolLogRepo() {
 import {
   BadRequestError as BadRequestError140,
   logger as logger112,
-  NotFoundError as NotFoundError40,
+  NotFoundError as NotFoundError42,
   useAtlas as useAtlas78
 } from "@7365admin1/node-server-utils";
 function patrolProblem(status) {
@@ -62919,7 +64099,7 @@ function usePatrolLogService() {
             session
           );
           if (file.matchedCount === 0) {
-            throw new NotFoundError40(`File not found: ${fileId}`);
+            throw new NotFoundError42(`File not found: ${fileId}`);
           }
         }
       }
@@ -63284,7 +64464,7 @@ import {
   BadRequestError as BadRequestError143,
   InternalServerError as InternalServerError52,
   logger as logger114,
-  NotFoundError as NotFoundError41,
+  NotFoundError as NotFoundError43,
   paginate as paginate36,
   useAtlas as useAtlas79
 } from "@7365admin1/node-server-utils";
@@ -63474,7 +64654,7 @@ function usePatrolEmailRepo() {
       throw new InternalServerError52("Failed to retrieve the patrol email.");
     }
     if (!data) {
-      throw new NotFoundError41("Patrol email not found.");
+      throw new NotFoundError43("Patrol email not found.");
     }
     const [decorated] = await withResendState([data], session);
     return decorated;
@@ -63489,7 +64669,7 @@ function usePatrolEmailRepo() {
         { session }
       );
       if (result.matchedCount === 0) {
-        throw new NotFoundError41("Patrol email not found.");
+        throw new NotFoundError43("Patrol email not found.");
       }
       return result;
     } catch (error) {
@@ -63518,7 +64698,7 @@ import {
   compileHandlebar as compileHandlebar5,
   getDirectory as getDirectory5,
   logger as logger116,
-  NotFoundError as NotFoundError42,
+  NotFoundError as NotFoundError44,
   useMailer as useMailer5
 } from "@7365admin1/node-server-utils";
 
@@ -63713,7 +64893,7 @@ function usePatrolEmailService() {
     for (const id of logIds) {
       const log = await _getPatrolLogById(id);
       if (!log) {
-        throw new NotFoundError42("Patrol log not found.");
+        throw new NotFoundError44("Patrol log not found.");
       }
       if (String(log.site) !== String(site)) {
         throw new BadRequestError146(
@@ -63763,7 +64943,7 @@ function usePatrolEmailService() {
   async function claimUploadedPdf(fileId) {
     const file = await _getFileById(fileId);
     if (!file) {
-      throw new NotFoundError42("Uploaded PDF not found.");
+      throw new NotFoundError44("Uploaded PDF not found.");
     }
     if (!isClaimableUpload(file)) {
       throw new BadRequestError146(
@@ -63772,7 +64952,7 @@ function usePatrolEmailService() {
     }
     const promoted = await _updateFileStatusById(fileId, { status: "active" });
     if (promoted.matchedCount === 0) {
-      throw new NotFoundError42("Uploaded PDF not found.");
+      throw new NotFoundError44("Uploaded PDF not found.");
     }
     return {
       file: fileId,
@@ -63781,7 +64961,7 @@ function usePatrolEmailService() {
     };
   }
   function sanitizeError(error) {
-    if (error instanceof BadRequestError146 || error instanceof NotFoundError42) {
+    if (error instanceof BadRequestError146 || error instanceof NotFoundError44) {
       return error.message;
     }
     return "Failed to send the patrol log email.";
@@ -64382,7 +65562,7 @@ import {
   InternalServerError as InternalServerError53,
   logger as logger118,
   makeCacheKey as makeCacheKey38,
-  NotFoundError as NotFoundError43,
+  NotFoundError as NotFoundError45,
   paginate as paginate37,
   useAtlas as useAtlas80,
   useCache as useCache43
@@ -64513,7 +65693,7 @@ function useSiteFacilityRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError43("Site facility not found.");
+        throw new NotFoundError45("Site facility not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger118.info(`Cache set for key: ${cacheKey}`);
@@ -64638,7 +65818,7 @@ function useSiteFacilityRepo() {
     try {
       const data = await collection.findOne(query2, { session });
       if (!data) {
-        throw new NotFoundError43("Site facility not found.");
+        throw new NotFoundError45("Site facility not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger118.info(`Cache set for key: ${cacheKey}`);
@@ -64779,7 +65959,7 @@ function useSiteFacilityService() {
 // src/controllers/site-facility.controller.ts
 import {
   BadRequestError as BadRequestError149,
-  NotFoundError as NotFoundError44,
+  NotFoundError as NotFoundError46,
   UnauthorizedError as UnauthorizedError17,
   logger as logger119
 } from "@7365admin1/node-server-utils";
@@ -64799,7 +65979,7 @@ function useSiteFacilityController() {
     const facility = await _getSiteFacilityById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(facility)) {
-      throw new NotFoundError44("Site facility not found.");
+      throw new NotFoundError46("Site facility not found.");
     }
     return facility;
   }
@@ -65064,7 +66244,7 @@ import {
   InternalServerError as InternalServerError54,
   logger as logger120,
   makeCacheKey as makeCacheKey39,
-  NotFoundError as NotFoundError45,
+  NotFoundError as NotFoundError47,
   paginate as paginate38,
   useAtlas as useAtlas82,
   useCache as useCache44
@@ -65179,7 +66359,7 @@ function useServiceProviderBillingRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError45("Service provider billing not found.");
+        throw new NotFoundError47("Service provider billing not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger120.info(`Cache set for key: ${cacheKey}`);
@@ -65734,7 +66914,7 @@ import {
   InternalServerError as InternalServerError55,
   logger as logger122,
   makeCacheKey as makeCacheKey40,
-  NotFoundError as NotFoundError46,
+  NotFoundError as NotFoundError48,
   paginate as paginate39,
   toObjectId as toObjectId16,
   useAtlas as useAtlas84,
@@ -65850,7 +67030,7 @@ function useSiteFacilityBookingRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError46("Site facility booking not found.");
+        throw new NotFoundError48("Site facility booking not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger122.info(`Cache set for key: ${cacheKey}`);
@@ -65993,7 +67173,7 @@ function useSiteFacilityBookingService() {
 // src/controllers/site-facility-booking.controller.ts
 import {
   BadRequestError as BadRequestError153,
-  NotFoundError as NotFoundError47,
+  NotFoundError as NotFoundError49,
   logger as logger123
 } from "@7365admin1/node-server-utils";
 import Joi88 from "joi";
@@ -66011,7 +67191,7 @@ function useSiteFacilityBookingController() {
     const booking = await _getSiteFacilityBookingById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(booking)) {
-      throw new NotFoundError47("Site facility booking not found.");
+      throw new NotFoundError49("Site facility booking not found.");
     }
     return booking;
   }
@@ -66303,7 +67483,7 @@ import {
   InternalServerError as InternalServerError56,
   logger as logger124,
   makeCacheKey as makeCacheKey41,
-  NotFoundError as NotFoundError48,
+  NotFoundError as NotFoundError50,
   paginate as paginate40,
   useAtlas as useAtlas86,
   useCache as useCache46
@@ -66477,7 +67657,7 @@ function useDocumentManagementRepo() {
         }
       ]).toArray();
       if (!data || !data.length) {
-        throw new NotFoundError48("Document not found.");
+        throw new NotFoundError50("Document not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger124.info(`Cache set for key: ${cacheKey}`);
@@ -66550,7 +67730,7 @@ function useDocumentManagementRepo() {
         { $set: updateValue }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError48("Folder not found.");
+        throw new NotFoundError50("Folder not found.");
       }
       delNamespace().then(() => {
         logger124.info(`Cache cleared for namespace: ${namespace_collection3}`);
@@ -66640,7 +67820,7 @@ function useDocumentManagementRepo() {
         session ? { session } : void 0
       ).toArray();
       if (!folders || folders.length === 0) {
-        throw new NotFoundError48("Folder not found.");
+        throw new NotFoundError50("Folder not found.");
       }
       const ids2 = folders[0].ids;
       const res = await collection.updateMany(
@@ -66969,7 +68149,7 @@ function useDocumentManagementService() {
 import {
   BadRequestError as BadRequestError156,
   logger as logger126,
-  NotFoundError as NotFoundError49
+  NotFoundError as NotFoundError51
 } from "@7365admin1/node-server-utils";
 import Joi90 from "joi";
 function useDocumentManagementController() {
@@ -66995,7 +68175,7 @@ function useDocumentManagementController() {
       return;
     const org = doc?.org?.toString() ?? "";
     if (!org || !actor.orgIds.includes(org)) {
-      throw new NotFoundError49("Document not found.");
+      throw new NotFoundError51("Document not found.");
     }
   }
   async function add(req, res, next) {
@@ -67403,7 +68583,7 @@ import {
   InternalServerError as InternalServerError57,
   logger as logger127,
   makeCacheKey as makeCacheKey42,
-  NotFoundError as NotFoundError50,
+  NotFoundError as NotFoundError52,
   paginate as paginate41,
   useAtlas as useAtlas88,
   useCache as useCache47
@@ -67539,7 +68719,7 @@ function useBulletinBoardRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError50("Bulletin board not found.");
+        throw new NotFoundError52("Bulletin board not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger127.info(`Cache set for key: ${cacheKey}`);
@@ -67638,7 +68818,7 @@ function useBulletinBoardRepo() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError50("No bulletin boards found to update.");
+        throw new NotFoundError52("No bulletin boards found to update.");
       }
       delNamespace().then(() => {
         logger127.info(
@@ -67673,7 +68853,7 @@ function useBulletinBoardRepo() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError50(
+        throw new NotFoundError52(
           "No upcoming bulletin boards found to activate."
         );
       }
@@ -67705,7 +68885,7 @@ function useBulletinBoardRepo() {
 }
 
 // src/services/bulletin-board.service.ts
-import { useAtlas as useAtlas89, NotFoundError as NotFoundError51 } from "@7365admin1/node-server-utils";
+import { useAtlas as useAtlas89, NotFoundError as NotFoundError53 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId117 } from "mongodb";
 
 // src/utils/bulletin-service-apps.util.ts
@@ -67752,7 +68932,7 @@ function useBulletinBoardService() {
             session
           );
           if (!file) {
-            throw new NotFoundError51("File not found.");
+            throw new NotFoundError53("File not found.");
           }
         }
       }
@@ -67901,7 +69081,7 @@ function useBulletinBoardService() {
 // src/controllers/bulletin-board.controller.ts
 import {
   BadRequestError as BadRequestError158,
-  NotFoundError as NotFoundError52,
+  NotFoundError as NotFoundError54,
   UnauthorizedError as UnauthorizedError18,
   logger as logger128
 } from "@7365admin1/node-server-utils";
@@ -67918,7 +69098,7 @@ function useBulletinBoardController() {
     const bulletin = await _getBulletinBoardById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(scopeOf(bulletin))) {
-      throw new NotFoundError52("Bulletin board not found.");
+      throw new NotFoundError54("Bulletin board not found.");
     }
     return bulletin;
   }
@@ -69498,7 +70678,7 @@ import {
   InternalServerError as InternalServerError60,
   logger as logger137,
   makeCacheKey as makeCacheKey45,
-  NotFoundError as NotFoundError55,
+  NotFoundError as NotFoundError57,
   paginate as paginate44,
   useAtlas as useAtlas94,
   useCache as useCache50
@@ -69672,7 +70852,7 @@ function useEventManagementRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError55("Event not found.");
+        throw new NotFoundError57("Event not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger137.info(`Cache set for key: ${cacheKey}`);
@@ -69769,7 +70949,7 @@ function useEventManagementRepo() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError55("No bulletin boards found to update.");
+        throw new NotFoundError57("No bulletin boards found to update.");
       }
       delNamespace().then(() => {
         logger137.info(
@@ -69881,7 +71061,7 @@ function useEventManagementService() {
 // src/controllers/event-management.controller.ts
 import {
   BadRequestError as BadRequestError168,
-  NotFoundError as NotFoundError56,
+  NotFoundError as NotFoundError58,
   logger as logger138
 } from "@7365admin1/node-server-utils";
 import Joi98 from "joi";
@@ -69896,7 +71076,7 @@ function useEventManagementController() {
     const event = await _getEventManagementById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(event)) {
-      throw new NotFoundError56("Event not found.");
+      throw new NotFoundError58("Event not found.");
     }
     return event;
   }
@@ -72799,7 +73979,7 @@ import {
   InternalServerError as InternalServerError62,
   logger as logger143,
   makeCacheKey as makeCacheKey47,
-  NotFoundError as NotFoundError58,
+  NotFoundError as NotFoundError60,
   paginate as paginate46,
   useAtlas as useAtlas99,
   useCache as useCache52
@@ -73002,7 +74182,7 @@ function useNfcPatrolTagRepo() {
     }
     const tag = await collection.findOne({ _id }, { session });
     if (!tag) {
-      throw new NotFoundError58("NFC Patrol Tag not found.");
+      throw new NotFoundError60("NFC Patrol Tag not found.");
     }
     return tag;
   }
@@ -73419,7 +74599,7 @@ import {
   InternalServerError as InternalServerError63,
   logger as logger146,
   makeCacheKey as makeCacheKey48,
-  NotFoundError as NotFoundError59,
+  NotFoundError as NotFoundError61,
   paginate as paginate47,
   toObjectId as toObjectId17,
   useAtlas as useAtlas101,
@@ -73563,7 +74743,7 @@ function useOccurrenceBookRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError59("Occurrence book not found.");
+        throw new NotFoundError61("Occurrence book not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger146.info(`Cache set for key: ${cacheKey}`);
@@ -74079,7 +75259,7 @@ import {
   InternalServerError as InternalServerError64,
   logger as logger148,
   makeCacheKey as makeCacheKey49,
-  NotFoundError as NotFoundError60,
+  NotFoundError as NotFoundError62,
   paginate as paginate48,
   useAtlas as useAtlas103,
   useCache as useCache54
@@ -74220,7 +75400,7 @@ function useBulletinVideoRepo() {
         { session }
       );
       if (!data) {
-        throw new NotFoundError60("Bulletin video not found.");
+        throw new NotFoundError62("Bulletin video not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger148.info(`Cache set for key: ${cacheKey}`);
@@ -74312,7 +75492,7 @@ function useBulletinVideoRepo() {
 }
 
 // src/services/bulletin-video.service.ts
-import { useAtlas as useAtlas104, NotFoundError as NotFoundError61 } from "@7365admin1/node-server-utils";
+import { useAtlas as useAtlas104, NotFoundError as NotFoundError63 } from "@7365admin1/node-server-utils";
 function useBulletinVideoService() {
   const {
     add: _add,
@@ -74333,7 +75513,7 @@ function useBulletinVideoService() {
           session
         );
         if (!file) {
-          throw new NotFoundError61("File not found.");
+          throw new NotFoundError63("File not found.");
         }
       }
       await _add(value, session);
@@ -74389,7 +75569,7 @@ function useBulletinVideoService() {
 // src/controllers/bulletin-video.controller.ts
 import {
   BadRequestError as BadRequestError181,
-  NotFoundError as NotFoundError62,
+  NotFoundError as NotFoundError64,
   logger as logger149
 } from "@7365admin1/node-server-utils";
 import Joi108 from "joi";
@@ -74404,7 +75584,7 @@ function useBulletinVideoController() {
     const video = await _getBulletinVideoById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(video)) {
-      throw new NotFoundError62("Bulletin video not found.");
+      throw new NotFoundError64("Bulletin video not found.");
     }
     return video;
   }
@@ -75698,7 +76878,7 @@ import {
   InternalServerError as InternalServerError66,
   logger as logger155,
   makeCacheKey as makeCacheKey51,
-  NotFoundError as NotFoundError64,
+  NotFoundError as NotFoundError66,
   paginate as paginate50,
   useAtlas as useAtlas107,
   useCache as useCache56
@@ -75866,7 +77046,7 @@ function useEntryPassSettingsRepo() {
         }
       ]).toArray();
       if (!data || !data.length) {
-        throw new NotFoundError64("Entry Pass Settings not found.");
+        throw new NotFoundError66("Entry Pass Settings not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger155.info(`Cache set for key: ${cacheKey}`);
@@ -76002,7 +77182,7 @@ function useEntryPassSettingsRepo() {
         }
       ]).toArray();
       if (!data || !data.length) {
-        throw new NotFoundError64("Entry Pass Settings not found.");
+        throw new NotFoundError66("Entry Pass Settings not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger155.info(`Cache set for key: ${cacheKey}`);
@@ -76811,7 +77991,7 @@ function useNfcPatrolRouteService() {
 import {
   BadRequestError as BadRequestError193,
   logger as logger162,
-  NotFoundError as NotFoundError66
+  NotFoundError as NotFoundError68
 } from "@7365admin1/node-server-utils";
 import Joi115 from "joi";
 function useNfcPatrolRouteController() {
@@ -76903,7 +78083,7 @@ function useNfcPatrolRouteController() {
       const nfcPatrolRoute = await _getById(value?.id, value?.isStart);
       await requireSiteReachIfSignedIn(req, nfcPatrolRoute?.site);
       if (!nfcPatrolRoute) {
-        throw new NotFoundError66("NFC Patrol Route not found.");
+        throw new NotFoundError68("NFC Patrol Route not found.");
       }
       res.json({
         message: "Successfully retrieved nfc patrol route.",
@@ -77301,7 +78481,7 @@ function MIncidentReport(value) {
 import {
   useAtlas as useAtlas112,
   BadRequestError as BadRequestError195,
-  NotFoundError as NotFoundError68
+  NotFoundError as NotFoundError70
 } from "@7365admin1/node-server-utils";
 
 // src/repositories/incident-report.repo.ts
@@ -77310,7 +78490,7 @@ import {
   InternalServerError as InternalServerError69,
   logger as logger163,
   makeCacheKey as makeCacheKey54,
-  NotFoundError as NotFoundError67,
+  NotFoundError as NotFoundError69,
   paginate as paginate52,
   useAtlas as useAtlas111,
   useCache as useCache59
@@ -77568,7 +78748,7 @@ function useIncidentReportRepo() {
         { session }
       );
       if (!data) {
-        throw new NotFoundError67("Incident report not found.");
+        throw new NotFoundError69("Incident report not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger163.info(`Cache set for key: ${cacheKey}`);
@@ -77851,7 +79031,7 @@ function useIncidentReportService() {
             session
           );
           if (!file) {
-            throw new NotFoundError68("File not found.");
+            throw new NotFoundError70("File not found.");
           }
         }
       }
@@ -78334,7 +79514,7 @@ import {
   InternalServerError as InternalServerError70,
   logger as logger166,
   makeCacheKey as makeCacheKey55,
-  NotFoundError as NotFoundError69,
+  NotFoundError as NotFoundError71,
   useAtlas as useAtlas113,
   useCache as useCache60
 } from "@7365admin1/node-server-utils";
@@ -78424,7 +79604,7 @@ function useNfcPatrolSettingsRepository() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError69("NFC patrol settings not found for this site.");
+        throw new NotFoundError71("NFC patrol settings not found for this site.");
       }
       delNamespace().then(() => {
         logger166.info(`Cache cleared for namespace: ${namespace_collection3}`);
@@ -78591,7 +79771,7 @@ import {
   InternalServerError as InternalServerError71,
   logger as logger169,
   makeCacheKey as makeCacheKey56,
-  NotFoundError as NotFoundError70,
+  NotFoundError as NotFoundError72,
   paginate as paginate53,
   useAtlas as useAtlas115,
   useCache as useCache61
@@ -78819,7 +79999,7 @@ function useOccurrenceSubjectRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError70("Occurrence subject not found.");
+        throw new NotFoundError72("Occurrence subject not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger169.info(`Cache set for key: ${cacheKey}`);
@@ -79300,7 +80480,7 @@ import {
   InternalServerError as InternalServerError72,
   logger as logger171,
   makeCacheKey as makeCacheKey57,
-  NotFoundError as NotFoundError71,
+  NotFoundError as NotFoundError73,
   paginate as paginate54,
   useAtlas as useAtlas117,
   useCache as useCache62
@@ -79446,7 +80626,7 @@ function useOnlineFormRepo() {
         }
       ]).toArray();
       if (!data || !data.length) {
-        throw new NotFoundError71("Document not found.");
+        throw new NotFoundError73("Document not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger171.info(`Cache set for key: ${cacheKey}`);
@@ -79590,7 +80770,7 @@ function useOnlineFormRepo() {
 // src/controllers/online-form.controller.ts
 import {
   BadRequestError as BadRequestError204,
-  NotFoundError as NotFoundError72,
+  NotFoundError as NotFoundError74,
   UnauthorizedError as UnauthorizedError21,
   logger as logger172
 } from "@7365admin1/node-server-utils";
@@ -79608,7 +80788,7 @@ function useOnlineFormController() {
     const form = await _getOnlineFormById(id);
     const { canReach } = await siteReachOf(req);
     if (!await canReach(form)) {
-      throw new NotFoundError72("Document not found.");
+      throw new NotFoundError74("Document not found.");
     }
     return form;
   }
@@ -80187,7 +81367,7 @@ function useNfcPatrolLogRepo() {
 // src/services/nfc-patrol-log.service.ts
 import {
   BadRequestError as BadRequestError207,
-  NotFoundError as NotFoundError74,
+  NotFoundError as NotFoundError76,
   useAtlas as useAtlas120
 } from "@7365admin1/node-server-utils";
 function useNfcPatrolLogService() {
@@ -80344,7 +81524,7 @@ function useNfcPatrolLogService() {
   async function sign(id, value) {
     const log = await getById(id);
     if (!log) {
-      throw new NotFoundError74("Patrol log not found.");
+      throw new NotFoundError76("Patrol log not found.");
     }
     const canSign = log.checkPoints.every(
       (c) => c.status === "Completed" || c.status === "Skipped"
@@ -83553,7 +84733,7 @@ function useManpowerDesignationRepo() {
 // src/controllers/manpower-designations.controller.ts
 import {
   BadRequestError as BadRequestError216,
-  NotFoundError as NotFoundError77,
+  NotFoundError as NotFoundError79,
   logger as logger183
 } from "@7365admin1/node-server-utils";
 import Joi131 from "joi";
@@ -83568,7 +84748,7 @@ function useManpowerDesignationCtrl() {
     const row = await _getManpowerDesignationsById(_id);
     const { canReach } = await siteReachOf(req);
     if (!row || !await canReach({ site: row.siteId })) {
-      throw new NotFoundError77("Manpower designations not found.");
+      throw new NotFoundError79("Manpower designations not found.");
     }
     return row;
   }
@@ -83582,7 +84762,7 @@ function useManpowerDesignationCtrl() {
       }
       const { actor, canReach } = await siteReachOf(req);
       if (!await canReach({ site: payload.siteId })) {
-        throw new NotFoundError77("Site not found.");
+        throw new NotFoundError79("Site not found.");
       }
       payload.createdBy = actor.id;
       payload.createdByName = actor.name;
@@ -86320,7 +87500,7 @@ import {
   useAtlas as useAtlas133,
   logger as logger198,
   BadRequestError as BadRequestError227,
-  NotFoundError as NotFoundError78,
+  NotFoundError as NotFoundError80,
   AppError as AppError34,
   paginate as paginate65
 } from "@7365admin1/node-server-utils";
@@ -86378,7 +87558,7 @@ var useRedDotPaymentRepo = () => {
         { session }
       );
       if (!payment) {
-        throw new NotFoundError78("Payment not found.");
+        throw new NotFoundError80("Payment not found.");
       }
       return payment;
     } catch (error) {
@@ -86710,7 +87890,7 @@ var useRedDotPaymentRepo = () => {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError78(
+        throw new NotFoundError80(
           "Payment not found or is no longer pending."
         );
       }
@@ -87041,7 +88221,7 @@ import {
   logger as logger201,
   getDirectory as getDirectory7,
   BadRequestError as BadRequestError231,
-  NotFoundError as NotFoundError81,
+  NotFoundError as NotFoundError83,
   InternalServerError as InternalServerError85,
   UnauthorizedError as UnauthorizedError22,
   useAtlas as useAtlas137,
@@ -87055,7 +88235,7 @@ import {
   BadRequestError as BadRequestError230,
   comparePassword as comparePassword3,
   InternalServerError as InternalServerError84,
-  NotFoundError as NotFoundError80,
+  NotFoundError as NotFoundError82,
   useAtlas as useAtlas136,
   useCache as useCache73
 } from "@7365admin1/node-server-utils";
@@ -87069,7 +88249,7 @@ import {
   logger as logger200,
   BadRequestError as BadRequestError229,
   paginate as paginate66,
-  NotFoundError as NotFoundError79,
+  NotFoundError as NotFoundError81,
   AppError as AppError35,
   useCache as useCache72,
   makeCacheKey as makeCacheKey65,
@@ -87202,7 +88382,7 @@ function useUserRepoV2() {
       ]).toArray();
       const data = results.length > 0 ? results[0] : null;
       if (!data)
-        throw new NotFoundError79("User not found.");
+        throw new NotFoundError81("User not found.");
       setCache(cacheKey, data, 15 * 60).then(() => logger200.info(`Cache set for key: ${cacheKey}`)).catch(
         (err) => logger200.error(`Failed to set cache for key: ${cacheKey}`, err)
       );
@@ -87568,7 +88748,7 @@ function useAuthServiceV2() {
     try {
       const user = await getUserByEmail(email);
       if (!user) {
-        throw new NotFoundError80(
+        throw new NotFoundError82(
           "Invalid user email. Please check your email and try again."
         );
       }
@@ -87831,7 +89011,7 @@ function useVerificationServiceV2() {
       session?.startTransaction();
       const item = await _getByVerificationCode(verificationCode);
       if (!item) {
-        throw new NotFoundError81("Verification not found.");
+        throw new NotFoundError83("Verification not found.");
       }
       switch (item.status) {
         case "expired" /* EXPIRED */:
@@ -88093,7 +89273,7 @@ function useVerificationServiceV2() {
   async function resendSignUpVerification(email) {
     const item = await _getPendingVerificationByEmail(email);
     if (!item) {
-      throw new NotFoundError81(
+      throw new NotFoundError83(
         "Pending verification not found."
       );
     }
@@ -88149,7 +89329,7 @@ function useVerificationServiceV2() {
   }
   async function assertInviteOpen(invite) {
     if (!invite) {
-      throw new NotFoundError81("Invitation not found.");
+      throw new NotFoundError83("Invitation not found.");
     }
     if (invite.type !== "user-invite" /* USER_INVITE */ && invite.type !== "member-invite" /* MEMBER_INVITE */) {
       throw new BadRequestError231("This link is not a user invitation.");
@@ -88317,7 +89497,7 @@ function useVerificationServiceV2() {
     const email = await callerEmail(userId);
     const invite = await _getVerificationByIdFresh(inviteId);
     if (!invite) {
-      throw new NotFoundError81("Invitation not found.");
+      throw new NotFoundError83("Invitation not found.");
     }
     if (invite.email.toLowerCase() !== email.toLowerCase()) {
       throw new UnauthorizedError22("Not authorized.");
@@ -89081,7 +90261,7 @@ import {
   comparePassword as comparePassword4,
   hashPassword as hashPassword5,
   InternalServerError as InternalServerError86,
-  NotFoundError as NotFoundError82,
+  NotFoundError as NotFoundError84,
   useAtlas as useAtlas138,
   useS3 as useS33
 } from "@7365admin1/node-server-utils";
@@ -89185,14 +90365,14 @@ function useUserServiceV2() {
     try {
       const otpDoc = await _getVerificationById(id);
       if (!otpDoc) {
-        throw new NotFoundError82("You are using an invalid reset link.");
+        throw new NotFoundError84("You are using an invalid reset link.");
       }
       if (otpDoc.status === "complete" /* COMPLETE */) {
         throw new BadRequestError234("This link has already been invalidated.");
       }
       const user = await _getUserByEmail(otpDoc.email);
       if (!user) {
-        throw new NotFoundError82("User not found.");
+        throw new NotFoundError84("User not found.");
       }
       if (!user._id) {
         throw new InternalServerError86("Invalid user ID.");
@@ -90062,7 +91242,7 @@ function MPost(value) {
 import {
   BadRequestError as BadRequestError240,
   InternalServerError as InternalServerError88,
-  NotFoundError as NotFoundError83,
+  NotFoundError as NotFoundError85,
   paginate as paginate67,
   useAtlas as useAtlas140
 } from "@7365admin1/node-server-utils";
@@ -90285,7 +91465,7 @@ function usePostPrelovedRepo() {
       ]).toArray();
       const data = result[0] ?? null;
       if (!data)
-        throw new NotFoundError83("Post not found.");
+        throw new NotFoundError85("Post not found.");
       return data;
     } catch (error) {
       throw error;
@@ -90595,7 +91775,7 @@ import { useAtlas as useAtlas142 } from "@7365admin1/node-server-utils";
 import {
   BadRequestError as BadRequestError241,
   InternalServerError as InternalServerError89,
-  NotFoundError as NotFoundError84,
+  NotFoundError as NotFoundError86,
   useAtlas as useAtlas141
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId172 } from "mongodb";
@@ -90691,7 +91871,7 @@ function usePostFavoriteRepo() {
     }
     const result = await collection.findOne({ _id });
     if (!result)
-      throw new NotFoundError84("Favorite not found.");
+      throw new NotFoundError86("Favorite not found.");
     return result;
   }
   async function getByPostId(postId) {
@@ -90702,7 +91882,7 @@ function usePostFavoriteRepo() {
     }
     const result = await collection.findOne({ postId });
     if (!result)
-      throw new NotFoundError84("Favorite not found.");
+      throw new NotFoundError86("Favorite not found.");
     return result;
   }
   async function updateById(_id, userId, session) {
@@ -91214,7 +92394,7 @@ function MCategoryPreloved(value) {
 import {
   BadRequestError as BadRequestError244,
   InternalServerError as InternalServerError90,
-  NotFoundError as NotFoundError85,
+  NotFoundError as NotFoundError87,
   useAtlas as useAtlas144
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId175 } from "mongodb";
@@ -91257,7 +92437,7 @@ function useCategoryPrelovedRepo() {
     try {
       const data = await collection.findOne({ _id: objectId2 });
       if (!data) {
-        throw new NotFoundError85("Category not found.");
+        throw new NotFoundError87("Category not found.");
       }
       return data;
     } catch (error) {
@@ -91286,7 +92466,7 @@ function useCategoryPrelovedRepo() {
     }
     const existing = await collection.findOne({ _id: objectId2 });
     if (!existing)
-      throw new NotFoundError85("Category not found.");
+      throw new NotFoundError87("Category not found.");
     const res = await collection.updateOne(
       { _id: objectId2 },
       { $set: { ...value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } }
@@ -91304,7 +92484,7 @@ function useCategoryPrelovedRepo() {
     }
     const existing = await collection.findOne({ _id: objectId2 });
     if (!existing)
-      throw new NotFoundError85("Category not found.");
+      throw new NotFoundError87("Category not found.");
     const res = await collection.deleteOne({ _id: objectId2 });
     if (res.deletedCount === 0)
       throw new InternalServerError90("Unable to delete category.");
@@ -91471,7 +92651,7 @@ function MSubcategoryPreloved(value) {
 import {
   BadRequestError as BadRequestError246,
   InternalServerError as InternalServerError91,
-  NotFoundError as NotFoundError86,
+  NotFoundError as NotFoundError88,
   useAtlas as useAtlas145
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId177 } from "mongodb";
@@ -91522,7 +92702,7 @@ function useSubcategoryPrelovedRepo() {
     try {
       const data = await collection.findOne({ _id: objectId2 });
       if (!data) {
-        throw new NotFoundError86("Subcategory not found.");
+        throw new NotFoundError88("Subcategory not found.");
       }
       return data;
     } catch (error) {
@@ -91797,7 +92977,7 @@ function MChatPreloved(value) {
 import {
   BadRequestError as BadRequestError248,
   InternalServerError as InternalServerError92,
-  NotFoundError as NotFoundError87,
+  NotFoundError as NotFoundError89,
   useAtlas as useAtlas146
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId179 } from "mongodb";
@@ -91837,7 +93017,7 @@ function useChatPrelovedRepo() {
     }
     const existing = await collection.findOne({ _id: objectId2 });
     if (!existing)
-      throw new NotFoundError87("Chat not found.");
+      throw new NotFoundError89("Chat not found.");
     value.edited = true;
     value.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const res = await collection.updateOne({ _id: objectId2 }, { $set: value });
@@ -91854,7 +93034,7 @@ function useChatPrelovedRepo() {
     }
     const existing = await collection.findOne({ _id: objectId2 });
     if (!existing)
-      throw new NotFoundError87("Chat not found.");
+      throw new NotFoundError89("Chat not found.");
     const res = await collection.updateOne(
       { _id: objectId2 },
       { $set: { deletedAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() } }
@@ -92587,7 +93767,7 @@ function useChannelPrelovedController() {
 // src/repositories/bid-preloved.repo.ts
 import {
   InternalServerError as InternalServerError96,
-  NotFoundError as NotFoundError88,
+  NotFoundError as NotFoundError90,
   useAtlas as useAtlas150
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId183 } from "mongodb";
@@ -92609,7 +93789,7 @@ function useBidPrelovedRepo() {
     const objectId2 = typeof _id === "string" ? new ObjectId183(_id) : _id;
     const existing = await collection.findOne({ _id: objectId2 });
     if (!existing)
-      throw new NotFoundError88("Bid not found.");
+      throw new NotFoundError90("Bid not found.");
     const res = await collection.updateOne(
       { _id: objectId2 },
       { $set: { status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } }
@@ -92623,7 +93803,7 @@ function useBidPrelovedRepo() {
       _id = new ObjectId183(_id);
     const result = await collection.findOne({ _id });
     if (!result)
-      throw new NotFoundError88("Bid not found.");
+      throw new NotFoundError90("Bid not found.");
     return result;
   }
   return { add, getById, updateStatus };
@@ -92930,7 +94110,7 @@ var residentFormEntry = Joi163.object({
 import {
   BadRequestError as BadRequestError253,
   InternalServerError as InternalServerError98,
-  NotFoundError as NotFoundError89,
+  NotFoundError as NotFoundError91,
   paginate as paginate70,
   useAtlas as useAtlas152,
   useCache as useCache76
@@ -93035,7 +94215,7 @@ function useFormEntryRepo() {
     try {
       const [data] = await collection.aggregate([{ $match: query2 }]).toArray();
       if (!data) {
-        throw new NotFoundError89("Document not found.");
+        throw new NotFoundError91("Document not found.");
       }
       return data;
     } catch (error) {
@@ -93059,7 +94239,7 @@ function useFormEntryRepo() {
       }
       const onlineFormRequest = await collection.findOne({ _id });
       if (!onlineFormRequest) {
-        throw new NotFoundError89("Online form not found.");
+        throw new NotFoundError91("Online form not found.");
       }
       if (onlineFormRequest.userId) {
         const user = await getUserById(onlineFormRequest.userId.toString());
@@ -93172,7 +94352,7 @@ function useFormEntryRepo() {
 // src/controllers/online-forms-v2.controller.ts
 import {
   BadRequestError as BadRequestError254,
-  NotFoundError as NotFoundError90,
+  NotFoundError as NotFoundError92,
   UnauthorizedError as UnauthorizedError25,
   logger as logger218
 } from "@7365admin1/node-server-utils";
@@ -93195,7 +94375,7 @@ function useFormEntryController() {
     const owner = entry?.userId?.toString?.() ?? "";
     const isOwner = Boolean(actor.id) && owner === actor.id;
     if (!isOwner && !await canReach(entry)) {
-      throw new NotFoundError90("Document not found.");
+      throw new NotFoundError92("Document not found.");
     }
     return { entry, isOwner, actor };
   }
@@ -95677,6 +96857,7 @@ export {
   cameraGrant,
   cameraHealthClaim,
   cameraHealthSummary,
+  cameraListClearConfirmation,
   cameraManagePermissions,
   cameraProbeCacheKey,
   cameraTransports,