refactor: migrate Js.Dict to Dict in remaining src/ dirs (14 files)

Replace deprecated Js.Dict in enemies/, screens/, multiplayer/,
popups/, player/, proven/, ui/, and utils/.

Part of #28.

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

Author: hyperpolymath

src/app/enemies/Distraction.res

@@ -165,7 +165,7 @@ let makeActive = (~id: string, ~spec: distractionSpec): activeDistraction => {
 
 type pbxState = {
   mutable hacked: bool, // Must hack the physical PBX first
-  mutable usesRemaining: Js.Dict.t<int>,
+  mutable usesRemaining: dict<int>,
   mutable cooldownSec: float, // Time until next call allowed
   mutable activeDistractions: array<activeDistraction>,
   mutable totalCalls: int,
@@ -181,12 +181,12 @@ type pbxState = {
 let cooldownBetweenCalls = 60.0 // Seconds between PBX calls
 
 let make = (~ipAddress: string): pbxState => {
-  let uses = Js.Dict.empty()
-  Js.Dict.set(uses, "pizza", 2)
-  Js.Dict.set(uses, "maintenance", 1)
-  Js.Dict.set(uses, "fire", 1)
-  Js.Dict.set(uses, "prank", 2)
-  Js.Dict.set(uses, "police", 1)
+  let uses = Dict.make()
+  Dict.set(uses, "pizza", 2)
+  Dict.set(uses, "maintenance", 1)
+  Dict.set(uses, "fire", 1)
+  Dict.set(uses, "prank", 2)
+  Dict.set(uses, "police", 1)
 
   {
     hacked: false,
@@ -220,7 +220,7 @@ let call = (pbx: pbxState, ~kind: distractionKind): callResult => {
     OnCooldown(pbx.cooldownSec)
   } else {
     let key = kindToString(kind)
-    let remaining = Js.Dict.get(pbx.usesRemaining, key)->Belt.Option.getWithDefault(0)
+    let remaining = Dict.get(pbx.usesRemaining, key)->Belt.Option.getWithDefault(0)
     if remaining <= 0 {
       NoUsesLeft
     } else {
@@ -236,7 +236,7 @@ let call = (pbx: pbxState, ~kind: distractionKind): callResult => {
       pbx.nextId = pbx.nextId + 1
       pbx.totalCalls = pbx.totalCalls + 1
       pbx.cooldownSec = cooldownBetweenCalls
-      Js.Dict.set(pbx.usesRemaining, key, remaining - 1)
+      Dict.set(pbx.usesRemaining, key, remaining - 1)
       let _ = Js.Array2.push(pbx.activeDistractions, distraction)
       Success(distraction)
     }
@@ -382,12 +382,12 @@ let applyDifficultyScaling = (pbx: pbxState, ~difficulty: int): unit => {
   // difficulty: 0=Tutorial, 1=Easy, 2=Normal, 3=Hard, 4=Expert
   // Reduce uses on harder difficulties
   if difficulty >= 3 {
-    Js.Dict.set(pbx.usesRemaining, "pizza", 1)
-    Js.Dict.set(pbx.usesRemaining, "prank", 1)
+    Dict.set(pbx.usesRemaining, "pizza", 1)
+    Dict.set(pbx.usesRemaining, "prank", 1)
   }
   if difficulty >= 4 {
-    Js.Dict.set(pbx.usesRemaining, "maintenance", 0)
-    Js.Dict.set(pbx.usesRemaining, "police", 0)
+    Dict.set(pbx.usesRemaining, "maintenance", 0)
+    Dict.set(pbx.usesRemaining, "police", 0)
   }
 }
 
@@ -428,7 +428,7 @@ let formatStatus = (pbx: pbxState): string => {
       ("police", "Fake Police"),
     ]
     ->Belt.Array.map(((key, label)) => {
-      let remaining = Js.Dict.get(pbx.usesRemaining, key)->Belt.Option.getWithDefault(0)
+      let remaining = Dict.get(pbx.usesRemaining, key)->Belt.Option.getWithDefault(0)
       `  ${label}: ${Belt.Int.toString(remaining)} remaining`
     })
     ->Array.join("\n")

src/app/multiplayer/MultiplayerClient.res

@@ -59,7 +59,7 @@ type t = {
   mutable playerId: string,
   mutable role: playerRole,
   mutable sessionId: option<string>,
-  coopPlayers: Js.Dict.t<coopPlayer>,
+  coopPlayers: dict<coopPlayer>,
   chatHistory: array<chatMessage>,
   handlers: eventHandlers,
   serverUrl: string,
@@ -84,29 +84,29 @@ let roleFromString = (s: string): playerRole => {
 let jsonString = (s: string): JSON.t => JSON.Encode.string(s)
 
 let makePayload = (pairs: array<(string, JSON.t)>): JSON.t => {
-  let obj = Js.Dict.empty()
-  Belt.Array.forEach(pairs, ((k, v)) => Js.Dict.set(obj, k, v))
+  let obj = Dict.make()
+  Belt.Array.forEach(pairs, ((k, v)) => Dict.set(obj, k, v))
   JSON.Encode.object(obj)
 }
 
 let getJsonString = (json: JSON.t, key: string): string => {
   switch JSON.Decode.object(json) {
-  | Some(obj) => Js.Dict.get(obj, key)->Option.flatMap(x => JSON.Decode.string(x))->Belt.Option.getWithDefault("")
+  | Some(obj) => Dict.get(obj, key)->Option.flatMap(x => JSON.Decode.string(x))->Belt.Option.getWithDefault("")
   | None => ""
   }
 }
 
 let getJsonFloat = (json: JSON.t, key: string): float => {
   switch JSON.Decode.object(json) {
-  | Some(obj) => Js.Dict.get(obj, key)->Option.flatMap(x => JSON.Decode.float(x))->Belt.Option.getWithDefault(0.0)
+  | Some(obj) => Dict.get(obj, key)->Option.flatMap(x => JSON.Decode.float(x))->Belt.Option.getWithDefault(0.0)
   | None => 0.0
   }
 }
 
 let getJsonArray = (json: JSON.t, key: string): array<JSON.t> => {
   switch JSON.Decode.object(json) {
   | Some(obj) =>
-    Js.Dict.get(obj, key)
+    Dict.get(obj, key)
     ->Option.flatMap(x =>
       switch JSON.Classify.classify(x) {
       | JSON.Classify.Array(arr) => Some(arr)
@@ -135,7 +135,7 @@ let make = (
   playerId,
   role,
   sessionId: None,
-  coopPlayers: Js.Dict.empty(),
+  coopPlayers: Dict.make(),
   chatHistory: [],
   handlers: {
     onPlayerJoined: None,
@@ -210,7 +210,7 @@ let setupChannelHandlers = (client: t, ch: PhoenixSocket.channel) => {
       y: 0.0,
       lastSeen: Date.now(),
     }
-    Js.Dict.set(client.coopPlayers, pid, player)
+    Dict.set(client.coopPlayers, pid, player)
     switch client.handlers.onPlayerJoined {
     | Some(cb) => cb(player)
     | None => ()
@@ -232,7 +232,7 @@ let setupChannelHandlers = (client: t, ch: PhoenixSocket.channel) => {
     let pid = getJsonString(payload, "player_id")
     let x = getJsonFloat(payload, "x")
     let y = getJsonFloat(payload, "y")
-    switch Js.Dict.get(client.coopPlayers, pid) {
+    switch Dict.get(client.coopPlayers, pid) {
     | Some(player) => {
         player.x = x
         player.y = y
@@ -274,7 +274,7 @@ let setupChannelHandlers = (client: t, ch: PhoenixSocket.channel) => {
     let pid = getJsonString(payload, "player_id")
     let deviceId = getJsonString(payload, "device_id")
     let state = switch JSON.Decode.object(payload) {
-    | Some(obj) => Js.Dict.get(obj, "state")->Belt.Option.getWithDefault(JSON.Encode.null)
+    | Some(obj) => Dict.get(obj, "state")->Belt.Option.getWithDefault(JSON.Encode.null)
     | None => JSON.Encode.null
     }
     switch client.handlers.onVMState {
@@ -369,7 +369,7 @@ let joinSession = (client: t, ~sessionId: string) => {
         if status == "ok" {
           switch JSON.Decode.object(payload) {
           | Some(obj) =>
-            switch Js.Dict.get(obj, "response") {
+            switch Dict.get(obj, "response") {
             | Some(resp) =>
               switch JSON.Decode.object(resp) {
               | Some(session) => {
@@ -408,7 +408,7 @@ let leaveSession = (client: t) => {
       client.sessionId = None
       client.state = InLobby
       // Clear co-op state
-      let keys = Js.Dict.keys(client.coopPlayers)
+      let keys = Dict.keysToArray(client.coopPlayers)
       Belt.Array.forEach(keys, k => Dict.delete(client.coopPlayers, k))
       notifyState(client)
     }
@@ -586,11 +586,11 @@ let sendAlertChanged = (client: t, ~level: string) => {
 // --- Query state ---
 
 let getCoopPlayers = (client: t): array<coopPlayer> => {
-  Js.Dict.values(client.coopPlayers)
+  Dict.valuesToArray(client.coopPlayers)
 }
 
 let getCoopPartner = (client: t): option<coopPlayer> => {
-  Js.Dict.values(client.coopPlayers)-> Belt.Array.getBy(p => p.id != client.playerId)
+  Dict.valuesToArray(client.coopPlayers)-> Belt.Array.getBy(p => p.id != client.playerId)
 }
 
 let stateToString = (state: multiplayerState): string => {

src/app/multiplayer/PhoenixSocket.res

@@ -56,7 +56,7 @@ type messageHandler = JSON.t => unit
 type channel = {
   topic: string,
   mutable state: channelState,
-  handlers: Js.Dict.t<array<messageHandler>>,
+  handlers: dict<array<messageHandler>>,
   mutable joinRef: option<string>,
 }
 
@@ -70,7 +70,7 @@ type t = {
   mutable socket: option<webSocket>,
   mutable state: connectionState,
   mutable refCounter: int,
-  channels: Js.Dict.t<channel>,
+  channels: dict<channel>,
   mutable heartbeatTimer: option<int>,
   mutable reconnectAttempts: int,
   mutable onStateChange: option<connectionState => unit>,
@@ -132,7 +132,7 @@ let make = (~url: string, ~onStateChange: option<connectionState => unit>=?): t
   socket: None,
   state: Disconnected,
   refCounter: 0,
-  channels: Js.Dict.empty(),
+  channels: Dict.make(),
   heartbeatTimer: None,
   reconnectAttempts: 0,
   onStateChange,
@@ -165,7 +165,7 @@ let startHeartbeat = (socket: t) => {
       {
         topic: "phoenix",
         event: "heartbeat",
-        payload: JSON.Encode.object(Js.Dict.empty()),
+        payload: JSON.Encode.object(Dict.make()),
         ref: Some(nextRef(socket)),
         joinRef: None,
       },
@@ -186,13 +186,13 @@ let stopHeartbeat = (socket: t) => {
 
 // Dispatch an incoming V2 message to the appropriate channel handler.
 let dispatchMessage = (socket: t, msg: phoenixMessage) => {
-  switch Js.Dict.get(socket.channels, msg.topic) {
+  switch Dict.get(socket.channels, msg.topic) {
   | Some(channel) => {
       // Handle join reply — update channel state on successful join ack
       if msg.event == "phx_reply" && channel.state == Joining {
         let statusOk = switch JSON.Decode.object(msg.payload) {
         | Some(obj) =>
-          switch Js.Dict.get(obj, "status") {
+          switch Dict.get(obj, "status") {
           | Some(s) => JSON.Decode.string(s) == Some("ok")
           | None => false
           }
@@ -209,7 +209,7 @@ let dispatchMessage = (socket: t, msg: phoenixMessage) => {
       }
 
       // Dispatch to all registered handlers for this event
-      switch Js.Dict.get(channel.handlers, msg.event) {
+      switch Dict.get(channel.handlers, msg.event) {
       | Some(handlers) => Belt.Array.forEach(handlers, h => h(msg.payload))
       | None => ()
       }
@@ -233,7 +233,7 @@ let rec connect = (socket: t) => {
 
     // Rejoin all channels that were previously joined after reconnect.
     // join_ref == message_ref for join messages (Phoenix convention).
-    Js.Dict.entries(socket.channels)->Belt.Array.forEach(((_topic, channel)) => {
+    Dict.toArray(socket.channels)->Belt.Array.forEach(((_topic, channel)) => {
       if channel.state == Joined || channel.state == Joining {
         channel.state = Joining
         let ref = nextRef(socket)
@@ -243,7 +243,7 @@ let rec connect = (socket: t) => {
           {
             topic: channel.topic,
             event: "phx_join",
-            payload: JSON.Encode.object(Js.Dict.empty()),
+            payload: JSON.Encode.object(Dict.make()),
             ref: Some(ref),
             joinRef: Some(ref),
           },
@@ -300,15 +300,15 @@ let channel = (socket: t, ~topic: string): channel => {
   let ch: channel = {
     topic,
     state: Closed,
-    handlers: Js.Dict.empty(),
+    handlers: Dict.make(),
     joinRef: None,
   }
-  Js.Dict.set(socket.channels, topic, ch)
+  Dict.set(socket.channels, topic, ch)
   ch
 }
 
 // Join a channel. For join messages, join_ref == message_ref (Phoenix V2 spec).
-let joinChannel = (socket: t, ch: channel, ~payload: JSON.t=JSON.Encode.object(Js.Dict.empty())) => {
+let joinChannel = (socket: t, ch: channel, ~payload: JSON.t=JSON.Encode.object(Dict.make())) => {
   ch.state = Joining
   let ref = nextRef(socket)
   ch.joinRef = Some(ref)
@@ -331,7 +331,7 @@ let leaveChannel = (socket: t, ch: channel) => {
     {
       topic: ch.topic,
       event: "phx_leave",
-      payload: JSON.Encode.object(Js.Dict.empty()),
+      payload: JSON.Encode.object(Dict.make()),
       ref: Some(nextRef(socket)),
       joinRef: ch.joinRef,
     },
@@ -341,8 +341,8 @@ let leaveChannel = (socket: t, ch: channel) => {
 }
 
 let on = (ch: channel, ~event: string, ~handler: messageHandler) => {
-  let existing = Js.Dict.get(ch.handlers, event)->Belt.Option.getWithDefault([])
-  Js.Dict.set(ch.handlers, event, Belt.Array.concat(existing, [handler]))
+  let existing = Dict.get(ch.handlers, event)->Belt.Option.getWithDefault([])
+  Dict.set(ch.handlers, event, Belt.Array.concat(existing, [handler]))
 }
 
 // Push an event to the server. join_ref carries the channel's original join ref

src/app/multiplayer/VMMessageBus.res

@@ -50,15 +50,15 @@ type portMessage = {
 
 // Module-level singleton port output buffer.
 // Keyed by port name (e.g. "console", "coop:sync", "covert:conn-1").
-let portOutputBuffer: dict<array<int>> = Js.Dict.empty()
+let portOutputBuffer: dict<array<int>> = Dict.make()
 
 // Append values to a port's output buffer.
 // Called by game code (terminal handlers, network events, covert-link
 // activation) when it wants the message bus to route data on the next
 // call to readPortOutput / flushPortMessages.
 let writePortOutput = (port: string, values: array<int>): unit => {
-  let existing = Js.Dict.get(portOutputBuffer, port)->Belt.Option.getWithDefault([])
-  Js.Dict.set(portOutputBuffer, port, Belt.Array.concat(existing, values))
+  let existing = Dict.get(portOutputBuffer, port)->Belt.Option.getWithDefault([])
+  Dict.set(portOutputBuffer, port, Belt.Array.concat(existing, values))
 }
 
 // Read and drain all pending output from the named port.
@@ -71,12 +71,12 @@ let writePortOutput = (port: string, values: array<int>): unit => {
 // to [] so each value is delivered exactly once.
 let readPortOutput = (vmState: VMBridge.vmState, port: string): array<int> => {
   let _ = vmState // Reserved for Tier 4 SEND/RECV integration
-  switch Js.Dict.get(portOutputBuffer, port) {
+  switch Dict.get(portOutputBuffer, port) {
   | None => []
   | Some(values) =>
     // Drain: replace the port's slice with an empty array before returning
     // so concurrent callers (if any) get distinct snapshots.
-    Js.Dict.set(portOutputBuffer, port, [])
+    Dict.set(portOutputBuffer, port, [])
     values
   }
 }
@@ -141,8 +141,8 @@ let flushCoopOutbox = (): unit => {
       MultiplayerClient.sendVMExecute(client, ~instruction, ~deviceId, ~args)
     | VMUndone({deviceId}) => MultiplayerClient.sendVMUndo(client, ~deviceId)
     | StateSync({deviceId, registers}) => {
-        let obj = Js.Dict.empty()
-        Belt.Array.forEach(registers, ((k, v)) => Js.Dict.set(obj, k, JSON.Encode.float(Int.toFloat(v))))
+        let obj = Dict.make()
+        Belt.Array.forEach(registers, ((k, v)) => Dict.set(obj, k, JSON.Encode.float(Int.toFloat(v))))
         MultiplayerClient.sendVMState(client, ~deviceId, ~state=JSON.Encode.object(obj))
       }
     | PortData(_) => () // Port data goes through VM state sync