fix: harden exception handling, break ARC cycles, sync license/client

Replace bare except: with CatchableError across storage, query, Raft,
backup, and protocol code so Defects are not swallowed. Break uncollectable
ARC cycles in server shard/gossip callbacks via Server-owned refs and
cursor locals. Align package license with LICENSE (BSD-3-Clause), sync
README version, and point test_all at the canonical clients/nim baradb
client (parseConnectionString + aliases).

src/barabadb/core/backup.nim

@@ -146,7 +146,7 @@ proc formatTimestamp*(ts: int64): string =
   try:
     let dt = fromUnix(ts)
     result = format(dt, "yyyy-MM-dd HH:mm:ss")
-  except:
+  except CatchableError:
     result = $ts
 
 proc parseBackupFilename*(filename: string): int64 =
@@ -163,7 +163,7 @@ proc parseBackupFilename*(filename: string): int64 =
         result = 0
     else:
       result = 0
-  except:
+  except CatchableError:
     result = 0
 
 proc getArchiveSize*(input: string): int64 =
@@ -175,7 +175,7 @@ proc getArchiveSize*(input: string): int64 =
     if exitCode == 0:
       try:
         result = parseBiggestInt(strip(outStr))
-      except:
+      except CatchableError:
         result = getFileSize(input)  # fallback
     else:
       result = getFileSize(input)
@@ -189,7 +189,7 @@ proc getFreeSpace*(path: string): int64 =
   if exitCode == 0:
     try:
       result = parseBiggestInt(strip(outStr))
-    except:
+    except CatchableError:
       result = -1
   else:
     result = -1
@@ -701,14 +701,14 @@ when isMainModule:
       of "input", "i": target = val
       of "keep", "k":
         try: keepCount = parseInt(val)
-        except: quit("ERROR: --keep must be a number", 1)
+        except CatchableError: quit("ERROR: --keep must be a number", 1)
       of "exclude", "e": excludes.add(val)
       of "level", "l":
         try:
           compression = parseInt(val)
           if compression < 0 or compression > 9:
             quit("ERROR: --level must be between 0 and 9", 1)
-        except: quit("ERROR: --level must be a number", 1)
+        except CatchableError: quit("ERROR: --level must be a number", 1)
       of "dry-run": dryRun = true
       of "force", "f": force = true
       of "online": online = true

src/barabadb/core/gossip.nim

@@ -277,7 +277,7 @@ proc sendGossipUdp(gp: GossipProtocol, target: GossipNode, msg: GossipMessage) =
     let data = serialize(msg)
     sock.sendTo(target.host, Port(target.port), cast[string](data))
     sock.close()
-  except:
+  except CatchableError:
     discard
 
 proc broadcastGossip(gp: GossipProtocol) =
@@ -298,7 +298,7 @@ proc handleIncomingGossip(gp: GossipProtocol, data: string, senderAddr: string)
         let parts = host.split(":")
         host = parts[0]
         if parts[1].len > 0:
-          port = try: parseInt(parts[1]) except: gp.gossipPort
+          port = try: parseInt(parts[1]) except CatchableError: gp.gossipPort
       let newNode = GossipNode(
         id: msg.senderId, host: host, port: port,
         state: nsAlive, incarnation: msg.senderIncarnation,
@@ -306,7 +306,7 @@ proc handleIncomingGossip(gp: GossipProtocol, data: string, senderAddr: string)
       )
       gp.addMember(newNode)
     gp.applyGossipMessage(msg)
-  except:
+  except CatchableError:
     discard
 
 proc startHealthCheck*(gp: GossipProtocol, intervalMs: int = 1000) {.async.} =
@@ -342,14 +342,14 @@ proc startGossipListener*(gp: GossipProtocol) {.async.} =
         # Recreate socket after too many errors
         try:
           gp.sock.close()
-        except:
+        except CatchableError:
           discard
         try:
           gp.sock = newAsyncSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
           gp.sock.setSockOpt(OptReuseAddr, true)
           gp.sock.bindAddr(Port(gp.gossipPort))
           consecutiveErrors = 0
-        except:
+        except CatchableError:
           break
       # Exponential backoff with cap
       let delayMs = min(baseRetryDelayMs * (1 shl min(consecutiveErrors, 6)), 5000)

src/barabadb/core/httpserver.nim

@@ -103,7 +103,7 @@ proc verifyToken*(server: HttpServer, tokenStr: string): (bool, string, string)
     let userId = token.claims["sub"].node.str
     let role = if "role" in token.claims: token.claims["role"].node.str else: "user"
     return (true, userId, role)
-  except:
+  except CatchableError:
     return (false, "", "")
 
 # ----------------------------------------------------------------------

src/barabadb/core/raft.nim

@@ -202,7 +202,7 @@ proc applyCommitted(node: RaftNode) =
         let parts = entry.command.split(":")
         if parts.len >= 3:
           let action = parts[1]
-          let txnId = try: parseUInt(parts[2]) except: 0'u64
+          let txnId = try: parseUInt(parts[2]) except CatchableError: 0'u64
           if action == "PREPARE" and node.onDistTxnPrepare != nil:
             discard node.onDistTxnPrepare(txnId, @[])
           elif action == "COMMIT" and node.onDistTxnCommit != nil:
@@ -564,7 +564,7 @@ proc connectToPeer(net: RaftNetwork, peerId: string) {.async.} =
     let sock = newAsyncSocket()
     await sock.connect(host, Port(port))
     net.peerSockets[peerId] = sock
-  except:
+  except CatchableError:
     discard
 
 proc send*(net: RaftNetwork, peerId: string, msg: RaftMessage) {.async.} =
@@ -577,7 +577,7 @@ proc send*(net: RaftNetwork, peerId: string, msg: RaftMessage) {.async.} =
     bigEndian32(addr header[0], unsafeAddr payloadLen)
     try:
       await net.peerSockets[peerId].send(cast[string](header) & cast[string](data))
-    except:
+    except CatchableError:
       net.peerSockets.del(peerId)
 
 proc broadcast*(net: RaftNetwork, msgs: seq[RaftMessage]) {.async.} =
@@ -615,9 +615,9 @@ proc receiveLoop(net: RaftNetwork, client: AsyncSocket) {.async.} =
       let msg = deserializeRaftMessage(payload)
       try:
         await net.processMessage(msg)
-      except:
+      except CatchableError:
         discard
-  except:
+  except CatchableError:
     discard
   finally:
     client.close()
@@ -641,7 +641,7 @@ proc run*(net: RaftNetwork) {.async.} =
     try:
       let client = await net.socket.accept()
       asyncCheck net.receiveLoop(client)
-    except:
+    except CatchableError:
       break
 
 proc stop*(net: RaftNetwork) =

src/barabadb/core/replication.nim

@@ -266,12 +266,12 @@ proc healthCheck*(rm: ReplicationManager) =
           sock.readLine(response)
           if response.strip() != "PONG":
             connected = false
-        except:
+        except CatchableError:
           connected = false
-    except:
+    except CatchableError:
       connected = false
     finally:
-      try: sock.close() except: discard
+      try: sock.close() except CatchableError: discard
 
     if not connected:
       acquire(rm.lock)

src/barabadb/core/server.nim

@@ -65,55 +65,53 @@ proc newServerWithRegistry*(config: BaraConfig, registry: DatabaseRegistry): Ser
     let tlsConfig = newTLSConfig(config.certFile, config.keyFile)
     tls = newTLSContext(tlsConfig)
 
-  # Initialize sharding
-  let shardRouter = newShardRouter()
+  # Initialize sharding / gossip. Server fields own the refs; locals used inside
+  # callback closures are {.cursor.} so ARC does not form uncollectable cycles
+  # (local + closure env + object callback fields).
   let localId = if config.raftNodeId.len > 0: config.raftNodeId else: "node-" & $config.port
-  let cm = newClusterMembership(shardRouter, localId)
-
-  # Wire shard migration callbacks to LSM (use default database)
-  shardRouter.iterateKeys = proc(shardId: int): seq[(string, seq[byte])] {.gcsafe.} =
-    var entries: seq[(string, seq[byte])] = @[]
-    for (key, value) in db.scanAll():
-      if shardRouter.getShard(key) == shardId:
-        entries.add((key, value))
-    return entries
-
-  shardRouter.storeKeys = proc(shardId: int, entries: seq[(string, seq[byte])]) {.gcsafe.} =
-    for (key, value) in entries:
-      db.put(key, value)
-
-  shardRouter.deleteKeys = proc(keys: seq[string]) {.gcsafe.} =
-    for key in keys:
-      db.delete(key)
-
-  # Initialize gossip
   let gossipPort = config.raftPort + 100
-  let gp = newGossipProtocol(localId, config.address, config.port, gossipPort = gossipPort)
-
-  # Wire gossip → cluster membership
-  gp.onJoin = proc(node: GossipNode) {.gcsafe.} =
-    cm.onNodeJoin(node.id, node.host, node.port)
-
-  gp.onLeave = proc(nodeId: string) {.gcsafe.} =
-    cm.onNodeLeave(nodeId)
-
-  gp.onSuspect = proc(nodeId: string) {.gcsafe.} =
-    cm.onNodeSuspect(nodeId)
-
-  # Initialize rate limiter
   let rl = newRateLimiter(rlaTokenBucket, config.rateLimitGlobal, config.rateLimitPerClient)
 
   result = Server(config: config, running: false, db: db, ctx: ctx,
          registry: registry,
          txnManager: ctx.txnManager, distTxnManager: newDistTxnManager(),
          replicationManager: newReplicationManager(),
-         shardRouter: shardRouter,
-         clusterMembership: cm,
-         gossipProtocol: gp,
+         shardRouter: newShardRouter(),
+         clusterMembership: nil,
+         gossipProtocol: newGossipProtocol(localId, config.address, config.port, gossipPort = gossipPort),
          tls: tls,
          rateLimiter: rl)
+  result.clusterMembership = newClusterMembership(result.shardRouter, localId)
   initLock(result.activeConnectionsLock)
 
+  # Wire shard migration callbacks to LSM (default database)
+  block:
+    let shardRouter {.cursor.} = result.shardRouter
+    let dbRef {.cursor.} = db
+    shardRouter.iterateKeys = proc(shardId: int): seq[(string, seq[byte])] {.gcsafe.} =
+      var entries: seq[(string, seq[byte])] = @[]
+      for (key, value) in dbRef.scanAll():
+        if shardRouter.getShard(key) == shardId:
+          entries.add((key, value))
+      return entries
+    shardRouter.storeKeys = proc(shardId: int, entries: seq[(string, seq[byte])]) {.gcsafe.} =
+      for (key, value) in entries:
+        dbRef.put(key, value)
+    shardRouter.deleteKeys = proc(keys: seq[string]) {.gcsafe.} =
+      for key in keys:
+        dbRef.delete(key)
+
+  # Wire gossip → cluster membership
+  block:
+    let gp {.cursor.} = result.gossipProtocol
+    let cm {.cursor.} = result.clusterMembership
+    gp.onJoin = proc(node: GossipNode) {.gcsafe.} =
+      cm.onNodeJoin(node.id, node.host, node.port)
+    gp.onLeave = proc(nodeId: string) {.gcsafe.} =
+      cm.onNodeLeave(nodeId)
+    gp.onSuspect = proc(nodeId: string) {.gcsafe.} =
+      cm.onNodeSuspect(nodeId)
+
 proc newServerWithDb*(config: BaraConfig, db: LSMTree): Server =
   let registry = newDatabaseRegistry(config)
   let ctx = newExecutionContext(db, registry)
@@ -389,7 +387,7 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
           rest.add(more)
         let parts = rest.strip().split(" ")
         if parts.len >= 2:
-          let txnId = try: uint64(parseBiggestUint(parts[0])) except: 0'u64
+          let txnId = try: uint64(parseBiggestUint(parts[0])) except CatchableError: 0'u64
           let action = parts[1].toUpper()
           if server.distTxnManager != nil:
             let txn = server.distTxnManager.getTxn(txnId)
@@ -428,8 +426,8 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
           rest.add(more)
         let parts = rest.strip().split(" ")
         if parts.len >= 2:
-          let lsn = try: parseUInt(parts[0]) except: 0'u64
-          let dataLen = try: parseInt(parts[1]) except: 0
+          let lsn = try: parseUInt(parts[0]) except CatchableError: 0'u64
+          let dataLen = try: parseInt(parts[1]) except CatchableError: 0
           if dataLen > 0:
             var data = ""
             while data.len < dataLen:
@@ -460,7 +458,7 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
         let headerLine = "MIGRATE " & rest.strip()
         let parts = rest.strip().split(" ")
         if parts.len >= 2:
-          let entryCount = try: parseInt(parts[1]) except: 0
+          let entryCount = try: parseInt(parts[1]) except CatchableError: 0
           var data = ""
           if entryCount > 0:
             # Read all entries (each entry is key\0value\n)
@@ -551,7 +549,7 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
         # Shard-aware routing: check if this node should handle the write
         var shardCheck = true
         if server.clusterMembership.nodes.len > 0:
-          let stmts = try: parse(tokenize(queryStr)) except: nil
+          let stmts = try: parse(tokenize(queryStr)) except CatchableError: nil
           if stmts != nil:
             for stmt in stmts.stmts:
               if stmt.kind in {nkInsert, nkUpdate, nkDelete}:

src/barabadb/core/sharding.nim

@@ -337,8 +337,8 @@ proc handleMigrationMessage*(headerLine: string, data: string,
   if parts.len < 3:
     return "ERR invalid migrate header\n"
 
-  let shardId = try: parseInt(parts[1]) except: -1
-  let entryCount = try: parseInt(parts[2]) except: 0
+  let shardId = try: parseInt(parts[1]) except CatchableError: -1
+  let entryCount = try: parseInt(parts[2]) except CatchableError: 0
 
   if shardId < 0 or entryCount < 0:
     return "ERR invalid shard id or entry count\n"

src/barabadb/core/tracing.nim

@@ -128,5 +128,5 @@ proc exportOtlp*(tracer: Tracer, endpoint: string = "http://localhost:4318/v1/tr
     client.close()
     tracer.spans = @[]
     return true
-  except:
+  except CatchableError:
     return false

src/barabadb/core/websocket.nim

@@ -189,7 +189,7 @@ proc notifyClient(client: WsClient, msg: string) {.async.} =
   try:
     let frame = encodeFrame(0x1, msg)
     await client.socket.send(frame)
-  except:
+  except CatchableError:
     discard
 
 proc broadcastToTable*(server: WsServer, table: string, msg: string) {.async.} =
@@ -247,7 +247,7 @@ proc handleWsClient(server: WsServer, client: AsyncSocket, id: int) {.async.} =
 
         buf = buf[consumed..^1]
 
-  except:
+  except CatchableError:
     discard
   finally:
     echo "WebSocket client ", id, " disconnected"
@@ -305,7 +305,7 @@ proc handleConnection(server: WsServer, client: AsyncSocket) {.async.} =
           await client.send("HTTP/1.1 401 Unauthorized\r\n\r\n")
           client.close()
           return
-    except:
+    except CatchableError:
       await client.send("HTTP/1.1 401 Unauthorized\r\n\r\n")
       client.close()
       return

src/barabadb/protocol/zerocopy.nim

@@ -167,14 +167,14 @@ proc encodeRecord*(buf: var ZeroBuf, schema: ZcSchema,
       try:
         var v = int32(parseInt(value))
         bigEndian32(addr buf.data[field.offset], unsafeAddr v)
-      except:
+      except CatchableError:
         var v: int32 = 0
         bigEndian32(addr buf.data[field.offset], unsafeAddr v)
     of ztInt64:
       try:
         var v = int64(parseInt(value))
         bigEndian64(addr buf.data[field.offset], unsafeAddr v)
-      except:
+      except CatchableError:
         var v: int64 = 0
         bigEndian64(addr buf.data[field.offset], unsafeAddr v)
     of ztString:

src/barabadb/query/executor.nim

@@ -232,7 +232,7 @@ proc acquireMigrationLock(ctx: ExecutionContext): bool =
   let (locked, lockVal) = ctx.db.get(lockKey)
   if locked:
     # Check for stale lock (older than 1 hour)
-    let lockTime = try: parseInt(cast[string](lockVal)) except: 0
+    let lockTime = try: parseInt(cast[string](lockVal)) except CatchableError: 0
     if lockTime > 0 and (epochTime().int64 - lockTime) > 3600:
       # Stale lock — force release
       ctx.db.delete(lockKey)
@@ -362,7 +362,7 @@ proc parseVectorString*(value: string): seq[float32] =
     if p.len > 0:
       try:
         result.add(parseFloat(p).float32)
-      except:
+      except CatchableError:
         discard
 
 # ----------------------------------------------------------------------
@@ -621,10 +621,10 @@ proc evalExpr*(expr: IRExpr, row: Row, ctx: ExecutionContext = nil): Value =
       case expr.valueKind
       of vkInt64:
         try: return Value(kind: vkInt64, int64Val: parseInt(s))
-        except: return Value(kind: vkNull)
+        except CatchableError: return Value(kind: vkNull)
       of vkFloat64:
         try: return Value(kind: vkFloat64, float64Val: parseFloat(s))
-        except: return Value(kind: vkNull)
+        except CatchableError: return Value(kind: vkNull)
       of vkBool:
         return Value(kind: vkBool, boolVal: s == "true")
       of vkNull:
@@ -634,10 +634,10 @@ proc evalExpr*(expr: IRExpr, row: Row, ctx: ExecutionContext = nil): Value =
         if s.len == 0: return Value(kind: vkString, strVal: s)
         try:
           return Value(kind: vkInt64, int64Val: parseInt(s))
-        except:
+        except CatchableError:
           try:
             return Value(kind: vkFloat64, float64Val: parseFloat(s))
-          except:
+          except CatchableError:
             return Value(kind: vkString, strVal: s)
     return Value(kind: vkNull)
   of irekBinary:
@@ -803,7 +803,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
           of JNull: return "null"
           else: return $val
       return ""
-    except:
+    except CatchableError:
       return ""
   of irekBinary:
     let left = evalExprOld(expr.binLeft, row, ctx)
@@ -814,30 +814,30 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
       # Try numeric comparison
       try:
         if parseFloat(left) == parseFloat(right): return "true"
-      except: discard
+      except CatchableError: discard
       return "false"
     of irNeq:
       if left != right: return "true"
       # Try numeric comparison
       try:
         return if parseFloat(left) != parseFloat(right): "true" else: "false"
-      except: return "false"
+      except CatchableError: return "false"
     of irLt:
       try:
         return if parseFloat(left) < parseFloat(right): "true" else: "false"
-      except: return if left < right: "true" else: "false"
+      except CatchableError: return if left < right: "true" else: "false"
     of irLte:
       try:
         return if parseFloat(left) <= parseFloat(right): "true" else: "false"
-      except: return if left <= right: "true" else: "false"
+      except CatchableError: return if left <= right: "true" else: "false"
     of irGt:
       try:
         return if parseFloat(left) > parseFloat(right): "true" else: "false"
-      except: return if left > right: "true" else: "false"
+      except CatchableError: return if left > right: "true" else: "false"
     of irGte:
       try:
         return if parseFloat(left) >= parseFloat(right): "true" else: "false"
-      except: return if left >= right: "true" else: "false"
+      except CatchableError: return if left >= right: "true" else: "false"
     of irAnd:
       if left == "true" and right == "true": return "true"
       return "false"
@@ -867,7 +867,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
       try:
         let rePattern = re(pattern)
         if left.match(rePattern): return "true"
-      except: discard
+      except CatchableError: discard
       return "false"
     of irILike:
       proc escapeRe(s: string): string =
@@ -882,7 +882,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
       try:
         let rePattern = re(pattern)
         if left.toLower().match(rePattern): return "true"
-      except: discard
+      except CatchableError: discard
       return "false"
     of irIn:
       if expr.binRight.kind == irekSubquery:
@@ -902,7 +902,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
         let lv = parseFloat(left)
         let rv = parseFloat(right)
         return if lv == rv: "true" else: "false"
-      except: discard
+      except CatchableError: discard
       return if left == right: "true" else: "false"
     of irNotIn:
       if expr.binRight.kind == irekSubquery:
@@ -922,7 +922,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
         let lv = parseFloat(left)
         let rv = parseFloat(right)
         return if lv != rv: "true" else: "false"
-      except: discard
+      except CatchableError: discard
       return if left != right: "true" else: "false"
     of irFtsMatch:
       # Check for FTS index via ctx
@@ -986,7 +986,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
           return "true"
         else:
           return if $(leftNode) == $(rightNode): "true" else: "false"
-      except:
+      except CatchableError:
         return "false"
     of irJsonContainedBy:
       # Check if left JSON is contained by right JSON (reverse of contains)
@@ -1010,7 +1010,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
           return "true"
         else:
           return if $(leftNode) == $(rightNode): "true" else: "false"
-      except:
+      except CatchableError:
         return "false"
     of irJsonHasAny:
       # Check if JSON object has any of the keys in right array
@@ -1022,7 +1022,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
             if key.kind == JString and leftNode.hasKey(key.getStr()):
               return "true"
         return "false"
-      except:
+      except CatchableError:
         return "false"
     of irJsonHasAll:
       # Check if JSON object has all of the keys in right array
@@ -1035,7 +1035,7 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
               return "false"
           return "true"
         return "false"
-      except:
+      except CatchableError:
         return "false"
     else: return "false"
   of irekUnary:
@@ -1097,10 +1097,10 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
           try:
             let idx = parseInt(key)
             return if idx >= 0 and idx < node.len: "true" else: "false"
-          except:
+          except CatchableError:
             return "false"
         return "false"
-      except:
+      except CatchableError:
         return "false"
     of "current_setting":
       if expr.irFuncArgs.len < 1:
@@ -1460,13 +1460,13 @@ proc evalExprOld*(expr: IRExpr, row: Table[string, string], ctx: ExecutionContex
           try:
             let dt = parse(val, "yyyy-MM-dd HH:mm:ss")
             return $(dt.toTime().toUnix())
-          except:
+          except CatchableError:
             return "0"
         elif fmt == "%Y-%m-%dT%H:%M:%SZ":
           try:
             let dt = parse(val, "yyyy-MM-dd HH:mm:ss")
             return format(dt, "yyyy-MM-dd'T'HH:mm:ss'Z'")
-          except:
+          except CatchableError:
             return ""
       return ""
     else:
@@ -1773,7 +1773,7 @@ proc execInsert*(ctx: ExecutionContext, table: string, fields: seq[string], valu
                 props[f] = rowVals[i]
           try:
             gengine.addNodeWithId(graph, nid, label, props)
-          except:
+          except CatchableError:
             discard
       elif table == graphName & "_edges":
         var srcStr = ""
@@ -1786,13 +1786,13 @@ proc execInsert*(ctx: ExecutionContext, table: string, fields: seq[string], valu
             elif f == "dest_id": dstStr = rowVals[i]
             elif f == "edge_label": label = rowVals[i]
             elif f == "weight":
-              try: weight = parseFloat(rowVals[i]) except: discard
+              try: weight = parseFloat(rowVals[i]) except CatchableError: discard
         if srcStr.len > 0 and dstStr.len > 0:
           let srcId = gengine.NodeId(parseUInt(srcStr))
           let dstId = gengine.NodeId(parseUInt(dstStr))
           try:
             gengine.addEdgeWithId(graph, srcId, dstId, label, weight)
-          except:
+          except CatchableError:
             discard
 
     inc count
@@ -2018,10 +2018,10 @@ proc validateType*(colType: string, value: string): (bool, string) =
   let t = colType.toUpper()
   if t == "INTEGER" or t == "INT" or t == "BIGINT" or t == "SMALLINT" or t == "SERIAL":
     try: discard parseInt(value)
-    except: return (false, "Type mismatch: expected " & t & " but got '" & value & "'")
+    except CatchableError: return (false, "Type mismatch: expected " & t & " but got '" & value & "'")
   elif t == "FLOAT" or t == "REAL" or t == "DOUBLE" or t == "DOUBLE PRECISION" or t == "NUMERIC":
     try: discard parseFloat(value)
-    except: return (false, "Type mismatch: expected " & t & " but got '" & value & "'")
+    except CatchableError: return (false, "Type mismatch: expected " & t & " but got '" & value & "'")
   elif t == "BOOLEAN" or t == "BOOL":
     let lv = value.toLower()
     if lv notin ["true", "false", "1", "0", "t", "f", "yes", "no"]:
@@ -2032,7 +2032,7 @@ proc validateType*(colType: string, value: string): (bool, string) =
   elif t == "JSON" or t == "JSONB":
     try:
       discard parseJson(value)
-    except:
+    except CatchableError:
       return (false, "Type mismatch: expected JSON but got '" & value & "'")
   elif t.startsWith("VECTOR"):
     let vec = parseVectorString(value)
@@ -2044,7 +2044,7 @@ proc validateType*(colType: string, value: string): (bool, string) =
     if dimStart >= 0 and dimEnd > dimStart:
       try:
         expectedDim = parseInt(t[dimStart+1..<dimEnd])
-      except:
+      except CatchableError:
         expectedDim = 0
     if expectedDim > 0 and vec.len != expectedDim:
       return (false, "Vector dimension mismatch: expected " & $expectedDim & " but got " & $vec.len)
@@ -2572,7 +2572,7 @@ proc compareRowsByOrder(a, b: Row, orderExprs: seq[IRExpr], orderDirs: seq[bool]
       let fb = parseFloat(valueToString(vb))
       if fa < fb: cmpRes = -1
       elif fa > fb: cmpRes = 1
-    except:
+    except CatchableError:
       cmpRes = cmp(valueToString(va), valueToString(vb))
     if cmpRes != 0:
       return if orderDirs.len > i and orderDirs[i]: -cmpRes else: cmpRes
@@ -2592,12 +2592,12 @@ proc resolveFrameBounds(pos, partLen: int, frameStart, frameEnd: string): (int,
   elif frameStart.endsWith(" PRECEDING"):
     let nStr = frameStart[0..^11]
     var n = 0
-    try: n = parseInt(nStr) except: n = 0
+    try: n = parseInt(nStr) except CatchableError: n = 0
     startPos = max(0, pos - n)
   elif frameStart.endsWith(" FOLLOWING"):
     let nStr = frameStart[0..^11]
     var n = 0
-    try: n = parseInt(nStr) except: n = 0
+    try: n = parseInt(nStr) except CatchableError: n = 0
     startPos = min(partLen - 1, pos + n)
 
   # Parse end boundary
@@ -2608,12 +2608,12 @@ proc resolveFrameBounds(pos, partLen: int, frameStart, frameEnd: string): (int,
   elif frameEnd.endsWith(" PRECEDING"):
     let nStr = frameEnd[0..^11]
     var n = 0
-    try: n = parseInt(nStr) except: n = 0
+    try: n = parseInt(nStr) except CatchableError: n = 0
     endPos = max(0, pos - n)
   elif frameEnd.endsWith(" FOLLOWING"):
     let nStr = frameEnd[0..^11]
     var n = 0
-    try: n = parseInt(nStr) except: n = 0
+    try: n = parseInt(nStr) except CatchableError: n = 0
     endPos = min(partLen - 1, pos + n)
 
   if startPos > endPos:
@@ -2668,7 +2668,7 @@ proc computeWindowValues*(rows: seq[Row], expr: IRExpr, ctx: ExecutionContext =
     of "ntile":
       var n = 1
       if expr.wfArgs.len > 0:
-        try: n = parseInt(valueToString(evalExpr(expr.wfArgs[0], rows[sortedIdxs[0]], ctx))) except: n = 1
+        try: n = parseInt(valueToString(evalExpr(expr.wfArgs[0], rows[sortedIdxs[0]], ctx))) except CatchableError: n = 1
       if n < 1: n = 1
       let groupSize = sortedIdxs.len div n
       let remainder = sortedIdxs.len mod n
@@ -2687,7 +2687,7 @@ proc computeWindowValues*(rows: seq[Row], expr: IRExpr, ctx: ExecutionContext =
       var offset = 1
       var defaultVal = ""
       if expr.wfArgs.len > 1:
-        try: offset = parseInt(valueToString(evalExpr(expr.wfArgs[1], rows[sortedIdxs[0]], ctx))) except: offset = 1
+        try: offset = parseInt(valueToString(evalExpr(expr.wfArgs[1], rows[sortedIdxs[0]], ctx))) except CatchableError: offset = 1
       if expr.wfArgs.len > 2:
         defaultVal = valueToString(evalExpr(expr.wfArgs[2], rows[sortedIdxs[0]], ctx))
       for pos, rowIdx in sortedIdxs:
@@ -2700,7 +2700,7 @@ proc computeWindowValues*(rows: seq[Row], expr: IRExpr, ctx: ExecutionContext =
       var offset = 1
       var defaultVal = ""
       if expr.wfArgs.len > 1:
-        try: offset = parseInt(valueToString(evalExpr(expr.wfArgs[1], rows[sortedIdxs[0]], ctx))) except: offset = 1
+        try: offset = parseInt(valueToString(evalExpr(expr.wfArgs[1], rows[sortedIdxs[0]], ctx))) except CatchableError: offset = 1
       if expr.wfArgs.len > 2:
         defaultVal = valueToString(evalExpr(expr.wfArgs[2], rows[sortedIdxs[0]], ctx))
       for pos, rowIdx in sortedIdxs:
@@ -2843,14 +2843,14 @@ proc executePlan*(ctx: ExecutionContext, plan: IRPlan): seq[Row] =
               var sum = 0.0
               for row in filteredRows:
                 let v = evalExpr(expr.aggArgs[0], row, ctx)
-                try: sum += parseFloat(valueToString(v)) except: discard
+                try: sum += parseFloat(valueToString(v)) except CatchableError: discard
               newRow[alias] = $sum
             of irAvg:
               var sum = 0.0
               var count = 0
               for row in filteredRows:
                 let v = evalExpr(expr.aggArgs[0], row, ctx)
-                try: sum += parseFloat(valueToString(v)); count += 1 except: discard
+                try: sum += parseFloat(valueToString(v)); count += 1 except CatchableError: discard
               newRow[alias] = if count > 0: $(sum / float(count)) else: "0"
             of irMin:
               var minVal = ""
@@ -2930,7 +2930,7 @@ proc executePlan*(ctx: ExecutionContext, plan: IRPlan): seq[Row] =
           let fb = parseFloat(valueToString(vb))
           if fa < fb: cmpRes = -1
           elif fa > fb: cmpRes = 1
-        except:
+        except CatchableError:
           cmpRes = cmp(valueToString(va), valueToString(vb))
         if not ascending: cmpRes = -cmpRes
         if cmpRes != 0: return cmpRes
@@ -3022,14 +3022,14 @@ proc executePlan*(ctx: ExecutionContext, plan: IRPlan): seq[Row] =
             var sum = 0.0
             for row in filteredRows:
               let v = evalExpr(aggExpr.aggArgs[0], row, ctx)
-              try: sum += parseFloat(valueToString(v)) except: discard
+              try: sum += parseFloat(valueToString(v)) except CatchableError: discard
             aggRow[aggKey] = $sum
           of irAvg:
             var sum = 0.0
             var count = 0
             for row in filteredRows:
               let v = evalExpr(aggExpr.aggArgs[0], row, ctx)
-              try: sum += parseFloat(valueToString(v)); count += 1 except: discard
+              try: sum += parseFloat(valueToString(v)); count += 1 except CatchableError: discard
             aggRow[aggKey] = if count > 0: $(sum / float(count)) else: "0"
           of irMin:
             var minVal = ""
@@ -3544,14 +3544,14 @@ proc executePlan*(ctx: ExecutionContext, plan: IRPlan): seq[Row] =
             var sum = 0.0
             for row in matchingRows:
               let v = evalExpr(plan.pivotAgg.aggArgs[0], row, ctx)
-              try: sum += parseFloat(valueToString(v)) except: discard
+              try: sum += parseFloat(valueToString(v)) except CatchableError: discard
             aggResult = $sum
           of irAvg:
             var sum = 0.0
             var count = 0
             for row in matchingRows:
               let v = evalExpr(plan.pivotAgg.aggArgs[0], row, ctx)
-              try: sum += parseFloat(valueToString(v)); count += 1 except: discard
+              try: sum += parseFloat(valueToString(v)); count += 1 except CatchableError: discard
             aggResult = if count > 0: $(sum / float(count)) else: "0"
           of irMin:
             var minVal = ""
@@ -3609,8 +3609,8 @@ proc executePlan*(ctx: ExecutionContext, plan: IRPlan): seq[Row] =
     let algo = plan.graphAlgo.toLowerAscii()
     let returnCols = plan.graphReturnCols
     let firstNodeId = if g.nodes.len > 0: g.nodes.keys.toSeq[0] else: gengine.NodeId(0)
-    let explicitStart = try: parseUInt(plan.graphStartNode) except: 0'u64
-    let explicitEnd = try: parseUInt(plan.graphEndNode) except: 0'u64
+    let explicitStart = try: parseUInt(plan.graphStartNode) except CatchableError: 0'u64
+    let explicitEnd = try: parseUInt(plan.graphEndNode) except CatchableError: 0'u64
 
     case algo
     of "bfs":
@@ -4034,7 +4034,7 @@ proc executeQueryImpl(ctx: ExecutionContext, astNode: Node, params: seq[WireValu
               if fa < fb: return -1
               if fa > fb: return 1
               return 0
-            except:
+            except CatchableError:
               return cmp(valueToString(va), valueToString(vb))
           filteredRows.sort(sortCmp, if asc: Ascending else: Descending)
         if stmt.selLimit != nil:
@@ -4369,7 +4369,7 @@ proc executeQueryImpl(ctx: ExecutionContext, astNode: Node, params: seq[WireValu
                     ctx.autoIncCounters[counterKey] = intVal + 1
                 finally:
                   release(ctx.sharedLock.lock)
-              except: discard
+              except CatchableError: discard
 
     applyDefaultValues(tbl, mutableFields, mutableValues)
 

src/barabadb/query/udf.nim

@@ -211,7 +211,7 @@ proc registerStdlib*(reg: UDFRegistry) =
       if args.len > 0 and args[0].kind == vkString:
         try:
           return Value(kind: vkInt64, int64Val: parseInt(args[0].strVal))
-        except:
+        except CatchableError:
           discard
       return Value(kind: vkNull))
 

src/barabadb/storage/compaction.nim

@@ -58,7 +58,7 @@ proc rebuildFromLSM*(cs: CompactionStrategy, db: LSMTree) =
   cs.clear()
   cs.dataDir = db.dir
   for sst in db.sstables:
-    let size = try: int(getFileSize(sst.path)) except: sst.entryCount * 64
+    let size = try: int(getFileSize(sst.path)) except CatchableError: sst.entryCount * 64
     cs.addTable(SSTableMeta(
       path: sst.path,
       level: sst.level,
@@ -143,7 +143,7 @@ proc compact*(cs: CompactionStrategy, level: int): CompactionResult =
   var sst = writeSSTable(final, outputPath, level + 1)
 
   # Use actual file size instead of rough guess
-  let actualSize = try: getFileSize(outputPath) except: final.len * 64
+  let actualSize = try: getFileSize(outputPath) except CatchableError: final.len * 64
 
   let outputMeta = SSTableMeta(
     path: outputPath,
@@ -159,7 +159,7 @@ proc compact*(cs: CompactionStrategy, level: int): CompactionResult =
   let (ok, msg) = verifySSTable(outputPath)
   if not ok:
     echo "[ERROR] Compaction output verification failed: ", msg
-    try: removeFile(outputPath) except: discard
+    try: removeFile(outputPath) except CatchableError: discard
     return CompactionResult()
 
   # Remove old SSTable files

src/barabadb/storage/gate.nim

@@ -18,13 +18,15 @@ var
 
 proc initStorageGate*() =
   ## Idempotent when called from a single thread at startup.
+  ## Must run before multi-threaded accept (HTTP workers / TCP).
   if not gInited:
     initLock(gGate)
     gInited = true
 
 proc acquireStorageGate*() {.inline.} =
   ## Prefer calling initStorageGate() once at process start (main).
-  ## Lazy-init is allowed for unit tests (single-threaded).
+  ## Lazy-init is only safe for single-threaded unit tests — concurrent
+  ## first-time init races on gInited / initLock.
   if not gInited:
     initStorageGate()
   acquire(gGate)

src/barabadb/storage/lsm.nim

@@ -473,7 +473,7 @@ proc listLegacySSTables*(dir: string): seq[(string, uint32)] =
         let sst = loadSSTable(path)
         if sst.fileVersion < SSTableVersion:
           result.add((path, sst.fileVersion))
-      except:
+      except CatchableError:
         discard
 
 proc migrateSSTable*(path: string): bool =
@@ -595,7 +595,7 @@ proc checkStorageConsistency*(db: LSMTree): seq[string] =
       let j = parseJson(readFile(manifestPath))
       for node in j{"sstables"}:
         manifestPaths.add(node{"path"}.getStr())
-    except:
+    except CatchableError:
       result.add("MANIFEST is corrupt or unreadable")
       return
 

src/barabadb/storage/wal.nim

@@ -77,7 +77,7 @@ proc parseWalSequence*(filename: string): int64 =
       result = parseBiggestInt(numStr)
     else:
       result = 0
-  except:
+  except CatchableError:
     result = 0
 
 proc listWalArchive*(dir: string): seq[WalSegment] =
@@ -90,7 +90,7 @@ proc listWalArchive*(dir: string): seq[WalSegment] =
     if kind == pcFile and path.endsWith(".log"):
       let seqNum = parseWalSequence(extractFilename(path))
       if seqNum > 0:
-        let size = try: getFileSize(path) except: 0
+        let size = try: getFileSize(path) except CatchableError: 0
         result.add(WalSegment(sequence: seqNum, path: path, size: size))
   result.sort(proc(a, b: WalSegment): int = cmp(a.sequence, b.sequence))
 
@@ -140,7 +140,7 @@ proc maybeRotate*(wal: var WriteAheadLog) =
   ## Rotate if current WAL exceeds max segment size.
   if wal.maxSegmentSize <= 0:
     return
-  let currentSize = try: getFileSize(wal.path) except: 0
+  let currentSize = try: getFileSize(wal.path) except CatchableError: 0
   if currentSize >= wal.maxSegmentSize:
     wal.rotate()