@7365admin1/core 3.68.0 → 3.68.1

package/dist/index.js

@@ -6145,6 +6145,7 @@ __export(src_exports, {
   cameraGrant: () => cameraGrant,
   cameraHealthClaim: () => cameraHealthClaim,
   cameraHealthSummary: () => cameraHealthSummary,
+  cameraListClearConfirmation: () => cameraListClearConfirmation,
   cameraManagePermissions: () => cameraManagePermissions,
   cameraProbeCacheKey: () => cameraProbeCacheKey,
   cameraTransports: () => cameraTransports,
@@ -21860,6 +21861,7 @@ var import_fs2 = require("fs");
 var import_joi26 = __toESM(require("joi"));
 var path2 = __toESM(require("path"));
 var import_urllib = require("urllib");
+var import_crypto2 = require("crypto");
 
 // src/repositories/visitor-transaction.repo.ts
 var import_node_server_utils56 = require("@7365admin1/node-server-utils");
@@ -24360,6 +24362,69 @@ function useVehicleRepo() {
       throw error;
     }
   }
+  async function getLivePlatesBySite(site) {
+    let siteId;
+    try {
+      siteId = new import_mongodb47.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils58.BadRequestError("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 import_node_server_utils58.InternalServerError("Failed to list the site's vehicles.");
+    }
+  }
   async function getAllExpiredVehicles() {
     try {
       const items = await collection.find(expiredVehicleSweepFilter()).toArray();
@@ -24564,6 +24629,7 @@ function useVehicleRepo() {
     getVehicleByPlateNumber,
     getVehiclesByNRIC,
     deleteExpiredVehicles,
+    getLivePlatesBySite,
     getAllVehiclesByUnitId,
     getAllExpiredVehicles,
     bulkUpsertVehicles,
@@ -24763,6 +24829,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)}`;
@@ -24773,6 +24906,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) {
@@ -24898,6 +25038,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({
@@ -24969,12 +25251,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;
         }
       }
@@ -25008,6 +25292,123 @@ async function useDahuaDigestWithRetry({
   }
   throw lastError;
 }
+var provenLogins = /* @__PURE__ */ new Map();
+function loginKey(host, username, password) {
+  return (0, import_crypto2.createHash)("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();
@@ -25609,111 +26010,115 @@ function useDahuaService() {
       start: import_joi26.default.string().isoDate().optional().allow("", null),
       end: import_joi26.default.string().isoDate().optional().allow("", null),
       owner: import_joi26.default.string().optional().allow("", null),
-      isOpenGate: import_joi26.default.boolean().optional().allow(null)
+      isOpenGate: import_joi26.default.boolean().optional().allow(null),
+      timezone: import_joi26.default.string().optional().allow("", null)
     });
     const { error: validationError } = validation.validate(value);
     if (validationError) {
       throw new import_node_server_utils60.BadRequestError(`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(
@@ -25733,7 +26138,8 @@ function useDahuaService() {
       start: import_joi26.default.string().isoDate().optional().allow("", null),
       end: import_joi26.default.string().isoDate().optional().allow("", null),
       owner: import_joi26.default.string().optional().allow("", null),
-      isOpenGate: import_joi26.default.boolean().optional()
+      isOpenGate: import_joi26.default.boolean().optional(),
+      timezone: import_joi26.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
@@ -25749,17 +26155,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) {
@@ -25782,14 +26191,16 @@ function useDahuaService() {
       throw new import_node_server_utils60.BadRequestError(`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) {
@@ -25811,11 +26222,18 @@ function useDahuaService() {
       throw new import_node_server_utils60.BadRequestError(`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);
@@ -25842,7 +26260,8 @@ function useDahuaService() {
       owner: import_joi26.default.string().optional().allow("", null),
       isOpenGate: import_joi26.default.boolean().optional().allow(null),
       vehicleType: import_joi26.default.string().optional().allow("", null),
-      vehicleColor: import_joi26.default.string().optional().allow("", null)
+      vehicleColor: import_joi26.default.string().optional().allow("", null),
+      timezone: import_joi26.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
@@ -25858,17 +26277,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) {
@@ -25922,11 +26344,91 @@ function useDahuaService() {
       throw error2;
     }
   }
+  async function setPlateWindow(value) {
+    const validation = import_joi26.default.object({
+      host: import_joi26.default.string().required(),
+      username: import_joi26.default.string().required(),
+      password: import_joi26.default.string().required(),
+      mode: import_joi26.default.string().valid(...Object.values(ANPRMode)).required(),
+      recno: import_joi26.default.string().required(),
+      plateNumber: import_joi26.default.string().required(),
+      owner: import_joi26.default.string().optional().allow("", null),
+      start: import_joi26.default.string().isoDate().optional().allow("", null),
+      end: import_joi26.default.string().isoDate().optional().allow("", null),
+      timezone: import_joi26.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      throw new import_node_server_utils60.BadRequestError(`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 import_node_server_utils60.BadRequestError(anprWriteReason(error2));
+    }
+  }
+  async function clearPlateList(value) {
+    const validation = import_joi26.default.object({
+      host: import_joi26.default.string().required(),
+      username: import_joi26.default.string().required(),
+      password: import_joi26.default.string().required(),
+      mode: import_joi26.default.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,
@@ -26368,6 +26870,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
         },
@@ -38087,6 +38594,7 @@ function useVehicleService() {
     getVehicleByPlateNumber: _getVehicleByPlateNumber,
     getAllExpiredVehicles: _getAllExpiredVehicles,
     bulkUpsertVehicles: _bulkUpsertVehicles,
+    getLivePlatesBySite: _getLivePlatesBySite,
     findOne
   } = useVehicleRepo();
   const {
@@ -38097,12 +38605,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) {
+      import_node_server_utils106.logger.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 import_mongodb72.ObjectId(String(site));
+    } catch {
+      siteId = null;
+    }
+    if (siteId && plateNumber) {
+      const excludeIds = exclude.map((id) => {
+        try {
+          return new import_mongodb72.ObjectId(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 import_node_server_utils106.BadRequestError(anprNoCameraRefusal("blocked"));
+    }
+    const { failures } = await writeToCameras(
+      cameras,
+      {
+        plateNumber,
+        mode: "TrafficBlackList" /* TRAFFIC_BLACKLIST */,
+        owner,
+        ...blockWindow(vehicle.end)
+      },
+      journal,
+      { onlyIfMissing: true }
+    );
+    if (failures.length) {
+      throw new import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
+          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 import_node_server_utils106.BadRequestError(anprUnblockFailureMessage(failures));
+    }
+  }
   async function add(value, session, user) {
     const isExternalSession = !!session;
     if (!session) {
@@ -38157,18 +39094,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;
@@ -38181,22 +39118,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);
         import_node_server_utils106.logger.info(
           `addVehicle resolved ${siteCameras.length} site camera(s) for site ${value?.site}`
         );
@@ -38231,7 +39153,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);
@@ -38251,8 +39176,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,
@@ -38282,13 +39206,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));
       }
@@ -38314,80 +39243,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);
-      import_node_server_utils106.logger.info(
-        `deleteVehicle resolved ${siteCameras.length} ANPR camera(s) for site ${site}`
-      );
       const vehicle = await findOne({ _id: new import_mongodb72.ObjectId(_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 });
+      import_node_server_utils106.logger.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)
@@ -38397,13 +39274,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) {
       import_node_server_utils106.logger.error("Error in vehicle service delete:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -38418,13 +39296,14 @@ function useVehicleService() {
     const org = await _getById(orgId);
     if (!org)
       throw new import_node_server_utils106.BadRequestError("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 import_mongodb72.ObjectId(id) });
     if (!vehicle) {
-      throw new import_node_server_utils106.BadRequestError("Vehicle not found");
+      throw new import_node_server_utils106.NotFoundError("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;
@@ -38442,70 +39321,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 import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
-            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 import_node_server_utils106.BadRequestError(
+          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
         );
@@ -38520,6 +39377,7 @@ function useVehicleService() {
       return "Vehicle plate number approved and added successfully.";
     } catch (error) {
       import_node_server_utils106.logger.error("Error in vehicle service approving and adding:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -38528,71 +39386,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);
         }
-        return outcome ?? anprRevokeThrew("no outcome returned");
+        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 ANPR_NOTHING_TO_REVOKE;
       },
       cameraLabel
     });
@@ -38619,90 +39444,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 import_mongodb72.ObjectId(id) });
     if (!vehicle) {
-      throw new import_node_server_utils106.BadRequestError("Vehicle not found");
+      throw new import_node_server_utils106.NotFoundError("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 import_node_server_utils106.BadRequestError(
+          `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 import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
-            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 import_node_server_utils106.BadRequestError(
+          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);
@@ -38710,21 +39528,62 @@ function useVehicleService() {
       return "Vehicle reactivated successfully.";
     } catch (error) {
       import_node_server_utils106.logger.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) {
-      import_node_server_utils106.logger.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 import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
+        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 import_node_server_utils106.BadRequestError(
+        anprWriteFailureMessage(writeFailures, "updated")
       );
-      return false;
     }
   }
   async function updateVehicleById(_id, value) {
@@ -38732,241 +39591,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 import_mongodb72.ObjectId(_id) });
+      if (!vehicle) {
+        throw new import_node_server_utils106.NotFoundError("Vehicle not found.");
+      }
       if (value.peopleId) {
         value.peopleId = new import_mongodb72.ObjectId(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 import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
+            "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 import_node_server_utils106.BadRequestError(
-                  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 import_node_server_utils106.BadRequestError(
-                  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 import_node_server_utils106.BadRequestError(
-                  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 import_node_server_utils106.BadRequestError(
-                    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 import_node_server_utils106.BadRequestError(
-                  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 import_node_server_utils106.BadRequestError(
-                  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 import_mongodb72.ObjectId(block) : block
         },
@@ -38976,13 +39669,27 @@ function useVehicleService() {
         ...unit && {
           unit: typeof unit === "string" ? new import_mongodb72.ObjectId(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) {
       import_node_server_utils106.logger.error("Error in vehicle service update:", error);
+      await rollbackCameras(journal, error);
       await session.abortTransaction();
       throw error;
     } finally {
@@ -39018,25 +39725,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();
@@ -39045,58 +39739,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 = [];
@@ -39141,123 +39840,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 import_mongodb72.ObjectId(value.peopleId);
+      const vehicle = await findOne({ _id: new import_mongodb72.ObjectId(_id) });
+      if (!vehicle) {
+        throw new import_node_server_utils106.NotFoundError("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 import_node_server_utils106.BadRequestError(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 import_node_server_utils106.BadRequestError(
-              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 import_node_server_utils106.BadRequestError(
-              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 {
@@ -39269,85 +39871,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 import_mongodb72.ObjectId(_id) });
+      if (!vehicle) {
+        throw new import_node_server_utils106.NotFoundError("Vehicle not found.");
+      }
+      if (vehicle.type !== "blocklist" /* BLOCKLIST */) {
+        throw new import_node_server_utils106.BadRequestError("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 import_mongodb72.ObjectId(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);
-        import_node_server_utils106.logger.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 import_node_server_utils106.BadRequestError(
-              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 import_node_server_utils106.NotFoundError("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 import_node_server_utils106.BadRequestError(
+          `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++;
+    }
+    import_node_server_utils106.logger.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 import_mongodb72.ObjectId(String(site));
+      id = new import_mongodb72.ObjectId(String(vehicleId));
+    } catch {
+      throw new import_node_server_utils106.BadRequestError("Invalid vehicle or site ID.");
+    }
+    const vehicle = await findOne({
+      _id: id,
+      site: siteId,
+      status: "active" /* ACTIVE */
+    });
+    if (!vehicle)
+      throw new import_node_server_utils106.NotFoundError("Vehicle not found.");
+    const held = listsHeldBy(vehicle);
+    if (list === "blocked" ? !held.block : !held.allow) {
+      throw new import_node_server_utils106.BadRequestError(
+        "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,
@@ -39357,7 +40096,10 @@ function useVehicleService() {
     updateVehicleById,
     bulkUpsertVehicles,
     blocklistVehicles,
-    removeFromBlocklist
+    removeFromBlocklist,
+    fillCameraLists,
+    newCameraPlateRows,
+    writeVehicleToNewCamera
   };
 }
 
@@ -43571,8 +44313,10 @@ function useVehicleController() {
       }
       const { _id, ...rest } = value;
       await requireVehicleReach(req, _id);
-      await _removeFromBlocklist(_id, rest);
-      res.json({ message: "Successfully removed vehicle from blocklist." });
+      const message = await _removeFromBlocklist(_id, rest);
+      res.json({
+        message: message || "Successfully removed vehicle from blocklist."
+      });
       return;
     } catch (error) {
       import_node_server_utils120.logger.log({ level: "error", message: error.message });
@@ -43672,10 +44416,69 @@ 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 import_node_server_utils121.NotFoundError("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) {
+        import_node_server_utils121.logger.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 import_node_server_utils121.BadRequestError(
+          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);
+    }
+    import_node_server_utils121.logger.info(
+      `clearPlateLists cleared ${cleared.join(" and ") || "nothing"} on camera ${id || target.host}`
+    );
+    return cleared;
+  }
   return {
     add,
     listenToCapturedPlateNumber,
-    updateById
+    updateById,
+    clearPlateLists
   };
 }
 
@@ -43811,8 +44614,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,
@@ -43896,6 +44720,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) {
@@ -43914,6 +44744,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 import_node_server_utils122.BadRequestError("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 */,
@@ -43923,8 +44799,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);
@@ -44033,6 +44911,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);
@@ -44067,6 +44951,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 import_node_server_utils122.BadRequestError(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({
@@ -44088,8 +45009,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);
@@ -44130,12 +45054,216 @@ function useSiteCameraController() {
       next(error2);
     }
   }
+  const schemaNewCameraDevice = {
+    host: import_joi58.default.string().trim().required(),
+    username: import_joi58.default.string().required(),
+    password: import_joi58.default.string().required(),
+    name: import_joi58.default.string().optional().allow("", null),
+    direction: import_joi58.default.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 import_node_server_utils122.BadRequestError("ANPR already exist.");
+    }
+  }
+  async function newCameraPlates(req, res, next) {
+    const { error, value } = import_joi58.default.object({
+      siteId: import_joi58.default.string().hex().length(24).required(),
+      host: import_joi58.default.string().trim().required(),
+      direction: schemaNewCameraDevice.direction
+    }).validate({
+      siteId: req.params.siteId,
+      host: req.query?.host,
+      direction: req.query?.direction
+    });
+    if (error) {
+      next(new import_node_server_utils122.BadRequestError(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 } = import_joi58.default.object({
+      siteId: import_joi58.default.string().hex().length(24).required(),
+      ...schemaNewCameraDevice
+    }).validate({ siteId: req.params.siteId, ...req.body ?? {} });
+    if (error) {
+      next(new import_node_server_utils122.BadRequestError(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 } = import_joi58.default.object({
+      siteId: import_joi58.default.string().hex().length(24).required(),
+      ...schemaNewCameraDevice,
+      vehicle: import_joi58.default.string().hex().length(24).required(),
+      list: import_joi58.default.string().valid("allowed", "blocked").required(),
+      onlyIfMissing: import_joi58.default.boolean().optional().default(false)
+    }).validate({ siteId: req.params.siteId, ...req.body ?? {} });
+    if (error) {
+      next(new import_node_server_utils122.BadRequestError(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 (!import_mongodb78.ObjectId.isValid(id))
+      throw new import_node_server_utils122.NotFoundError("Camera not found.");
+    const camera = await _findOne(
+      { _id: new import_mongodb78.ObjectId(id) },
+      {
+        site: 1,
+        type: 1,
+        host: 1,
+        username: 1,
+        password: 1,
+        name: 1,
+        direction: 1,
+        status: 1
+      }
+    );
+    if (!camera)
+      throw new import_node_server_utils122.NotFoundError("Camera not found.");
+    await authorizeWrite({
+      req,
+      site: camera.site,
+      type: camera.type,
+      notFound: "Camera not found."
+    });
+    if (String(camera.type ?? "").toLowerCase() !== "anpr") {
+      throw new import_node_server_utils122.BadRequestError("Only ANPR cameras hold vehicle plates.");
+    }
+    if (String(camera.status ?? "active") !== "active") {
+      throw new import_node_server_utils122.BadRequestError(
+        "This camera is inactive. Switch it on before adding vehicles to it."
+      );
+    }
+    const lists = listsFilledByDirectionChange("", camera.direction);
+    if (!lists.allow && !lists.block) {
+      throw new import_node_server_utils122.BadRequestError("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 } = import_joi58.default.object({
+      vehicle: import_joi58.default.string().hex().length(24).required(),
+      list: import_joi58.default.string().valid("allowed", "blocked").required(),
+      onlyIfMissing: import_joi58.default.boolean().optional().default(true)
+    }).validate(req.body ?? {});
+    if (error) {
+      next(new import_node_server_utils122.BadRequestError(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
   };
 }
 
@@ -47732,7 +48860,7 @@ var VALID_STATUSES = /* @__PURE__ */ new Set([
 ]);
 
 // src/services/hid-amico.service.ts
-var import_crypto3 = __toESM(require("crypto"));
+var import_crypto4 = __toESM(require("crypto"));
 var import_axios = __toESM(require("axios"));
 var import_node_server_utils140 = require("@7365admin1/node-server-utils");
 
@@ -49687,7 +50815,7 @@ function stringifyHidJson(value) {
 }
 
 // src/utils/hid-secret.util.ts
-var import_crypto2 = __toESM(require("crypto"));
+var import_crypto3 = __toESM(require("crypto"));
 var HID_SECRET_ENV = "HID_AMICO_SECRET";
 var HID_LEGACY_SECRET_ENV = "ACCESS_TOKEN_SECRET";
 var HID_SECRET_MISSING_FOR_WRITE = `${HID_SECRET_ENV} is not configured, so a new HID credential cannot be encrypted. Set ${HID_SECRET_ENV} on this service and try again. It is deliberately NOT falling back to ${HID_LEGACY_SECRET_ENV}: that key is rotated independently, and anything encrypted with it becomes permanently unreadable the moment it is.`;
@@ -49708,7 +50836,7 @@ function resolveHidSecretKey(purpose, env2 = process.env) {
   return { key: deriveKey(legacy), usedLegacyFallback: true };
 }
 function deriveKey(secret) {
-  return import_crypto2.default.createHash("sha256").update(secret).digest();
+  return import_crypto3.default.createHash("sha256").update(secret).digest();
 }
 
 // src/services/hid-amico.service.ts
@@ -49912,8 +51040,8 @@ function getPublicMonitorConfiguration(monitor, callbackToken) {
   };
 }
 function encryptSecret(value) {
-  const iv = import_crypto3.default.randomBytes(12);
-  const cipher = import_crypto3.default.createCipheriv("aes-256-gcm", getSecretKey("encrypt"), iv);
+  const iv = import_crypto4.default.randomBytes(12);
+  const cipher = import_crypto4.default.createCipheriv("aes-256-gcm", getSecretKey("encrypt"), iv);
   const encrypted = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
   const tag = cipher.getAuthTag();
   return [PASSWORD_PREFIX, iv.toString("hex"), tag.toString("hex"), encrypted.toString("hex")].join(":");
@@ -49925,7 +51053,7 @@ function decryptSecret(value) {
   const key = getSecretKey("decrypt");
   try {
     const [, ivHex, tagHex, encryptedHex] = value.split(":");
-    const decipher = import_crypto3.default.createDecipheriv("aes-256-gcm", key, Buffer.from(ivHex, "hex"));
+    const decipher = import_crypto4.default.createDecipheriv("aes-256-gcm", key, Buffer.from(ivHex, "hex"));
     decipher.setAuthTag(Buffer.from(tagHex, "hex"));
     return Buffer.concat([
       decipher.update(Buffer.from(encryptedHex, "hex")),
@@ -49965,7 +51093,7 @@ function normalizeHidReaderBaseUrl(value) {
   return endpoint.origin;
 }
 function createStableHidId(seed) {
-  const bytes = import_crypto3.default.createHash("sha256").update(seed).digest().subarray(0, 6);
+  const bytes = import_crypto4.default.createHash("sha256").update(seed).digest().subarray(0, 6);
   return Number.parseInt(bytes.toString("hex"), 16) || 1;
 }
 function isUnknownRecord2(value) {
@@ -50040,7 +51168,7 @@ function resolveProfileIdentityType(memberType, userType) {
 var VISITOR_QR_FORMAT = "0";
 function createVisitorQrCredential(visitorId, readerId, qrValue) {
   const credentialId = createStableHidId(`visitor-qr:${readerId}:${visitorId}`);
-  const token = qrValue || `VIS${import_crypto3.default.randomBytes(12).toString("hex").toUpperCase()}`;
+  const token = qrValue || `VIS${import_crypto4.default.randomBytes(12).toString("hex").toUpperCase()}`;
   return { credentialId, object: "qrcodes", value: token, qrValue: token };
 }
 async function configureVisitorQrReader(client) {
@@ -50544,7 +51672,7 @@ function getSipProvisioningConfig() {
   return { provisionerUrl, provisionerToken, websocketUrl, domain };
 }
 function createSipPassword() {
-  return import_crypto3.default.randomBytes(12).toString("base64url");
+  return import_crypto4.default.randomBytes(12).toString("base64url");
 }
 function sipAccountResponse(account) {
   const { websocketUrl, domain } = getSipProvisioningConfig();
@@ -53224,7 +54352,7 @@ function useHidAmicoService() {
     assertReaderCardProfile(reader, cardType);
     const hidUserId = Number(hidUserIdValue);
     const client = new HidAmicoClient(reader);
-    const lockOwner = import_crypto3.default.randomUUID();
+    const lockOwner = import_crypto4.default.randomUUID();
     const acquired = await repo.acquireEnrollmentLock(readerId, lockOwner, timeoutSeconds + 30);
     if (!acquired) {
       throw new import_node_server_utils140.BadRequestError("Another physical HID card enrollment is already running on this reader.");
@@ -55506,17 +56634,17 @@ var import_fs5 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var import_axios2 = __toESM(require("axios"));
 var import_xml2js = require("xml2js");
-var import_crypto4 = __toESM(require("crypto"));
+var import_crypto5 = __toESM(require("crypto"));
 var ALGORITHM = "aes-256-gcm";
-var SECRET_KEY = import_crypto4.default.createSecretKey(
-  new Uint8Array(import_crypto4.default.createHash("sha256").update("acm-secret-key").digest())
+var SECRET_KEY = import_crypto5.default.createSecretKey(
+  new Uint8Array(import_crypto5.default.createHash("sha256").update("acm-secret-key").digest())
 );
 function decryptAcmUrl(encryptedText) {
   const [ivB64, authTagB64, encryptedB64] = encryptedText.split(":");
   const iv = Buffer.from(ivB64, "base64");
   const authTag = Buffer.from(authTagB64, "base64");
   const encrypted = Buffer.from(encryptedB64, "base64");
-  const decipher = import_crypto4.default.createDecipheriv(
+  const decipher = import_crypto5.default.createDecipheriv(
     ALGORITHM,
     SECRET_KEY,
     new Uint8Array(iv)
@@ -55659,10 +56787,10 @@ async function getTransactions(index, url) {
 }
 function encryptPayload(payloadHex) {
   const buffer = Buffer.from(payloadHex, "ascii");
-  const encrypted = import_crypto4.default.publicEncrypt(
+  const encrypted = import_crypto5.default.publicEncrypt(
     {
       key: "testing",
-      padding: import_crypto4.default.constants.RSA_PKCS1_PADDING
+      padding: import_crypto5.default.constants.RSA_PKCS1_PADDING
     },
     buffer
   );
@@ -55672,7 +56800,7 @@ function toHex(num, length) {
   return num.toString(16).padStart(length * 2, "0");
 }
 function buildPayload(cardNumber, validityMinutes) {
-  const randomHex = import_crypto4.default.randomBytes(2).toString("hex");
+  const randomHex = import_crypto5.default.randomBytes(2).toString("hex");
   const cardHex = toHex(cardNumber, 4);
   const epochHex = toHex(Math.floor(Date.now() / 1e3), 4);
   const validityHex = toHex(validityMinutes, 2);
@@ -60615,6 +61743,21 @@ var import_joi72 = __toESM(require("joi"));
 var import_node_server_utils148 = require("@7365admin1/node-server-utils");
 var import_node_server_utils149 = require("@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) {
   if (!Array.isArray(body?.files))
@@ -60723,6 +61866,41 @@ function usePersonController() {
       next(new import_node_server_utils148.BadRequestError(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) {
+          import_node_server_utils148.logger.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 import_node_server_utils149.UnauthorizedError("Not authorized."));
+          return;
+        }
+      }
+    } catch (gateError) {
+      import_node_server_utils148.logger.log({
+        level: "warn",
+        message: `[people-create] reach check failed open: ${gateError?.message}`
+      });
+    }
     try {
       const data = await _add(payload);
       res.status(201).json({ message: data });
@@ -86987,7 +88165,7 @@ function useRedDotPaymentController() {
 
 // src/services/verification-v2.service.ts
 var import_node_server_utils271 = require("@7365admin1/node-server-utils");
-var import_crypto5 = __toESM(require("crypto"));
+var import_crypto6 = __toESM(require("crypto"));
 var import_joi142 = __toESM(require("joi"));
 
 // src/services/auth-v2.service.ts
@@ -87685,7 +88863,7 @@ function useVerificationServiceV2() {
   }
   function generateVerificationCode(length = 8) {
     const chars = "0123456789";
-    const bytes = import_crypto5.default.randomBytes(length);
+    const bytes = import_crypto6.default.randomBytes(length);
     let result = "";
     for (let i = 0; i < length; i++) {
       result += chars[bytes[i] % chars.length];
@@ -95518,6 +96696,7 @@ function usePersonalEmergencyChainController() {
   cameraGrant,
   cameraHealthClaim,
   cameraHealthSummary,
+  cameraListClearConfirmation,
   cameraManagePermissions,
   cameraProbeCacheKey,
   cameraTransports,