diff --git a/package.json b/package.json
index 5f89a5e8..deab7c43 100644
--- a/package.json
+++ b/package.json
@@ -60,7 +60,6 @@
     "leaflet.measure": "^1.0.0",
     "leaflet.polylinemeasure": "^3.0.0",
     "leaflet.vectorgrid": "^1.3.0",
-    "markerwithlabel": "^2.0.2",
     "moment": "^2.29.1",
     "nunjucks": "^3.2.4",
     "remove": "^0.1.5",
diff --git a/src/lib/noop.js b/src/lib/noop.js
new file mode 100644
index 00000000..9c219abb
--- /dev/null
+++ b/src/lib/noop.js
@@ -0,0 +1,4 @@
+// Empty stub module used by webpack to replace packages that are incompatible
+// with Chrome Extension MV3 CSP (e.g. @googlemaps/js-api-loader which
+// dynamically injects <script> tags).
+module.exports = {};
diff --git a/src/pages/tasking/components/alerts.js b/src/pages/tasking/components/alerts.js
index 737bce70..3fcd424e 100644
--- a/src/pages/tasking/components/alerts.js
+++ b/src/pages/tasking/components/alerts.js
@@ -246,7 +246,7 @@ function buildDefaultRules(vm) {
     {
       id: 'unacked-notifications',
       level: 'danger',
-      title: 'Unacknowledged notifications',
+      title: 'Unacknowledged ICEMS notifications',
       active: unackedNotifications.length > 0,
       items: unackedNotifications.slice(0, 10).map(asItem),
       count: unackedNotifications.length,
diff --git a/src/pages/tasking/main.js b/src/pages/tasking/main.js
index 5238810e..5222eb2e 100644
--- a/src/pages/tasking/main.js
+++ b/src/pages/tasking/main.js
@@ -56,6 +56,10 @@ import { registerSESUnitLocationsLayer } from "./mapLayers/geoservices.js";
 import { registerTransportIncidentsLayer } from "./mapLayers/transport.js";
 import { renderFRAOSLayer } from "./mapLayers/frao.js";
 import { registerHazardWatchWarningsLayer } from "./mapLayers/hazardwatch.js"
+import { registerPowerBoundariesGridLayer } from "./mapLayers/power.js";
+import { registerWaterNSWBoundariesLayer, registerEPAContaminationSitesLayer } from "./mapLayers/waternsw.js";
+import { registerBOMLandWarningsLayer } from "./mapLayers/bom.js";
+import { registerRainRadarLayer } from "./mapLayers/weather.js";
 
 import { fetchHqDetailsSummary } from './utils/hqSummary.js';
 
@@ -1245,7 +1249,7 @@ function VM() {
 
         for (const m of s.matchAll(re)) {
             const tok = _normAssetName(m[0]); // strips spaces/punct => "par56"
-            if (!tok || seen.has(tok)) continue;
+            if (!tok) continue;
             seen.add(tok);
             tokens.push(tok);
         }
@@ -1291,23 +1295,27 @@ function VM() {
         const matchedAssets = new Set();
         const usedTokens = new Set();
 
-        // 1) EXACT first: token === assetName
+        // 1) EXACT first: token === assetName (one match per token)
+        //    If multiple exact matches exist, prefer non-Portable resourceType
         for (const tok of tokens) {
             const exactList = byName.get(tok);
             if (!exactList || !exactList.length) continue;
 
-            // allow multiple exact matches (duplicate assets with same name)
-            let addedAny = false;
-            for (const a of exactList) {
-                if (matchedAssetIds.has(a.id())) continue;
-                matchedAssetIds.add(a.id());
-                matchedAssets.add(a);
-                addedAny = true;
-            }
+            // Filter to unmatched candidates
+            const candidates = exactList.filter(a => !matchedAssetIds.has(a.id()));
+            if (!candidates.length) continue;
+
+            // Sort so that Portable resourceType comes last (least preferable)
+            candidates.sort((a, b) => {
+            const aPortable = (ko.unwrap(a.resourceType) || '').toLowerCase() === 'portable' ? 1 : 0;
+            const bPortable = (ko.unwrap(b.resourceType) || '').toLowerCase() === 'portable' ? 1 : 0;
+            return aPortable - bPortable;
+            });
 
-            // consume the token if it produced at least one exact match,
-            // so it won't be used for fuzzy matching.
-            if (addedAny) usedTokens.add(tok);
+            const best = candidates[0];
+            matchedAssetIds.add(best.id());
+            matchedAssets.add(best);
+            usedTokens.add(tok);
         }
 
         // 2) FUZZY second (token consumed once; asset matched once)
@@ -1663,6 +1671,10 @@ function VM() {
 
     // Maintain markers only for currently filtered assets
     self.filteredTrackableAssets.subscribe((changes) => {
+        // bail fast if the layer is not currently visible
+        if (!self.mapVM || !map.hasLayer(self.mapVM.assetLayer)) {
+            return;
+        }
         changes.forEach(ch => {
             const a = ch.value;
             if (ch.status === 'added') {
@@ -1690,21 +1702,37 @@ function VM() {
         });
     }, null, "arrayChange");
 
+    // --- Matched asset layer: populate / tear-down on toggle ---
+    map.on('layeradd', (ev) => {
+        if (ev.layer !== self.mapVM.assetLayer) return;
+        const assets = self.filteredTrackableAssets?.() || [];
+        assets.forEach(a => {
+            attachAssetMarker(ko, map, self, a);
+        });
+    });
+
+    map.on('layerremove', (ev) => {
+        if (ev.layer !== self.mapVM.assetLayer) return;
+        const assets = self.filteredTrackableAssets?.() || [];
+        assets.forEach(a => {
+            detachAssetMarker(ko, map, self, a);
+        });
+    });
+
+    // --- Unmatched asset layer: populate / tear-down on toggle ---
     map.on('layeradd', (ev) => {
         if (ev.layer !== self.mapVM.unmatchedAssetLayer) return;
-        // initial populate unmatchedTrackableAssets only when layer becomes visible
         const assets = self.unmatchedTrackableAssets?.() || [];
         assets.forEach(a => {
-            attachUnmatchedAssetMarker(ko, self.map, self, a);
+            attachUnmatchedAssetMarker(ko, map, self, a);
         });
     });
 
-    // catch the unmatchedTrackableAssets layer being turned off to remove markers
     map.on('layerremove', (ev) => {
         if (ev.layer !== self.mapVM.unmatchedAssetLayer) return;
         const assets = self.unmatchedTrackableAssets?.() || [];
         assets.forEach(a => {
-            attachUnmatchedAssetMarker(ko, self.map, self, a);
+            detachUnmatchedAssetMarker(ko, map, self, a);
         });
     });
 
@@ -2143,6 +2171,11 @@ function VM() {
     registerHazardWatchWarningsLayer(self, apiHost);
     registerSESUnitLocationsLayer(self);
     renderFRAOSLayer(self, map, getToken, apiHost, params);
+    registerPowerBoundariesGridLayer(self, map);
+    registerWaterNSWBoundariesLayer(self);
+    registerEPAContaminationSitesLayer(self);
+    registerBOMLandWarningsLayer(self);
+    registerRainRadarLayer(self, map);
 
     // --- Layers Drawer (under zoom)
     const LayersDrawer = L.Control.extend({
@@ -2272,7 +2305,7 @@ function VM() {
 
                 const gid = safeId(groupKey);
                 const storeKey = `layers.ovgrp.${gid}`;
-                const open = localStorage.getItem(storeKey) !== "0"; // default open
+                const open = localStorage.getItem(storeKey) === "1"; // default closed
 
                 const item = document.createElement("div");
                 item.className = "accordion-item";
diff --git a/src/pages/tasking/mapLayers/bom.js b/src/pages/tasking/mapLayers/bom.js
new file mode 100644
index 00000000..d7f7445e
--- /dev/null
+++ b/src/pages/tasking/mapLayers/bom.js
@@ -0,0 +1,186 @@
+import * as esri from "esri-leaflet";
+
+const BASE_URL =
+  "https://services1.arcgis.com/vkTwD8kHw2woKBqV/arcgis/rest/services/BOM_Land_Warnings_RO/FeatureServer";
+
+/* ── Flood Warning severity colours (layer 0 & 1) ────────────── */
+function floodSeverityStyle(severity) {
+  switch (severity) {
+    case "MAJ":
+      return { color: "#E60000", fillColor: "#FF0000", fillOpacity: 0.4 };
+    case "MOD":
+      return { color: "#FFAA00", fillColor: "#FFAA00", fillOpacity: 0.4 };
+    case "MIN":
+      return { color: "#38A800", fillColor: "#B4D79E", fillOpacity: 0.4 };
+    case "BMIN":
+      return { color: "#00C5FF", fillColor: "#FFFFFF", fillOpacity: 0.3 };
+    case "FINAL":
+      return { color: "#CDCD66", fillColor: "#F2F2E1", fillOpacity: 0.3 };
+    case "UNCL":
+    default:
+      return { color: "#C8C3FF", fillColor: "#EFEDFF", fillOpacity: 0.3 };
+  }
+}
+
+/* ── Fire Weather severity colours (layer 4) ──────────────────── */
+function fireSeverityStyle(severity) {
+  switch (severity) {
+    case "CAT":
+      return { color: "#730000", fillColor: "#730000", fillOpacity: 0.45 };
+    case "EXT":
+      return { color: "#E60000", fillColor: "#E60000", fillOpacity: 0.4 };
+    case "SEV":
+    default:
+      return { color: "#E69800", fillColor: "#E69800", fillOpacity: 0.4 };
+  }
+}
+
+/* ── Human-readable severity label ────────────────────────────── */
+function severityLabel(code) {
+  const map = {
+    MAJ: "Major",
+    MOD: "Moderate",
+    MIN: "Minor",
+    BMIN: "Below Minor",
+    UNCL: "Generalised",
+    FINAL: "Final Warning",
+    SEV: "Severe",
+    CAT: "Catastrophic",
+    EXT: "Extreme",
+  };
+  return map[code] || code || "";
+}
+
+/**
+ * Register a single toggle that draws all five BOM Land Warning sub-layers.
+ */
+export function registerBOMLandWarningsLayer(vm) {
+  vm.mapVM.registerPollingLayer("bomLandWarnings", {
+    label: "BOM Land Warnings",
+    menuGroup: "Bureau of Meteorology",
+    refreshMs: 300000, // 5 min – warnings update frequently
+    visibleByDefault: localStorage.getItem(`ov.bomLandWarnings`) || false,
+    fetchFn: async () => {
+      return {};
+    },
+    drawFn: (layerGroup, data) => {
+      if (!data) return;
+
+      /* --- 0  Flood Warning ----------------------------------- */
+      const floodWarning = esri.featureLayer({
+        url: `${BASE_URL}/0`,
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "name", "severity", "status", "phase", "start_time_local", "end_time_local"],
+        style: (feature) => {
+          const s = floodSeverityStyle(feature.properties.severity);
+          return { weight: 2, color: s.color, opacity: 1, fill: true, fillColor: s.fillColor, fillOpacity: s.fillOpacity };
+        },
+      });
+      floodWarning.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>🌊 Flood Warning</strong><br>
+          ${p.name || "Unknown"}<br>
+          <strong>Severity:</strong> ${severityLabel(p.severity)}<br>
+          ${p.phase ? `<strong>Phase:</strong> ${p.phase}<br>` : ""}
+          ${p.start_time_local ? `<strong>From:</strong> ${new Date(p.start_time_local).toLocaleString()}<br>` : ""}
+          ${p.end_time_local ? `<strong>Until:</strong> ${new Date(p.end_time_local).toLocaleString()}` : ""}`;
+      });
+      layerGroup.addLayer(floodWarning);
+
+      /* --- 1  Flood Watch -------------------------------------- */
+      const floodWatch = esri.featureLayer({
+        url: `${BASE_URL}/1`,
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "name", "severity", "status", "phase", "start_time_local", "end_time_local"],
+        style: (feature) => {
+          const s = floodSeverityStyle(feature.properties.severity);
+          return { weight: 2, dashArray: "6 4", color: s.color, opacity: 1, fill: true, fillColor: s.fillColor, fillOpacity: s.fillOpacity * 0.6 };
+        },
+      });
+      floodWatch.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>👁️ Flood Watch</strong><br>
+          ${p.name || "Unknown"}<br>
+          <strong>Severity:</strong> ${severityLabel(p.severity)}<br>
+          ${p.phase ? `<strong>Phase:</strong> ${p.phase}<br>` : ""}
+          ${p.start_time_local ? `<strong>From:</strong> ${new Date(p.start_time_local).toLocaleString()}<br>` : ""}
+          ${p.end_time_local ? `<strong>Until:</strong> ${new Date(p.end_time_local).toLocaleString()}` : ""}`;
+      });
+      layerGroup.addLayer(floodWatch);
+
+      /* --- 2  Severe Weather Warning --------------------------- */
+      const severeWeather = esri.featureLayer({
+        url: `${BASE_URL}/2`,
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "product", "phenomena", "warning", "validfrom_utc", "validto_utc"],
+        style: () => ({
+          weight: 1.5,
+          color: "#6E6E6E",
+          opacity: 1,
+          fill: true,
+          fillColor: "#F7E363",
+          fillOpacity: 0.45,
+        }),
+      });
+      severeWeather.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>⚠️ Severe Weather Warning</strong><br>
+          ${p.phenomena || p.product || "Unknown"}<br>
+          ${p.warning ? `${p.warning}<br>` : ""}
+          ${p.validfrom_utc ? `<strong>From:</strong> ${new Date(p.validfrom_utc).toLocaleString()}<br>` : ""}
+          ${p.validto_utc ? `<strong>Until:</strong> ${new Date(p.validto_utc).toLocaleString()}` : ""}`;
+      });
+      layerGroup.addLayer(severeWeather);
+
+      /* --- 3  Thunderstorm Warning ----------------------------- */
+      const thunderstorm = esri.featureLayer({
+        url: `${BASE_URL}/3`,
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "severity", "status", "phase", "start_time_local", "end_time_local", "state_code"],
+        style: () => ({
+          weight: 1.5,
+          color: "#6E6E6E",
+          opacity: 1,
+          fill: true,
+          fillColor: "#C896FF",
+          fillOpacity: 0.4,
+        }),
+      });
+      thunderstorm.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>⛈️ Thunderstorm Warning</strong><br>
+          <strong>Severity:</strong> ${severityLabel(p.severity)}<br>
+          ${p.phase ? `<strong>Phase:</strong> ${p.phase}<br>` : ""}
+          ${p.start_time_local ? `<strong>From:</strong> ${new Date(p.start_time_local).toLocaleString()}<br>` : ""}
+          ${p.end_time_local ? `<strong>Until:</strong> ${new Date(p.end_time_local).toLocaleString()}` : ""}`;
+      });
+      layerGroup.addLayer(thunderstorm);
+
+      /* --- 4  Fire Weather Warnings ---------------------------- */
+      const fireWeather = esri.featureLayer({
+        url: `${BASE_URL}/4`,
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "severity", "status", "headline", "day", "start_time_local", "end_time_local", "state_code"],
+        style: (feature) => {
+          const s = fireSeverityStyle(feature.properties.severity);
+          return { weight: 1.5, color: s.color, opacity: 1, fill: true, fillColor: s.fillColor, fillOpacity: s.fillOpacity };
+        },
+      });
+      fireWeather.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>🔥 Fire Weather Warning</strong><br>
+          ${p.headline || ""}<br>
+          <strong>Severity:</strong> ${severityLabel(p.severity)}<br>
+          ${p.day ? `<strong>Day:</strong> ${p.day}<br>` : ""}
+          ${p.start_time_local ? `<strong>From:</strong> ${new Date(p.start_time_local).toLocaleString()}<br>` : ""}
+          ${p.end_time_local ? `<strong>Until:</strong> ${new Date(p.end_time_local).toLocaleString()}` : ""}`;
+      });
+      layerGroup.addLayer(fireWeather);
+    },
+  });
+}
diff --git a/src/pages/tasking/mapLayers/geoservices.js b/src/pages/tasking/mapLayers/geoservices.js
index 67dfce1e..cea5e80b 100644
--- a/src/pages/tasking/mapLayers/geoservices.js
+++ b/src/pages/tasking/mapLayers/geoservices.js
@@ -1,4 +1,5 @@
 import BeaconClient from "../../../shared/BeaconClient";
+import { unitColorMap } from "../utils/unitColorMap";
 import L from "leaflet";
 
 
@@ -152,7 +153,7 @@ export function registerSESUnitsZonesHybridGridLayer(vm, map) {
     drawFn: (layerGroup, data) => {
 
       if (!data) return;
-      const LABEL_ZOOM_THRESHOLD = 10;  // tweak to taste
+      const LABEL_ZOOM_THRESHOLD = 9;  // tweak to taste
 
       const vectorGrid = L.vectorGrid.protobuf(
         `https://map.lighthouse-extension.com/sesunits/tiles/{z}/{x}/{y}.pbf`, // Replace with actual path
@@ -266,16 +267,7 @@ function zoneFillColor(code) {
 
 function colorByUnitCode(code) {
   if (!code) return '#999';
-
-  let hash = 0;
-  for (let i = 0; i < code.length; i++) {
-    hash = (hash << 5) - hash + code.charCodeAt(i);
-    hash |= 0;
-  }
-
-  // Spread around 360° hue wheel
-  const hue = Math.abs(hash) % 360;
-  return `hsl(${hue}, 70%, 50%)`;
+  return unitColorMap[code] || '#999';
 }
 
 
@@ -311,7 +303,6 @@ export function registerSESUnitLocationsLayer(vm) {
           marker.on('popupopen', async () => {
             try {
               const details = await vm.fetchHQDetails(feature.properties.HQNAME);
-              console.log("Fetched HQ details for popup:", details);
               const popupContent = `
             <div style="background-color: #333; color: #fff; padding: 5px; text-align: center; font-weight: bold; width: 300px;">
               ${name}
diff --git a/src/pages/tasking/mapLayers/power.js b/src/pages/tasking/mapLayers/power.js
new file mode 100644
index 00000000..a6da4867
--- /dev/null
+++ b/src/pages/tasking/mapLayers/power.js
@@ -0,0 +1,95 @@
+import L from "leaflet";
+
+export function registerPowerBoundariesGridLayer(vm, _map) {
+  vm.mapVM.registerPollingLayer("powerBoundaries", {
+    label: "Electrical Distribution Boundaries",
+    menuGroup: "Public Service",
+    refreshMs: 0, // No auto-refresh, only redraw on filter change
+    visibleByDefault: localStorage.getItem(`ov.powerBoundaries`) || false,
+    fetchFn: async () => {
+      return {};
+    },
+    drawFn: (layerGroup, data) => {
+
+      if (!data) return;
+
+      const vectorGrid = L.vectorGrid.protobuf(
+        `https://map.lighthouse-extension.com/power/tiles/{z}/{x}/{y}.pbf`,
+        {
+          pane: 'pane-lowest',
+          vectorTileLayerStyles: {
+            'ausgrid_boundary': (_props) => {
+              return {
+                weight: 1.2,
+                color: '#333',
+                opacity: 1,
+                fill: true,
+                fillColor: '#ff7800',
+                fillOpacity: 0.3
+              };
+            },
+            'endeavour_boundary': (_props) => {
+              return {
+                weight: 1.2,
+                color: '#333',
+                opacity: 1,
+                fill: true,
+                fillColor: '#26229cff',
+                fillOpacity: 0.3
+              };
+            },
+            'essential_boundary': (_props) => {
+              return {
+                weight: 1.2,
+                color: '#333',
+                opacity: 1,
+                fill: true,
+                fillColor: '#74ac7aff',
+                fillOpacity: 0.3
+              };
+            },
+            'evo_boundary': (_props) => {
+              return {
+                weight: 1.2,
+                color: '#333',
+                opacity: 1,
+                fill: true,
+                fillColor: '#812e2eff',
+                fillOpacity: 0.3
+              };
+            },
+          },
+          interactive: true
+        });
+
+
+      layerGroup.addLayer(vectorGrid);
+
+      const powerLabelLayer = L.geoJSON(null, {
+        pointToLayer: (feature, latlng) => {
+          const name = feature.properties.name;
+          return L.marker(latlng, {
+            interactive: false,
+            pane: 'pane-middle-plus',
+            icon: L.divIcon({
+              className: 'unit-label',
+              html: name,
+              iconSize: [0, 0]
+            })
+          });
+        }
+      });
+
+
+      // Load unit labels
+      fetch('https://map.lighthouse-extension.com/power/power_labels.geojson')
+        .then(r => r.json())
+        .then(data => {
+          powerLabelLayer.addData(data);
+          layerGroup.addLayer(powerLabelLayer)
+        });
+
+
+    },
+  });
+}
\ No newline at end of file
diff --git a/src/pages/tasking/mapLayers/waternsw.js b/src/pages/tasking/mapLayers/waternsw.js
new file mode 100644
index 00000000..25dff737
--- /dev/null
+++ b/src/pages/tasking/mapLayers/waternsw.js
@@ -0,0 +1,109 @@
+import L from "leaflet";
+import * as esri from "esri-leaflet";
+
+/**
+ * Colour by WaterNSW Special/Controlled Area class.
+ * Mirrors the service's own renderer colours.
+ */
+function styleByClass(cls) {
+  switch (cls) {
+    case "Schedule 1 Controlled Area":
+      return { color: "#0070FF", fillColor: "#0070FF" }; // blue
+    case "Schedule 1 Special Area":
+      return { color: "#FF0000", fillColor: "#FF0000" }; // red
+    case "Schedule 2 Special Area":
+      return { color: "#FFAA00", fillColor: "#FFAA00" }; // orange
+    default:
+      return { color: "#888888", fillColor: "#888888" };
+  }
+}
+
+export function registerWaterNSWBoundariesLayer(vm) {
+  vm.mapVM.registerPollingLayer("waternswBoundaries", {
+    label: "WaterNSW Special & Controlled Areas",
+    menuGroup: "Public Service",
+    refreshMs: 0, // static data – no auto-refresh
+    visibleByDefault: localStorage.getItem(`ov.waternswBoundaries`) || false,
+    fetchFn: async () => {
+      return {};
+    },
+    drawFn: (layerGroup, data) => {
+      if (!data) return;
+
+      const featureLayer = esri.featureLayer({
+        url: "https://nula.waternsw.com.au/arcgis/rest/services/WaterNSW_Boundaries/WaterNSW_Boundaries/FeatureServer/1",
+        pane: "pane-lowest",
+        where: "1=1",
+        fields: ["OBJECTID", "Class", "NAME"],
+        style: (feature) => {
+            console.log(feature)
+          const cls = feature.properties.Class;
+          const colours = styleByClass(cls);
+          return {
+            weight: 1.5,
+            color: colours.color,
+            opacity: 1,
+            fill: true,
+            fillColor: colours.fillColor,
+            fillOpacity: 0.3,
+          };
+        },
+      });
+
+      featureLayer.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return `<strong>${p.NAME || "Unknown"}</strong><br>${p.Class || ""}`;
+      });
+
+      layerGroup.addLayer(featureLayer);
+    },
+  });
+}
+
+export function registerEPAContaminationSitesLayer(vm) {
+  vm.mapVM.registerPollingLayer("epaContamination", {
+    label: "EPA Contamination Sites",
+    menuGroup: "Public Service",
+    refreshMs: 0, // updated monthly server-side – no client poll
+    visibleByDefault: localStorage.getItem(`ov.epaContamination`) || false,
+    fetchFn: async () => {
+      return {};
+    },
+    drawFn: (layerGroup, data) => {
+      if (!data) return;
+
+      const featureLayer = esri.featureLayer({
+        url: "https://nula.waternsw.com.au/arcgis/rest/services/External_Data/Contamination_Sites_EPA/FeatureServer/0",
+        where: "1=1",
+        fields: ["OBJECTID", "SiteName", "Address", "Suburb", "ContaminationActivityType", "ManagementClass"],
+        pointToLayer: (_geojson, latlng) => {
+          return L.circleMarker(latlng, {
+            pane: "pane-middle",
+            radius: 5,
+            weight: 0.6,
+            color: "#000",
+            fillColor: "#E60000",
+            fillOpacity: 0.85,
+          });
+        },
+      });
+
+      featureLayer.bindPopup((layer) => {
+        const p = layer.feature.properties;
+        return [
+          `<strong>${p.SiteName || "Unknown Site"}</strong>`,
+          p.Address ? `<br>${p.Address}` : "",
+          p.Suburb ? `, ${p.Suburb}` : "",
+          p.ContaminationActivityType
+            ? `<br><strong>Activity:</strong> ${p.ContaminationActivityType}`
+            : "",
+          p.ManagementClass
+            ? `<br><strong>Management:</strong> ${p.ManagementClass}`
+            : "",
+        ].join("");
+      });
+
+      layerGroup.addLayer(featureLayer);
+    },
+  });
+}
diff --git a/src/pages/tasking/mapLayers/weather.js b/src/pages/tasking/mapLayers/weather.js
new file mode 100644
index 00000000..ca4eea49
--- /dev/null
+++ b/src/pages/tasking/mapLayers/weather.js
@@ -0,0 +1,243 @@
+import L from "leaflet";
+
+
+
+/* ══════════════════════════════════════════════════════════════
+ *  RainViewer Radar Overlay  (animated, past ~2 h)
+ *  API docs: https://www.rainviewer.com/api/weather-maps-api.html
+ * ══════════════════════════════════════════════════════════════ */
+
+const RAINVIEWER_API = "https://api.rainviewer.com/public/weather-maps.json";
+const FRAME_INTERVAL_MS = 500;   // default playback speed
+const DATA_REFRESH_MS   = 300000; // re-fetch frame list every 5 min
+
+/**
+ * Register an animated rainfall radar overlay powered by the RainViewer API.
+ * Loops through the past ~2 hours of composite radar frames with on-map
+ * playback controls (play / pause / step / scrub).
+ */
+export function registerRainRadarLayer(vm, map) {
+  /* ── state ─────────────────────────────────────────────────── */
+  let frames       = [];       // [{ time, path }]
+  let host         = null;
+  let tileLayers   = [];       // parallel to `frames`
+  let frameIdx     = -1;
+  let playing      = false;
+  let playTimer    = null;
+  let dataTimer    = null;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let activeGroup  = null;
+  let control      = null;
+  let speed        = FRAME_INTERVAL_MS;
+
+  /* ── helpers ───────────────────────────────────────────────── */
+  function buildTileLayer(framePath) {
+    return L.tileLayer(
+      `${host}${framePath}/512/{z}/{x}/{y}/2/1_1.png`,
+      {
+        pane: "pane-lowest-plus",
+        tileSize: 512,
+        zoomOffset: -1,
+        maxNativeZoom: 7,
+        maxZoom: 18,
+        opacity: 0,  // start invisible; showFrame will reveal the active one
+        attribution:
+          '<a href="https://www.rainviewer.com" target="_blank">RainViewer</a>',
+      }
+    );
+  }
+
+  function fmtTime(unix) {
+    const d = new Date(unix * 1000);
+    return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  }
+
+  /* ── frame display ─────────────────────────────────────────── */
+  function showFrame(idx) {
+    if (idx < 0 || idx >= tileLayers.length) return;
+
+    // hide previous
+    if (frameIdx >= 0 && frameIdx < tileLayers.length) {
+      tileLayers[frameIdx].setOpacity(0);
+    }
+    frameIdx = idx;
+    tileLayers[frameIdx].setOpacity(0.6);
+
+    // update control UI
+    if (control) {
+      const ts = control._container.querySelector(".rv-timestamp");
+      const slider = control._container.querySelector(".rv-slider");
+      if (ts) ts.textContent = fmtTime(frames[frameIdx].time);
+      if (slider) slider.value = frameIdx;
+    }
+  }
+
+  function stepForward() {
+    showFrame((frameIdx + 1) % tileLayers.length);
+  }
+
+  function stepBack() {
+    showFrame((frameIdx - 1 + tileLayers.length) % tileLayers.length);
+  }
+
+  function play() {
+    if (playing) return;
+    playing = true;
+    updatePlayBtn();
+    playTimer = setInterval(stepForward, speed);
+  }
+
+  function pause() {
+    playing = false;
+    updatePlayBtn();
+    if (playTimer) { clearInterval(playTimer); playTimer = null; }
+  }
+
+  function togglePlay() { playing ? pause() : play(); }
+
+  function updatePlayBtn() {
+    if (!control) return;
+    const btn = control._container.querySelector(".rv-play");
+    if (btn) btn.textContent = playing ? "⏸" : "▶";
+  }
+
+  /* ── data loading ──────────────────────────────────────────── */
+  async function loadFrames(layerGroup) {
+    try {
+      const res = await fetch(RAINVIEWER_API);
+      if (!res.ok) throw new Error(`RainViewer API ${res.status}`);
+      const json = await res.json();
+      const past = json.radar?.past;
+      if (!past || past.length === 0) return;
+
+      const newHost = json.host;
+      const pathsMatch =
+        host === newHost &&
+        frames.length === past.length &&
+        frames.every((f, i) => f.path === past[i].path);
+
+      if (pathsMatch) return; // nothing changed
+
+      // tear down old tile layers
+      tileLayers.forEach((tl) => {
+        if (layerGroup.hasLayer(tl)) layerGroup.removeLayer(tl);
+      });
+
+      host = newHost;
+      frames = past;
+      tileLayers = frames.map((f) => {
+        const tl = buildTileLayer(f.path);
+        layerGroup.addLayer(tl);
+        return tl;
+      });
+
+      // update slider range
+      if (control) {
+        const slider = control._container.querySelector(".rv-slider");
+        if (slider) { slider.max = frames.length - 1; slider.value = frames.length - 1; }
+      }
+
+      // show latest frame
+      frameIdx = -1;
+      showFrame(frames.length - 1);
+    } catch (err) {
+      console.warn("[RainViewer Radar] Failed to load frames:", err);
+    }
+  }
+
+  /* ── Leaflet control for playback ──────────────────────────── */
+  const RadarControl = L.Control.extend({
+    options: { position: "bottomleft" },
+    onAdd() {
+      const c = L.DomUtil.create("div", "leaflet-bar rv-control");
+      L.DomEvent.disableClickPropagation(c);
+      L.DomEvent.disableScrollPropagation(c);
+
+      c.innerHTML = `
+        <div style="
+          display:flex; align-items:center; gap:6px;
+          background:#fff; padding:4px 8px; border-radius:4px;
+          font-size:12px; font-family:monospace; box-shadow:0 1px 4px rgba(0,0,0,.3);
+          user-select:none;
+        ">
+          <button class="rv-step-back" title="Previous frame"
+            style="border:none;background:none;cursor:pointer;font-size:14px;padding:2px;">⏮</button>
+          <button class="rv-play" title="Play / Pause"
+            style="border:none;background:none;cursor:pointer;font-size:14px;padding:2px;">▶</button>
+          <button class="rv-step-fwd" title="Next frame"
+            style="border:none;background:none;cursor:pointer;font-size:14px;padding:2px;">⏭</button>
+          <input class="rv-slider" type="range" min="0" max="0" value="0"
+            style="width:120px;cursor:pointer;" title="Scrub through frames" />
+          <span class="rv-timestamp" style="min-width:48px;text-align:center;">--:--</span>
+          <select class="rv-speed" title="Playback speed"
+            style="border:1px solid #ccc;border-radius:3px;font-size:11px;padding:1px 2px;cursor:pointer;">
+            <option value="1000">0.5×</option>
+            <option value="500" selected>1×</option>
+            <option value="250">2×</option>
+            <option value="125">4×</option>
+          </select>
+        </div>`;
+
+      c.querySelector(".rv-play").addEventListener("click", togglePlay);
+      c.querySelector(".rv-step-back").addEventListener("click", () => { pause(); stepBack(); });
+      c.querySelector(".rv-step-fwd").addEventListener("click", () => { pause(); stepForward(); });
+      c.querySelector(".rv-slider").addEventListener("input", (e) => {
+        pause();
+        showFrame(parseInt(e.target.value, 10));
+      });
+      c.querySelector(".rv-speed").addEventListener("change", (e) => {
+        speed = parseInt(e.target.value, 10);
+        if (playing) { pause(); play(); }
+      });
+
+      return c;
+    },
+  });
+
+  /* ── layer registration ────────────────────────────────────── */
+  vm.mapVM.registerPollingLayer("rainRadar", {
+    label: "Rainfall Radar - Animated",
+    menuGroup: "Weather",
+    refreshMs: 0,
+    visibleByDefault: localStorage.getItem(`ov.rainRadar`) || false,
+    fetchFn: async () => {
+      return {};
+    },
+    drawFn: (layerGroup, data) => {
+      if (!data) return;
+
+      // Clean up any previous cycle (toggle off → on)
+      pause();
+      if (dataTimer) { clearInterval(dataTimer); dataTimer = null; }
+      if (control) { map.removeControl(control); control = null; }
+      tileLayers = [];
+      frames = [];
+      frameIdx = -1;
+      activeGroup = layerGroup;
+
+      // Add playback control to the map
+      control = new RadarControl();
+      map.addControl(control);
+
+      // Clean up control + timers when the layerGroup is removed from the map
+      layerGroup.on("remove", cleanup);
+
+      // Initial load + periodic refresh of frame list
+      loadFrames(layerGroup);
+      dataTimer = setInterval(() => loadFrames(layerGroup), DATA_REFRESH_MS);
+
+      // Auto-play
+      play();
+    },
+  });
+
+  function cleanup() {
+    pause();
+    if (dataTimer) { clearInterval(dataTimer); dataTimer = null; }
+    if (control) { map.removeControl(control); control = null; }
+    tileLayers = [];
+    frames = [];
+    frameIdx = -1;
+    activeGroup = null;
+  }
+}
diff --git a/src/pages/tasking/utils/unitColorMap.js b/src/pages/tasking/utils/unitColorMap.js
new file mode 100644
index 00000000..7cc5d5d2
--- /dev/null
+++ b/src/pages/tasking/utils/unitColorMap.js
@@ -0,0 +1,237 @@
+// Auto-generated by unitColors.js – 2026-02-13T01:14:22.306Z
+// Maps SES UNITCODE → hex colour (4-colour theorem)
+export const unitColorMap = {
+  "WGT": "#4363d8",
+  "WWY": "#e6194b",
+  "CCX": "#f58231",
+  "WAL": "#3cb44b",
+  "WBN": "#e6194b",
+  "YNG": "#4363d8",
+  "NRN": "#f58231",
+  "WGA": "#e6194b",
+  "LPS": "#3cb44b",
+  "OOM": "#e6194b",
+  "WRN": "#3cb44b",
+  "BDN": "#4363d8",
+  "LSY": "#3cb44b",
+  "BRW": "#3cb44b",
+  "MOL": "#e6194b",
+  "GUN": "#f58231",
+  "NAA": "#3cb44b",
+  "ARM": "#e6194b",
+  "COP": "#3cb44b",
+  "CLB": "#e6194b",
+  "HIL": "#f58231",
+  "CWT": "#3cb44b",
+  "CON": "#f58231",
+  "CLR": "#e6194b",
+  "WHT": "#e6194b",
+  "NME": "#4363d8",
+  "GLS": "#f58231",
+  "KPS": "#4363d8",
+  "TAR": "#e6194b",
+  "BIN": "#e6194b",
+  "WRI": "#3cb44b",
+  "IVL": "#f58231",
+  "BNG": "#f58231",
+  "COB": "#4363d8",
+  "MGE": "#3cb44b",
+  "MRE": "#f58231",
+  "MWA": "#f58231",
+  "DUN": "#e6194b",
+  "URL": "#f58231",
+  "BAY": "#e6194b",
+  "NOW": "#f58231",
+  "TMT": "#3cb44b",
+  "FBS": "#4363d8",
+  "BWR": "#f58231",
+  "OAG": "#f58231",
+  "NYN": "#e6194b",
+  "CBL": "#e6194b",
+  "GIL": "#f58231",
+  "WHP": "#f58231",
+  "STO": "#e6194b",
+  "CAS": "#f58231",
+  "DEP": "#4363d8",
+  "IVH": "#e6194b",
+  "GUY": "#3cb44b",
+  "BAB": "#4363d8",
+  "GBN": "#4363d8",
+  "LAW": "#f58231",
+  "ULM": "#3cb44b",
+  "MCL": "#4363d8",
+  "MSV": "#e6194b",
+  "CCN": "#f58231",
+  "HAY": "#4363d8",
+  "GND": "#4363d8",
+  "DQN": "#3cb44b",
+  "URN": "#4363d8",
+  "GLG": "#3cb44b",
+  "TMW": "#e6194b",
+  "CAW": "#4363d8",
+  "EUG": "#f58231",
+  "SYD": "#3cb44b",
+  "BKE": "#3cb44b",
+  "DBO": "#3cb44b",
+  "PIL": "#f58231",
+  "NUN": "#4363d8",
+  "KYG": "#e6194b",
+  "TAB": "#4363d8",
+  "ASH": "#e6194b",
+  "TEN": "#f58231",
+  "TGA": "#4363d8",
+  "MEN": "#3cb44b",
+  "WTN": "#4363d8",
+  "PTS": "#3cb44b",
+  "MBH": "#4363d8",
+  "ASL": "#e6194b",
+  "CFS": "#3cb44b",
+  "BEL": "#f58231",
+  "DOR": "#4363d8",
+  "HDN": "#3cb44b",
+  "YAS": "#f58231",
+  "SHE": "#4363d8",
+  "BRD": "#3cb44b",
+  "CLM": "#4363d8",
+  "CTA": "#e6194b",
+  "BAR": "#e6194b",
+  "JER": "#f58231",
+  "JUN": "#3cb44b",
+  "TEM": "#f58231",
+  "PKE": "#3cb44b",
+  "TDL": "#e6194b",
+  "EUA": "#3cb44b",
+  "BOM": "#3cb44b",
+  "CFL": "#4363d8",
+  "SNO": "#4363d8",
+  "BLY": "#e6194b",
+  "MAR": "#4363d8",
+  "BUR": "#4363d8",
+  "WLC": "#f58231",
+  "WIL": "#f58231",
+  "MUN": "#3cb44b",
+  "LRG": "#3cb44b",
+  "GGY": "#e6194b",
+  "WWA": "#e6194b",
+  "WGM": "#4363d8",
+  "NAB": "#3cb44b",
+  "CHV": "#3cb44b",
+  "NAM": "#3cb44b",
+  "MNL": "#3cb44b",
+  "BAL": "#4363d8",
+  "MUL": "#e6194b",
+  "GLN": "#e6194b",
+  "BEG": "#4363d8",
+  "ULD": "#4363d8",
+  "WNT": "#4363d8",
+  "BIG": "#e6194b",
+  "GAH": "#e6194b",
+  "MOU": "#4363d8",
+  "BHQ": "#f58231",
+  "WDL": "#e6194b",
+  "GRF": "#4363d8",
+  "TOC": "#e6194b",
+  "CWA": "#3cb44b",
+  "HBK": "#4363d8",
+  "GRI": "#4363d8",
+  "LCG": "#4363d8",
+  "MUR": "#4363d8",
+  "TRK": "#3cb44b",
+  "GFL": "#f58231",
+  "PKH": "#f58231",
+  "TUM": "#f58231",
+  "YUR": "#e6194b",
+  "GDA": "#4363d8",
+  "KMA": "#3cb44b",
+  "KOG": "#4363d8",
+  "CAR": "#f58231",
+  "CBI": "#f58231",
+  "FPP": "#4363d8",
+  "MDI": "#f58231",
+  "BWT": "#f58231",
+  "CKI": "#4363d8",
+  "YET": "#4363d8",
+  "URB": "#3cb44b",
+  "BGI": "#3cb44b",
+  "BGA": "#e6194b",
+  "BOG": "#f58231",
+  "TSP": "#e6194b",
+  "BRI": "#e6194b",
+  "BMB": "#e6194b",
+  "TWC": "#3cb44b",
+  "PAC": "#3cb44b",
+  "TIB": "#4363d8",
+  "STN": "#3cb44b",
+  "BSH": "#e6194b",
+  "URG": "#e6194b",
+  "RWK": "#4363d8",
+  "SWN": "#4363d8",
+  "LTN": "#3cb44b",
+  "PTM": "#e6194b",
+  "KHN": "#e6194b",
+  "COR": "#4363d8",
+  "QBN": "#e6194b",
+  "WVW": "#e6194b",
+  "NSY": "#e6194b",
+  "GLD": "#e6194b",
+  "ABD": "#3cb44b",
+  "TOM": "#4363d8",
+  "HAR": "#4363d8",
+  "EDN": "#e6194b",
+  "TWH": "#e6194b",
+  "DPT": "#3cb44b",
+  "SGB": "#3cb44b",
+  "YAM": "#3cb44b",
+  "MOA": "#3cb44b",
+  "ABX": "#e6194b",
+  "SWE": "#3cb44b",
+  "HHL": "#e6194b",
+  "MOS": "#3cb44b",
+  "MAN": "#3cb44b",
+  "LHI": "#e6194b",
+  "SCN": "#e6194b",
+  "BTH": "#4363d8",
+  "CRK": "#3cb44b",
+  "CBY": "#3cb44b",
+  "DNG": "#4363d8",
+  "HVL": "#f58231",
+  "SUD": "#3cb44b",
+  "WPW": "#4363d8",
+  "RYL": "#4363d8",
+  "MBK": "#4363d8",
+  "RYD": "#4363d8",
+  "WOL": "#e6194b",
+  "WCB": "#f58231",
+  "CAN": "#3cb44b",
+  "STR": "#e6194b",
+  "OBR": "#f58231",
+  "WYG": "#e6194b",
+  "SOF": "#f58231",
+  "COO": "#3cb44b",
+  "LMQ": "#e6194b",
+  "MAI": "#e6194b",
+  "NTL": "#f58231",
+  "DEN": "#e6194b",
+  "KRG": "#3cb44b",
+  "FFD": "#f58231",
+  "HAW": "#f58231",
+  "PEN": "#3cb44b",
+  "BTN": "#e6194b",
+  "BKK": "#4363d8",
+  "LVP": "#e6194b",
+  "AUB": "#3cb44b",
+  "HOL": "#4363d8",
+  "BLU": "#e6194b",
+  "GOS": "#3cb44b",
+  "LGW": "#3cb44b",
+  "PRT": "#e6194b",
+  "CES": "#4363d8",
+  "SIN": "#3cb44b",
+  "HBY": "#e6194b",
+  "HLS": "#4363d8",
+  "WDY": "#4363d8",
+  "PAR": "#f58231",
+  "CAM": "#3cb44b",
+  "CTN": "#f58231",
+  "MDT": "#4363d8"
+};
diff --git a/src/pages/tasking/viewmodels/Map.js b/src/pages/tasking/viewmodels/Map.js
index 2f7f042a..ef64441c 100644
--- a/src/pages/tasking/viewmodels/Map.js
+++ b/src/pages/tasking/viewmodels/Map.js
@@ -18,7 +18,7 @@ export function MapVM(Lmap, root) {
   self.crowFliesLine = null;
 
   // layers
-  self.assetLayer = L.layerGroup().addTo(Lmap);
+  self.assetLayer = L.layerGroup();             // not added by default – layers drawer handles visibility
   self.jobMarkerGroups = new Map();
   self.unmatchedAssetLayer = L.layerGroup();   // not added by default
 
diff --git a/src/pages/tasking/viewmodels/TrackableAssetsModalVM.js b/src/pages/tasking/viewmodels/TrackableAssetsModalVM.js
index caccc00f..b6a795c3 100644
--- a/src/pages/tasking/viewmodels/TrackableAssetsModalVM.js
+++ b/src/pages/tasking/viewmodels/TrackableAssetsModalVM.js
@@ -19,7 +19,8 @@ export function TrackableAssetsModalVM(mainVM) {
         if (!self.isOpen) return [];
         const query = self.searchQuery().toLowerCase();
         const tg = self.selectedTalkgroup();
-        return mainVM.trackableAssets().filter(a => {
+        return mainVM.trackableAssets()
+            .filter(a => {
             const name = a.name && a.name().toLowerCase();
             const radioId = a.radioId && String(a.radioId()).toLowerCase();
             const talkgroup = a.talkgroup && a.talkgroup();
@@ -27,6 +28,14 @@ export function TrackableAssetsModalVM(mainVM) {
             const matchesQuery = !query || (name && name.includes(query)) || (radioId && radioId.includes(query)) || (entity && entity.includes(query));
             const matchesTG = !tg || talkgroup === tg;
             return matchesQuery && matchesTG;
-        });
+            })
+            .sort((a, b) => {
+            const nameA = a.name && a.name().toLowerCase();
+            const nameB = b.name && b.name().toLowerCase();
+            if (!nameA && !nameB) return 0;
+            if (!nameA) return 1;
+            if (!nameB) return -1;
+            return nameA.localeCompare(nameB);
+            });
     });
 }
\ No newline at end of file
diff --git a/static/manifest.json b/static/manifest.json
index 27ab1453..39a05801 100644
--- a/static/manifest.json
+++ b/static/manifest.json
@@ -40,7 +40,10 @@
     "https://app.ses-mams-uat.net/*",
     "https://api.ses-mams.net/*",
     "https://s3.ap-southeast-2.amazonaws.com/csv-download.ses-mams.net/*",
-    "https://api.adsb.lol/v2/*"
+    "https://api.adsb.lol/v2/*",
+    "https://nula.waternsw.com.au/*",
+    "https://services1.arcgis.com/*",
+    "https://api.rainviewer.com/*"
   ],
   "permissions": [
     "storage",
diff --git a/webpack.common.js b/webpack.common.js
index 2e5564cb..fb872161 100644
--- a/webpack.common.js
+++ b/webpack.common.js
@@ -1,5 +1,6 @@
 const path = require('path');
 const glob = require('glob');
+const webpack = require('webpack');
 
 const DotenvPlugin = require('dotenv-webpack');
 const ESLintPlugin = require('eslint-webpack-plugin');
@@ -81,6 +82,13 @@ module.exports = {
     clean: true,
   },
   plugins: [
+    // leaflet-geosearch optionally depends on @googlemaps/js-api-loader which
+    // dynamically injects <script> tags — forbidden under Chrome Extension MV3 CSP.
+    // Replace it with an empty module so webpack never bundles it.
+    new webpack.NormalModuleReplacementPlugin(
+      /@googlemaps\/js-api-loader/,
+      path.resolve(__dirname, 'src/lib/noop.js')
+    ),
     new DotenvPlugin(),
     new ESLintPlugin({
       extensions: ['js', 'ts'],