refactor: migrate Js.Dict to Dict in src/app/devices/ (16 files)

Replace deprecated Js.Dict API with modern Dict equivalents:
- Js.Dict.empty() -> Dict.make()
- Js.Dict.get/set -> Dict.get/set
- Js.Dict.entries -> Dict.toArray
- Js.Dict.keys -> Dict.keysToArray
- Js.Dict.t<X> -> dict<X>

Part of #28.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: hyperpolymath

src/app/devices/CameraDevice.res

@@ -55,10 +55,10 @@ type cameraState = {
 }
 
 // Global camera states keyed by IP address
-let cameraStates: Js.Dict.t<cameraState> = Js.Dict.empty()
+let cameraStates: dict<cameraState> = Dict.make()
 
 let getCameraState = (ipAddress: string): cameraState => {
-  switch Js.Dict.get(cameraStates, ipAddress) {
+  switch Dict.get(cameraStates, ipAddress) {
   | Some(state) => state
   | None =>
     let state = {
@@ -68,7 +68,7 @@ let getCameraState = (ipAddress: string): cameraState => {
       loopedMotionState: false,
       loopedHackerPosition: None,
     }
-    Js.Dict.set(cameraStates, ipAddress, state)
+    Dict.set(cameraStates, ipAddress, state)
     state
   }
 }

src/app/devices/CameraFeed.res

@@ -23,10 +23,10 @@ let getFeedData = (): option<cameraFeedData> => {
 // Motion detection callbacks - keyed by camera IP address
 // WorldScreen registers callbacks to update camera sprite indicators
 // Callback receives: None = disabled/grey, Some(false) = no motion/blue, Some(true) = motion/orange
-let motionCallbacks: Js.Dict.t<option<bool> => unit> = Js.Dict.empty()
+let motionCallbacks: dict<option<bool> => unit> = Dict.make()
 
 let registerMotionCallback = (cameraIp: string, callback: option<bool> => unit): unit => {
-  Js.Dict.set(motionCallbacks, cameraIp, callback)
+  Dict.set(motionCallbacks, cameraIp, callback)
 }
 
 let unregisterMotionCallback = (cameraIp: string): unit => {
@@ -35,15 +35,15 @@ let unregisterMotionCallback = (cameraIp: string): unit => {
 
 // Motion status: None = disabled/grey, Some(false) = no motion/blue, Some(true) = motion/orange
 let notifyMotionStatus = (cameraIp: string, motionDetected: bool): unit => {
-  switch Js.Dict.get(motionCallbacks, cameraIp) {
+  switch Dict.get(motionCallbacks, cameraIp) {
   | Some(callback) => callback(Some(motionDetected))
   | None => ()
   }
 }
 
 // Notify camera is disabled (grey indicator)
 let notifyCameraDisabled = (cameraIp: string): unit => {
-  switch Js.Dict.get(motionCallbacks, cameraIp) {
+  switch Dict.get(motionCallbacks, cameraIp) {
   | Some(callback) => callback(None)
   | None => ()
   }
@@ -81,17 +81,17 @@ let getHackerRelativePosition = (cameraX: float, viewWidth: float): option<float
 
 // Camera positions in world - used for background motion checking
 // Maps IP address to (worldX, viewWidth)
-let cameraPositions: Js.Dict.t<(float, float)> = Js.Dict.empty()
+let cameraPositions: dict<(float, float)> = Dict.make()
 
 // Track which cameras are disabled (to skip in background motion check)
 let disabledCameras: Set.t<string> = Set.make()
 
 // Track which cameras are looping and their frozen motion state
 // Maps IP to frozen motion state (true = motion detected, false = no motion)
-let loopingCameras: Js.Dict.t<bool> = Js.Dict.empty()
+let loopingCameras: dict<bool> = Dict.make()
 
 let registerCameraPosition = (cameraIp: string, worldX: float, viewWidth: float): unit => {
-  Js.Dict.set(cameraPositions, cameraIp, (worldX, viewWidth))
+  Dict.set(cameraPositions, cameraIp, (worldX, viewWidth))
 }
 
 let setCameraEnabled = (cameraIp: string, enabled: bool): unit => {
@@ -104,7 +104,7 @@ let setCameraEnabled = (cameraIp: string, enabled: bool): unit => {
 
 let setCameraLooping = (cameraIp: string, looping: bool, frozenMotionState: bool): unit => {
   if looping {
-    Js.Dict.set(loopingCameras, cameraIp, frozenMotionState)
+    Dict.set(loopingCameras, cameraIp, frozenMotionState)
   } else {
     Dict.delete(loopingCameras, cameraIp)
   }
@@ -113,7 +113,7 @@ let setCameraLooping = (cameraIp: string, looping: bool, frozenMotionState: bool
 // Update all camera motion statuses based on hacker position
 // Called from WorldScreen update loop
 let updateAllCameraMotion = (): unit => {
-  Js.Dict.entries(cameraPositions)->Belt.Array.forEach(((ip, position)) => {
+  Dict.toArray(cameraPositions)->Belt.Array.forEach(((ip, position)) => {
     let (worldX, viewWidth) = position
 
     // Skip disabled cameras
@@ -124,16 +124,16 @@ let updateAllCameraMotion = (): unit => {
       let hasPower = PowerManager.isDeviceOperational(ip)
       if !hasPower {
         // No power - show grey indicator
-        switch Js.Dict.get(motionCallbacks, ip) {
+        switch Dict.get(motionCallbacks, ip) {
         | Some(callback) => callback(None)
         | None => ()
         }
       } else {
         // Check if this camera has a motion callback registered
-        switch Js.Dict.get(motionCallbacks, ip) {
+        switch Dict.get(motionCallbacks, ip) {
         | Some(callback) =>
           // Check if camera is looping - use frozen state instead of live detection
-          switch Js.Dict.get(loopingCameras, ip) {
+          switch Dict.get(loopingCameras, ip) {
           | Some(frozenMotion) =>
             // Camera is looping - show the frozen motion state
             callback(Some(frozenMotion))

src/app/devices/CoprocessorBridge.res

@@ -52,16 +52,16 @@ open Coprocessor
 
 // Resolved coprocessor results waiting to be read by RECV, keyed by device ID.
 // Populated asynchronously by Promise.then callbacks after each SEND dispatch.
-let outputBuffers: Js.Dict.t<ref<array<string>>> = Js.Dict.empty()
+let outputBuffers: dict<ref<array<string>>> = Dict.make()
 
 // Retrieve or lazily create the result buffer for a device.
 // All SEND and RECV calls for a device share the same buffer reference.
 let getBuffer = (deviceId: string): ref<array<string>> => {
-  switch Js.Dict.get(outputBuffers, deviceId) {
+  switch Dict.get(outputBuffers, deviceId) {
   | Some(b) => b
   | None =>
     let b = ref([])
-    Js.Dict.set(outputBuffers, deviceId, b)
+    Dict.set(outputBuffers, deviceId, b)
     b
   }
 }

src/app/devices/CovertLink.res

@@ -281,41 +281,41 @@ let formatShort = (conn: t): string => {
 
 module Registry = {
   // All connections in the current level
-  let connections: Js.Dict.t<t> = Js.Dict.empty()
+  let connections: dict<t> = Dict.make()
 
   // Register a connection
   let add = (conn: t): unit => {
-    Js.Dict.set(connections, conn.id, conn)
+    Dict.set(connections, conn.id, conn)
   }
 
   // Get a connection by ID
   let get = (id: string): option<t> => {
-    Js.Dict.get(connections, id)
+    Dict.get(connections, id)
   }
 
   // Get all connections
   let getAll = (): array<t> => {
-    Js.Dict.values(connections)
+    Dict.valuesToArray(connections)
   }
 
   // Get connections by state
   let getByState = (state: connectionState): array<t> => {
-    Js.Dict.values(connections)->Belt.Array.keep(c => c.state == state)
+    Dict.valuesToArray(connections)->Belt.Array.keep(c => c.state == state)
   }
 
   // Get active connections for a specific IP
   let getActiveForIp = (ip: string): array<t> => {
-    Js.Dict.values(connections)->Belt.Array.keep(c => c.state == Active && hasEndpoint(c, ip))
+    Dict.valuesToArray(connections)->Belt.Array.keep(c => c.state == Active && hasEndpoint(c, ip))
   }
 
   // Get all discovered-or-active connections (for overlay map)
   let getVisible = (): array<t> => {
-    Js.Dict.values(connections)->Belt.Array.keep(c => c.state == Discovered || c.state == Active)
+    Dict.valuesToArray(connections)->Belt.Array.keep(c => c.state == Discovered || c.state == Active)
   }
 
   // Find an active covert route between two IPs
   let findRoute = (sourceIp: string, destIp: string): option<t> => {
-    Belt.Array.getBy(Js.Dict.values(connections), c =>
+    Belt.Array.getBy(Dict.valuesToArray(connections), c =>
       c.state == Active && connects(c, sourceIp, destIp)
     )
   }
@@ -327,14 +327,14 @@ module Registry = {
 
   // Update all connections (call each frame)
   let updateAll = (deltaSeconds: float): unit => {
-    Js.Dict.values(connections)->Belt.Array.forEach(conn => {
+    Dict.valuesToArray(connections)->Belt.Array.forEach(conn => {
       update(conn, deltaSeconds)
     })
   }
 
   // Reset all connections (new level)
   let clear = (): unit => {
-    Js.Dict.keys(connections)->Belt.Array.forEach(key => {
+    Dict.keysToArray(connections)->Belt.Array.forEach(key => {
       Dict.delete(connections, key)
     })
   }

src/app/devices/DeviceActivity.res

@@ -4,15 +4,15 @@
 
 let getCurrentTime: unit => float = %raw(`function() { return Date.now(); }`)
 
-let lastActivity: Js.Dict.t<float> = Js.Dict.empty()
+let lastActivity: dict<float> = Dict.make()
 let activityTimeoutMs = 30000.0 // 30 seconds
 
 let recordActivity = (ip: string): unit => {
-  Js.Dict.set(lastActivity, ip, getCurrentTime())
+  Dict.set(lastActivity, ip, getCurrentTime())
 }
 
 let isActive = (ip: string): bool => {
-  switch Js.Dict.get(lastActivity, ip) {
+  switch Dict.get(lastActivity, ip) {
   | Some(time) => getCurrentTime() -. time < activityTimeoutMs
   | None => false
   }

src/app/devices/DeviceRegistry.res

@@ -24,30 +24,30 @@
 //   - All mutation is single-threaded (no concurrent write hazard in Deno).
 
 // The singleton backing store: ipAddress -> device
-let registry: dict<DeviceTypes.device> = Js.Dict.empty()
+let registry: dict<DeviceTypes.device> = Dict.make()
 
 // Defence flags backing store: ipAddress -> defenceFlags (ADR-0013).
 // Populated by NetworkManager.applyLevelDefences; cleared on level unload.
-let defenceRegistry: dict<DeviceType.defenceFlags> = Js.Dict.empty()
+let defenceRegistry: dict<DeviceType.defenceFlags> = Dict.make()
 
 // Register a device under its IP address.
 // If a device is already registered at this IP it will be overwritten —
 // this is intentional for hot-reload during development.
 let register = (ipAddress: string, device: DeviceTypes.device): unit => {
-  Js.Dict.set(registry, ipAddress, device)
+  Dict.set(registry, ipAddress, device)
 }
 
 // Look up a device by IP address. Returns None if not registered.
 let lookup = (ipAddress: string): option<DeviceTypes.device> => {
-  Js.Dict.get(registry, ipAddress)
+  Dict.get(registry, ipAddress)
 }
 
 // Look up a device and call f with it. Returns None if not registered.
 let withDevice = (
   ipAddress: string,
   f: DeviceTypes.device => 'a,
 ): option<'a> => {
-  switch Js.Dict.get(registry, ipAddress) {
+  switch Dict.get(registry, ipAddress) {
   | Some(device) => Some(f(device))
   | None => None
   }
@@ -64,17 +64,17 @@ let unregister = (ipAddress: string): unit => {
 
 // Return all registered IP addresses.
 let allIps = (): array<string> => {
-  Js.Dict.keys(registry)
+  Dict.keysToArray(registry)
 }
 
 // Return all registered devices as (ipAddress, device) pairs.
 let allEntries = (): array<(string, DeviceTypes.device)> => {
-  Js.Dict.entries(registry)
+  Dict.toArray(registry)
 }
 
 // Return all devices whose deviceType matches the given type.
 let byType = (targetType: DeviceTypes.deviceType): array<DeviceTypes.device> => {
-  Js.Dict.values(registry)->Belt.Array.keep(device => {
+  Dict.valuesToArray(registry)->Belt.Array.keep(device => {
     let info = device.getInfo()
     info.deviceType == targetType
   })
@@ -93,15 +93,15 @@ let byMinSecurityLevel = (
     | DeviceType.Medium => 2
     | DeviceType.Strong => 3
     }
-  Js.Dict.values(registry)->Belt.Array.keep(device => {
+  Dict.valuesToArray(registry)->Belt.Array.keep(device => {
     let info = device.getInfo()
     rank((info.securityLevel :> DeviceType.securityLevel)) >= rank(minLevel)
   })
 }
 
 // Return the number of currently registered devices.
 let count = (): int => {
-  Js.Dict.keys(registry)->Belt.Array.length
+  Dict.keysToArray(registry)->Belt.Array.length
 }
 
 // --- Defence flags (ADR-0013) ---
@@ -115,24 +115,24 @@ let count = (): int => {
 // Overwrites any previously stored flags for the same IP (safe — missions
 // always reset flags before the level starts).
 let setDefenceFlags = (ipAddress: string, flags: DeviceType.defenceFlags): unit => {
-  Js.Dict.set(defenceRegistry, ipAddress, flags)
+  Dict.set(defenceRegistry, ipAddress, flags)
 }
 
 // Read defence flags for a device.
 // Returns DeviceType.defaultDefenceFlags (all inactive) if no override
 // has been registered for this IP — i.e. the device has stock behaviour.
 let getDefenceFlags = (ipAddress: string): DeviceType.defenceFlags => {
-  Js.Dict.get(defenceRegistry, ipAddress)->Belt.Option.getWithDefault(DeviceType.defaultDefenceFlags)
+  Dict.get(defenceRegistry, ipAddress)->Belt.Option.getWithDefault(DeviceType.defaultDefenceFlags)
 }
 
 // Remove all registered devices and defence flag overrides.
 // Called on level unload / game reset to prevent stale state leaking
 // between missions.
 let clear = (): unit => {
   // Delete all device entries
-  let deviceKeys = Js.Dict.keys(registry)
+  let deviceKeys = Dict.keysToArray(registry)
   Belt.Array.forEach(deviceKeys, k => Dict.delete(registry, k))
   // Delete all defence flag overrides
-  let defenceKeys = Js.Dict.keys(defenceRegistry)
+  let defenceKeys = Dict.keysToArray(defenceRegistry)
   Belt.Array.forEach(defenceKeys, k => Dict.delete(defenceRegistry, k))
 }