refactor: migrate Js.Dict to Dict in src/shared/ (6 files)

Replace deprecated Js.Dict API with modern Dict equivalents in
Coprocessor, Coprocessor_IO, DLCLoader, Kernel_Crypto, Kernel_Quantum,
and ResourceAccounting.

Part of #28.

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

Author: hyperpolymath

src/shared/Coprocessor.res

@@ -64,19 +64,19 @@ type backend = {
 
 // --- Global Registry ---
 
-let backends: Js.Dict.t<backend> = Js.Dict.empty()
+let backends: dict<backend> = Dict.make()
 
 let register = (b: backend): unit => {
-  Js.Dict.set(backends, b.id, b)
+  Dict.set(backends, b.id, b)
   Js.Console.log(`Coprocessor: Registered backend "${b.id}" for domain ${Domain.toString(b.domain)}`)
 }
 
 let get = (id: string): option<backend> => {
-  Js.Dict.get(backends, id)
+  Dict.get(backends, id)
 }
 
 let listByDomain = (d: Domain.t): array<backend> => {
-  Js.Dict.values(backends)->Belt.Array.keep(b => b.domain == d)
+  Dict.valuesToArray(backends)->Belt.Array.keep(b => b.domain == d)
 }
 
 // --- Power Integration ---

src/shared/Coprocessor_IO.res

@@ -58,20 +58,20 @@ open Coprocessor
 
 // Two-level dict: deviceId → (filePath → content).
 // Lazily populated on first access per device.
-let filesystems: Js.Dict.t<Js.Dict.t<array<int>>> = Js.Dict.empty()
+let filesystems: dict<dict<array<int>>> = Dict.make()
 
 // Tombstone set for deleted paths.
 // Key format: deviceId ++ "\x00" ++ filePath.
 // Value true = deleted; false (or absent) = live.
-let deletedPaths: Js.Dict.t<bool> = Js.Dict.empty()
+let deletedPaths: dict<bool> = Dict.make()
 
 // Retrieve (or lazily create) the file dict for a device.
-let getFs = (deviceId: string): Js.Dict.t<array<int>> =>
-  switch Js.Dict.get(filesystems, deviceId) {
+let getFs = (deviceId: string): dict<array<int>> =>
+  switch Dict.get(filesystems, deviceId) {
   | Some(fs) => fs
   | None =>
-    let fs = Js.Dict.empty()
-    Js.Dict.set(filesystems, deviceId, fs)
+    let fs = Dict.make()
+    Dict.set(filesystems, deviceId, fs)
     fs
   }
 
@@ -81,18 +81,18 @@ let tombKey = (deviceId: string, path: string): string =>
 
 // Return true if a path has been tombstoned on this device.
 let isTombstoned = (deviceId: string, path: string): bool =>
-  switch Js.Dict.get(deletedPaths, tombKey(deviceId, path)) {
+  switch Dict.get(deletedPaths, tombKey(deviceId, path)) {
   | Some(true) => true
   | _          => false
   }
 
 // Mark a path as deleted.
 let tombstone = (deviceId: string, path: string): unit =>
-  Js.Dict.set(deletedPaths, tombKey(deviceId, path), true)
+  Dict.set(deletedPaths, tombKey(deviceId, path), true)
 
 // Clear a tombstone so a subsequent write is visible again.
 let clearTombstone = (deviceId: string, path: string): unit =>
-  Js.Dict.set(deletedPaths, tombKey(deviceId, path), false)
+  Dict.set(deletedPaths, tombKey(deviceId, path), false)
 
 // ---------------------------------------------------------------------------
 // Data encoding helpers
@@ -165,7 +165,7 @@ let cmdWrite = (deviceId: string, data: array<int>): executionResult => {
   } else {
     let fs         = getFs(deviceId)
     let contentLen = Belt.Array.length(content)
-    Js.Dict.set(fs, path, content)
+    Dict.set(fs, path, content)
     clearTombstone(deviceId, path)
     {
       status:  0,
@@ -193,7 +193,7 @@ let cmdRead = (deviceId: string, data: array<int>): executionResult => {
      message: Some(`IO: read "${path}" not found (deleted)`)}
   } else {
     let fs = getFs(deviceId)
-    switch Js.Dict.get(fs, path) {
+    switch Dict.get(fs, path) {
     | None =>
       {status: 404, data: [], metrics: emptyMetrics,
        message: Some(`IO: read "${path}" not found`)}
@@ -221,7 +221,7 @@ let cmdList = (deviceId: string, data: array<int>): executionResult => {
   let prefix = decodePath(data)
   let fs     = getFs(deviceId)
   let paths  =
-    Js.Dict.keys(fs)
+    Dict.keysToArray(fs)
     ->Belt.Array.keep(p =>
       !isTombstoned(deviceId, p) &&
       (Js.String2.length(prefix) == 0 || Js.String2.startsWith(p, prefix))
@@ -254,7 +254,7 @@ let cmdDelete = (deviceId: string, data: array<int>): executionResult => {
   } else {
     let fs = getFs(deviceId)
     let live =
-      switch Js.Dict.get(fs, path) {
+      switch Dict.get(fs, path) {
       | Some(_) => !isTombstoned(deviceId, path)
       | None    => false
       }
@@ -287,7 +287,7 @@ let cmdStat = (deviceId: string, data: array<int>): executionResult => {
         0
       } else {
         let fs = getFs(deviceId)
-        switch Js.Dict.get(fs, path) {
+        switch Dict.get(fs, path) {
         | None          => 0
         | Some(content) => Belt.Array.length(content)
         }

src/shared/DLCLoader.res

@@ -98,9 +98,9 @@ let inferTierFromInstructions = (instrs: array<string>): PuzzleFormat.tier => {
 let extractRegisters = (stateJson: Js.Json.t): array<(string, int)> => {
   switch Js.Json.classify(stateJson) {
   | JSONObject(dict) =>
-    let keys = Js.Dict.keys(dict)
+    let keys = Dict.keysToArray(dict)
     Belt.Array.keepMap(keys, key => {
-      switch Js.Dict.get(dict, key) {
+      switch Dict.get(dict, key) {
       | Some(v) =>
         switch Js.Json.classify(v) {
         | JSONNumber(n) => Some((key, Belt.Float.toInt(n)))
@@ -123,22 +123,22 @@ let parseHints = (json: Js.Json.t): array<PuzzleFormat.hint> => {
       | JSONString(s) => Some({PuzzleFormat.moveThreshold: 3, text: s})
       // Old format: {moveNumber, text} objects
       | JSONObject(dict) => {
-          let text = switch Js.Dict.get(dict, "text") {
+          let text = switch Dict.get(dict, "text") {
           | Some(v) =>
             switch Js.Json.classify(v) {
             | JSONString(s) => s
             | _ => ""
             }
           | None => ""
           }
-          let threshold = switch Js.Dict.get(dict, "moveNumber") {
+          let threshold = switch Dict.get(dict, "moveNumber") {
           | Some(v) =>
             switch Js.Json.classify(v) {
             | JSONNumber(n) => Belt.Float.toInt(n)
             | _ => 3
             }
           | None =>
-            switch Js.Dict.get(dict, "moveThreshold") {
+            switch Dict.get(dict, "moveThreshold") {
             | Some(v) =>
               switch Js.Json.classify(v) {
               | JSONNumber(n) => Belt.Float.toInt(n)
@@ -161,8 +161,8 @@ let parseHints = (json: Js.Json.t): array<PuzzleFormat.hint> => {
 }
 
 // Get a string field from a JSON object
-let getString = (dict: Js.Dict.t<Js.Json.t>, key: string, default: string): string => {
-  switch Js.Dict.get(dict, key) {
+let getString = (dict: dict<Js.Json.t>, key: string, default: string): string => {
+  switch Dict.get(dict, key) {
   | Some(v) =>
     switch Js.Json.classify(v) {
     | JSONString(s) => s
@@ -173,8 +173,8 @@ let getString = (dict: Js.Dict.t<Js.Json.t>, key: string, default: string): stri
 }
 
 // Get an int field from a JSON object
-let getInt = (dict: Js.Dict.t<Js.Json.t>, key: string, default: int): int => {
-  switch Js.Dict.get(dict, key) {
+let getInt = (dict: dict<Js.Json.t>, key: string, default: int): int => {
+  switch Dict.get(dict, key) {
   | Some(v) =>
     switch Js.Json.classify(v) {
     | JSONNumber(n) => Belt.Float.toInt(n)
@@ -185,8 +185,8 @@ let getInt = (dict: Js.Dict.t<Js.Json.t>, key: string, default: int): int => {
 }
 
 // Get a string array from a JSON object
-let getStringArray = (dict: Js.Dict.t<Js.Json.t>, key: string): array<string> => {
-  switch Js.Dict.get(dict, key) {
+let getStringArray = (dict: dict<Js.Json.t>, key: string): array<string> => {
+  switch Dict.get(dict, key) {
   | Some(v) =>
     switch Js.Json.classify(v) {
     | JSONArray(arr) =>
@@ -211,7 +211,7 @@ let parsePuzzleJson = (id: string, jsonStr: string): option<PuzzleFormat.t> => {
       let description = getString(dict, "description", "")
       let difficulty = getString(dict, "difficulty", "beginner")->parseDifficulty
       let maxMoves = getInt(dict, "maxMoves", 50)
-      let parMoves = switch Js.Dict.get(dict, "optimalMoves") {
+      let parMoves = switch Dict.get(dict, "optimalMoves") {
       | Some(v) =>
         switch Js.Json.classify(v) {
         | JSONNumber(n) => Belt.Float.toInt(n)
@@ -221,28 +221,28 @@ let parsePuzzleJson = (id: string, jsonStr: string): option<PuzzleFormat.t> => {
       }
 
       // Parse initial/goal state (supports both initialState and initialRegisters)
-      let initialRegisters = switch Js.Dict.get(dict, "initialState") {
+      let initialRegisters = switch Dict.get(dict, "initialState") {
       | Some(v) => extractRegisters(v)
       | None =>
-        switch Js.Dict.get(dict, "initialRegisters") {
+        switch Dict.get(dict, "initialRegisters") {
         | Some(v) => extractRegisters(v)
         | None => []
         }
       }
-      let goalRegisters = switch Js.Dict.get(dict, "goalState") {
+      let goalRegisters = switch Dict.get(dict, "goalState") {
       | Some(v) => extractRegisters(v)
       | None =>
-        switch Js.Dict.get(dict, "goalRegisters") {
+        switch Dict.get(dict, "goalRegisters") {
         | Some(v) => extractRegisters(v)
         | None => []
         }
       }
 
       // Parse tier  explicit, or inferred
-      let tier = switch Js.Dict.get(dict, "tier") {
+      let tier = switch Dict.get(dict, "tier") {
       | Some(v) => parseTier(v)
       | None => {
-          let fromInstr = switch Js.Dict.get(dict, "allowedInstructions") {
+          let fromInstr = switch Dict.get(dict, "allowedInstructions") {
           | Some(_) => {
               let instrs = getStringArray(dict, "allowedInstructions")
               if Belt.Array.length(instrs) > 0 {
@@ -271,7 +271,7 @@ let parsePuzzleJson = (id: string, jsonStr: string): option<PuzzleFormat.t> => {
       }
 
       // Parse hints
-      let hints = switch Js.Dict.get(dict, "hints") {
+      let hints = switch Dict.get(dict, "hints") {
       | Some(v) => parseHints(v)
       | None => []
       }
@@ -282,7 +282,7 @@ let parsePuzzleJson = (id: string, jsonStr: string): option<PuzzleFormat.t> => {
         if Belt.Array.length(topLevel) > 0 {
           topLevel
         } else {
-          switch Js.Dict.get(dict, "metadata") {
+          switch Dict.get(dict, "metadata") {
           | Some(v) =>
             switch Js.Json.classify(v) {
             | JSONObject(metaDict) => getStringArray(metaDict, "tags")
@@ -316,59 +316,59 @@ let parsePuzzleJson = (id: string, jsonStr: string): option<PuzzleFormat.t> => {
 
 // Serialize a puzzle to JSON (for bundle generation)
 let puzzleToJson = (p: PuzzleFormat.t): Js.Json.t => {
-  let dict = Js.Dict.empty()
-  Js.Dict.set(dict, "id", Js.Json.string(p.id))
-  Js.Dict.set(dict, "name", Js.Json.string(p.name))
-  Js.Dict.set(dict, "description", Js.Json.string(p.description))
-  Js.Dict.set(dict, "difficulty", Js.Json.string(PuzzleFormat.difficultyToString(p.difficulty)))
-  Js.Dict.set(dict, "tier", Js.Json.number(Belt.Int.toFloat(PuzzleFormat.tierToInt(p.tier))))
-  Js.Dict.set(dict, "maxMoves", Js.Json.number(Belt.Int.toFloat(p.maxMoves)))
-  Js.Dict.set(dict, "parMoves", Js.Json.number(Belt.Int.toFloat(p.parMoves)))
+  let dict = Dict.make()
+  Dict.set(dict, "id", Js.Json.string(p.id))
+  Dict.set(dict, "name", Js.Json.string(p.name))
+  Dict.set(dict, "description", Js.Json.string(p.description))
+  Dict.set(dict, "difficulty", Js.Json.string(PuzzleFormat.difficultyToString(p.difficulty)))
+  Dict.set(dict, "tier", Js.Json.number(Belt.Int.toFloat(PuzzleFormat.tierToInt(p.tier))))
+  Dict.set(dict, "maxMoves", Js.Json.number(Belt.Int.toFloat(p.maxMoves)))
+  Dict.set(dict, "parMoves", Js.Json.number(Belt.Int.toFloat(p.parMoves)))
 
   // Registers as objects
   let regsToJson = (regs: array<(string, int)>): Js.Json.t => {
-    let d = Js.Dict.empty()
+    let d = Dict.make()
     Belt.Array.forEach(regs, ((k, v)) => {
-      Js.Dict.set(d, k, Js.Json.number(Belt.Int.toFloat(v)))
+      Dict.set(d, k, Js.Json.number(Belt.Int.toFloat(v)))
     })
     Js.Json.object_(d)
   }
-  Js.Dict.set(dict, "initialRegisters", regsToJson(p.initialRegisters))
-  Js.Dict.set(dict, "goalRegisters", regsToJson(p.goalRegisters))
+  Dict.set(dict, "initialRegisters", regsToJson(p.initialRegisters))
+  Dict.set(dict, "goalRegisters", regsToJson(p.goalRegisters))
 
   // Memory pairs
   if Belt.Array.length(p.initialMemory) > 0 {
     let memToJson = (pairs: array<(int, int)>): Js.Json.t => {
       Js.Json.array(
         Belt.Array.map(pairs, ((addr, val_)) => {
-          let d = Js.Dict.empty()
-          Js.Dict.set(d, "addr", Js.Json.number(Belt.Int.toFloat(addr)))
-          Js.Dict.set(d, "value", Js.Json.number(Belt.Int.toFloat(val_)))
+          let d = Dict.make()
+          Dict.set(d, "addr", Js.Json.number(Belt.Int.toFloat(addr)))
+          Dict.set(d, "value", Js.Json.number(Belt.Int.toFloat(val_)))
           Js.Json.object_(d)
         }),
       )
     }
-    Js.Dict.set(dict, "initialMemory", memToJson(p.initialMemory))
-    Js.Dict.set(dict, "goalMemory", memToJson(p.goalMemory))
+    Dict.set(dict, "initialMemory", memToJson(p.initialMemory))
+    Dict.set(dict, "goalMemory", memToJson(p.goalMemory))
   }
 
   // Allowed instructions
   switch p.allowedInstructions {
   | Some(instrs) =>
-    Js.Dict.set(dict, "allowedInstructions", Js.Json.array(Belt.Array.map(instrs, Js.Json.string)))
+    Dict.set(dict, "allowedInstructions", Js.Json.array(Belt.Array.map(instrs, Js.Json.string)))
   | None => ()
   }
 
   // Hints
   if Belt.Array.length(p.hints) > 0 {
-    Js.Dict.set(
+    Dict.set(
       dict,
       "hints",
       Js.Json.array(
         Belt.Array.map(p.hints, h => {
-          let d = Js.Dict.empty()
-          Js.Dict.set(d, "moveThreshold", Js.Json.number(Belt.Int.toFloat(h.moveThreshold)))
-          Js.Dict.set(d, "text", Js.Json.string(h.text))
+          let d = Dict.make()
+          Dict.set(d, "moveThreshold", Js.Json.number(Belt.Int.toFloat(h.moveThreshold)))
+          Dict.set(d, "text", Js.Json.string(h.text))
           Js.Json.object_(d)
         }),
       ),
@@ -377,18 +377,18 @@ let puzzleToJson = (p: PuzzleFormat.t): Js.Json.t => {
 
   // Tags
   if Belt.Array.length(p.tags) > 0 {
-    Js.Dict.set(dict, "tags", Js.Json.array(Belt.Array.map(p.tags, Js.Json.string)))
+    Dict.set(dict, "tags", Js.Json.array(Belt.Array.map(p.tags, Js.Json.string)))
   }
 
   Js.Json.object_(dict)
 }
 
 // Serialize an array of puzzles to a bundle JSON string
 let bundleToJsonString = (puzzles: array<PuzzleFormat.t>): string => {
-  let bundle = Js.Dict.empty()
-  Js.Dict.set(bundle, "version", Js.Json.string("1.0.0"))
-  Js.Dict.set(bundle, "generatedAt", Js.Json.string("build-time"))
-  Js.Dict.set(bundle, "count", Js.Json.number(Belt.Int.toFloat(Belt.Array.length(puzzles))))
-  Js.Dict.set(bundle, "puzzles", Js.Json.array(Belt.Array.map(puzzles, puzzleToJson)))
+  let bundle = Dict.make()
+  Dict.set(bundle, "version", Js.Json.string("1.0.0"))
+  Dict.set(bundle, "generatedAt", Js.Json.string("build-time"))
+  Dict.set(bundle, "count", Js.Json.number(Belt.Int.toFloat(Belt.Array.length(puzzles))))
+  Dict.set(bundle, "puzzles", Js.Json.array(Belt.Array.map(puzzles, puzzleToJson)))
   Js.Json.stringify(Js.Json.object_(bundle))
 }

src/shared/Kernel_Crypto.res

@@ -31,15 +31,15 @@ let maxConcurrentCrypto = 3
 
 // Active crypto call counts keyed by deviceId.
 // Lazily populated; never shrinks (counts reset to 0 rather than removed).
-let cryptoActiveCounts: Js.Dict.t<ref<int>> = Js.Dict.empty()
+let cryptoActiveCounts: dict<ref<int>> = Dict.make()
 
 // Retrieve (or lazily create) the active-count ref for a device.
 let getCount = (deviceId: string): ref<int> =>
-  switch Js.Dict.get(cryptoActiveCounts, deviceId) {
+  switch Dict.get(cryptoActiveCounts, deviceId) {
   | Some(r) => r
   | None =>
     let r = ref(0)
-    Js.Dict.set(cryptoActiveCounts, deviceId, r)
+    Dict.set(cryptoActiveCounts, deviceId, r)
     r
   }