diff --git a/package-lock.json b/package-lock.json
index 468cb896..f649d2be 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,7 +11,8 @@
 				"@lucide/svelte": "^0.564.0",
 				"@types/leaflet.markercluster": "^1.5.6",
 				"leaflet": "^1.9.4",
-				"leaflet.markercluster": "^1.5.3"
+				"leaflet.markercluster": "^1.5.3",
+				"spacetimedb": "^2.3.0"
 			},
 			"devDependencies": {
 				"@sveltejs/adapter-auto": "^7.0.0",
@@ -2140,6 +2141,26 @@
 				"node": ">= 0.4"
 			}
 		},
+		"node_modules/base64-js": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+			"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "MIT"
+		},
 		"node_modules/blake3-wasm": {
 			"version": "2.1.5",
 			"resolved": "https://registry.npmjs.org/blake3-wasm/-/blake3-wasm-2.1.5.tgz",
@@ -2331,6 +2352,12 @@
 			"dev": true,
 			"license": "ISC"
 		},
+		"node_modules/headers-polyfill": {
+			"version": "4.0.3",
+			"resolved": "https://registry.npmjs.org/headers-polyfill/-/headers-polyfill-4.0.3.tgz",
+			"integrity": "sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==",
+			"license": "MIT"
+		},
 		"node_modules/is-reference": {
 			"version": "3.0.3",
 			"resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
@@ -2673,6 +2700,17 @@
 				"node": ">=18.0.0"
 			}
 		},
+		"node_modules/miniflare/node_modules/undici": {
+			"version": "7.18.2",
+			"resolved": "https://registry.npmjs.org/undici/-/undici-7.18.2.tgz",
+			"integrity": "sha512-y+8YjDFzWdQlSE9N5nzKMT3g4a5UBX1HKowfdXh0uvAnTaqqwqB92Jt4UXBAeKekDs5IaDKyJFR4X1gYVCgXcw==",
+			"dev": true,
+			"license": "MIT",
+			"peer": true,
+			"engines": {
+				"node": ">=20.18.1"
+			}
+		},
 		"node_modules/mri": {
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
@@ -2712,6 +2750,18 @@
 				"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
 			}
 		},
+		"node_modules/object-inspect": {
+			"version": "1.13.4",
+			"resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+			"integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
 		"node_modules/obug": {
 			"version": "2.1.1",
 			"resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
@@ -2788,6 +2838,37 @@
 				"node": "^10 || ^12 || >=14"
 			}
 		},
+		"node_modules/prettier": {
+			"version": "3.8.3",
+			"resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.3.tgz",
+			"integrity": "sha512-7igPTM53cGHMW8xWuVTydi2KO233VFiTNyF5hLJqpilHfmn8C8gPf+PS7dUT64YcXFbiMGZxS9pCSxL/Dxm/Jw==",
+			"license": "MIT",
+			"bin": {
+				"prettier": "bin/prettier.cjs"
+			},
+			"engines": {
+				"node": ">=14"
+			},
+			"funding": {
+				"url": "https://github.com/prettier/prettier?sponsor=1"
+			}
+		},
+		"node_modules/pure-rand": {
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-7.0.1.tgz",
+			"integrity": "sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==",
+			"funding": [
+				{
+					"type": "individual",
+					"url": "https://github.com/sponsors/dubzzz"
+				},
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/fast-check"
+				}
+			],
+			"license": "MIT"
+		},
 		"node_modules/readdirp": {
 			"version": "4.1.2",
 			"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
@@ -2870,6 +2951,15 @@
 				"node": ">=6"
 			}
 		},
+		"node_modules/safe-stable-stringify": {
+			"version": "2.5.0",
+			"resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
+			"integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
 		"node_modules/semver": {
 			"version": "7.7.4",
 			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
@@ -2962,6 +3052,59 @@
 				"node": ">=0.10.0"
 			}
 		},
+		"node_modules/spacetimedb": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/spacetimedb/-/spacetimedb-2.3.0.tgz",
+			"integrity": "sha512-AleiQ+UkcgC9aRe0ArRRh77c8DI6lM2lBBw1wlVzlYpev6Aiem5aLiduPbACxyECrdwngfurDR211ZTmbh+etw==",
+			"license": "ISC",
+			"dependencies": {
+				"base64-js": "^1.5.1",
+				"headers-polyfill": "^4.0.3",
+				"object-inspect": "^1.13.4",
+				"prettier": "^3.3.3",
+				"pure-rand": "^7.0.1",
+				"safe-stable-stringify": "^2.5.0",
+				"statuses": "^2.0.2",
+				"url-polyfill": "^1.1.14"
+			},
+			"peerDependencies": {
+				"@angular/core": ">=17.0.0",
+				"@tanstack/react-query": "^5.0.0",
+				"react": "^18.0.0 || ^19.0.0-0 || ^19.0.0",
+				"svelte": "^4.0.0 || ^5.0.0",
+				"undici": "^6.19.2",
+				"vue": "^3.3.0"
+			},
+			"peerDependenciesMeta": {
+				"@angular/core": {
+					"optional": true
+				},
+				"@tanstack/react-query": {
+					"optional": true
+				},
+				"react": {
+					"optional": true
+				},
+				"svelte": {
+					"optional": true
+				},
+				"undici": {
+					"optional": true
+				},
+				"vue": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/statuses": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+			"integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
 		"node_modules/supports-color": {
 			"version": "10.2.2",
 			"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-10.2.2.tgz",
@@ -3099,14 +3242,14 @@
 			}
 		},
 		"node_modules/undici": {
-			"version": "7.18.2",
-			"resolved": "https://registry.npmjs.org/undici/-/undici-7.18.2.tgz",
-			"integrity": "sha512-y+8YjDFzWdQlSE9N5nzKMT3g4a5UBX1HKowfdXh0uvAnTaqqwqB92Jt4UXBAeKekDs5IaDKyJFR4X1gYVCgXcw==",
-			"dev": true,
+			"version": "6.26.0",
+			"resolved": "https://registry.npmjs.org/undici/-/undici-6.26.0.tgz",
+			"integrity": "sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==",
 			"license": "MIT",
+			"optional": true,
 			"peer": true,
 			"engines": {
-				"node": ">=20.18.1"
+				"node": ">=18.17"
 			}
 		},
 		"node_modules/unenv": {
@@ -3120,6 +3263,12 @@
 				"pathe": "^2.0.3"
 			}
 		},
+		"node_modules/url-polyfill": {
+			"version": "1.1.14",
+			"resolved": "https://registry.npmjs.org/url-polyfill/-/url-polyfill-1.1.14.tgz",
+			"integrity": "sha512-p4f3TTAG6ADVF3mwbXw7hGw+QJyw5CnNGvYh5fCuQQZIiuKUswqcznyV3pGDP9j0TSmC4UvRKm8kl1QsX1diiQ==",
+			"license": "MIT"
+		},
 		"node_modules/vite": {
 			"version": "7.3.1",
 			"resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
diff --git a/package.json b/package.json
index f4005c17..b55beb41 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
 		"@lucide/svelte": "^0.564.0",
 		"@types/leaflet.markercluster": "^1.5.6",
 		"leaflet": "^1.9.4",
-		"leaflet.markercluster": "^1.5.3"
+		"leaflet.markercluster": "^1.5.3",
+		"spacetimedb": "^2.3.0"
 	}
 }
diff --git a/src/app.html b/src/app.html
index 0994e653..fb417f32 100644
--- a/src/app.html
+++ b/src/app.html
@@ -4,10 +4,16 @@
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" />
 		<meta name="description" content="Game map for BitCraft Online" />
+<!-- this is basically useless anyway
 		<meta
 			http-equiv="Content-Security-Policy"
-			content="default-src 'self'; script-src 'self' 'unsafe-inline' https://static.cloudflareinsights.com; style-src 'self' 'unsafe-inline'; img-src 'self' https://exports.bitjita.com data:; connect-src 'self' https://bcmap-api.bitjita.com/ https://api.bitcraftmap.com/ https://api.github.com https://gist.githubusercontent.com https://exports.bitjita.com wss://live.bitjita.com/ https://cloudflareinsights.com; font-src 'self';"
+			content="default-src 'self';
+					 script-src 'self' 'unsafe-eval' 'unsafe-inline' https://static.cloudflareinsights.com;
+					 style-src 'self' 'unsafe-inline'; img-src 'self' https://exports.bitjita.com data:;
+					 connect-src 'self' https://bcmap-api.bitjita.com/ https://api.bitcraftmap.com/ https://api.github.com https://gist.githubusercontent.com https://exports.bitjita.com wss://live.bitjita.com/ https://cloudflareinsights.com;
+					 font-src 'self';"
 		/>
+-->
 		<link rel="icon" href="/favicon.svg" />
 		%sveltekit.head%
 	</head>
diff --git a/src/lib/components/map/MapContainer.svelte b/src/lib/components/map/MapContainer.svelte
index 923dfdef..17d15b09 100644
--- a/src/lib/components/map/MapContainer.svelte
+++ b/src/lib/components/map/MapContainer.svelte
@@ -1,95 +1,49 @@
 <script lang="ts">
-  import { SvelteSet } from "svelte/reactivity";
-  import { onMount, setContext } from "svelte";
-  import L from "leaflet";
-  import "leaflet/dist/leaflet.css";
-  import "leaflet.markercluster";
-  import { createMapConfig } from "$lib/config/map";
-  import { createAppConfig } from "$lib/config/api";
-  import { env } from "$env/dynamic/public";
-  import { setupDefaultIcon, createIcon } from "$lib/map/create-icon";
+  import {env} from "$env/dynamic/public";
+  import DetailPanel from "$lib/components/detail/DetailPanel.svelte";
+  import SearchBar from "$lib/components/search/SearchBar.svelte";
+  import Sidebar from "$lib/components/sidebar/Sidebar.svelte";
+  import {createAppConfig} from "$lib/config/api";
+  import {createMapConfig} from "$lib/config/map";
+  import {tierColors} from "$lib/config/tiers";
+  import {creatureIndex, resourceIndex, resourceIndexOverride,} from "$lib/data/resource-index";
+  import {formatCoordinates,} from "$lib/map/coordinate-utils";
+  import {setupDefaultIcon} from "$lib/map/create-icon";
   import {
     initIcons,
-    loadTreesGeoJson,
-    loadTemplesGeoJson,
-    loadRuinedGeoJson,
-    loadClaimsGeoJson,
     loadCavesGeoJson,
-    loadEventsGeoJson,
+    loadClaimsGeoJson,
     loadDungeonsGeoJson,
+    loadEventsGeoJson,
+    loadGeoJsonFromHash,
     loadGridsGeoJson,
+    loadRuinedGeoJson,
+    loadTemplesGeoJson,
     loadTowersGeoJson,
-    loadGeoJsonFromHash,
+    loadTreesGeoJson,
   } from "$lib/map/geojson-loader";
-  import { validateGeoJson } from "$lib/map/geojson-validator";
-  import { paintGeoJson, type PaintContext } from "$lib/map/geojson-painter";
-  import { ResourceCanvasLayer } from "$lib/map/resource-canvas-layer";
-  import { getLodEnabled } from "$lib/stores/settings-store.svelte";
-  import {
-    setMap,
-    saveMapState,
-    restoreMapState,
-    hashHasFlyToOrZoom,
-    resetView,
-  } from "$lib/stores/map-store";
-  import {
-    parseUrlParams,
-    updatePlayerIdParam,
-    updateResourceIdParam,
-    updateEnemyIdParam,
-    updateRegionIdParam,
-  } from "$lib/utils/url-params";
-  import { getRegionState, setRegions } from "$lib/stores/region-store.svelte";
-  import {
-    addSearchEntries,
-    type SearchEntry,
-  } from "$lib/stores/search-store.svelte";
-  import {
-    addTrackingItem,
-    toggleTrackingItem,
-    loadColorPreference,
-    registerColorSyncHandler,
-  } from "$lib/stores/tracking-store.svelte";
-  import { getLatestGistRaw } from "$lib/services/gist-service";
-  import { fetchResource, fetchEnemy } from "$lib/services/api-service";
-  import {
-    connectWebSocket,
-    type PlayerState,
-    setResourceEventCallback,
-    subscribeResource,
-    unsubscribeResource,
-    closeResourceWebSocket,
-  } from "$lib/services/websocket-service";
-  import {
-    handleResourceEvent,
-    cancelPendingRefetches,
-    cancelAllPendingRefetches,
-    type ResourceUpdateContext,
-  } from "$lib/services/resource-update-handler";
-  import { lookupPlayer } from "$lib/services/player-service";
-  import {
-    readableCoordinates,
-    formatCoordinates,
-  } from "$lib/map/coordinate-utils";
-  import {
-    resourceIndex,
-    resourceIndexOverride,
-    creatureIndex,
-  } from "$lib/data/resource-index";
-  import { tierColors } from "$lib/config/tiers";
-  import { filterUnique } from "$lib/utils/dedupe";
-
-  import MapImageLayer from "./MapImageLayer.svelte";
-  import HeatmapLayer from "./HeatmapLayer.svelte";
-  import RoadsLayer from "./RoadsLayer.svelte";
+  import {type PaintContext, paintGeoJson} from "$lib/map/geojson-painter";
+  import {validateGeoJson} from "$lib/map/geojson-validator";
+  import {buildPopupHtml} from "$lib/map/popup-builder";
+  import {ResourceCanvasLayer} from "$lib/map/resource-canvas-layer";
+  import {getLatestGistRaw} from "$lib/services/gist-service";
+  import {destroyRelayService, initRelayService, trackEntity, trackPlayer, untrackEntity, untrackPlayer, updateAllEntityRegions,} from "$lib/services/relay-service";
+  import {hashHasFlyToOrZoom, resetView, restoreMapState, saveMapState, setMap,} from "$lib/stores/map-store";
+  import {getRegionState, setRegions} from "$lib/stores/region-store.svelte";
+  import {addSearchEntries,} from "$lib/stores/search-store.svelte";
+  import {setSelection} from "$lib/stores/selection-store.svelte";
+  import {getLodEnabled} from "$lib/stores/settings-store.svelte";
+  import {addTrackingItem, loadColorPreference, registerColorSyncHandler,} from "$lib/stores/tracking-store.svelte";
+  import {filterUnique} from "$lib/utils/dedupe";
+  import {parseUrlParams, updateEnemyIdParam, updatePlayerIdParam, updateRegionIdParam, updateResourceIdParam,} from "$lib/utils/url-params";
+  import L from "leaflet";
+  import "leaflet/dist/leaflet.css";
+  import "leaflet.markercluster";
+  import {onMount, setContext} from "svelte";
+  import {SvelteSet} from "svelte/reactivity";
   import CoordinateDisplay from "./CoordinateDisplay.svelte";
-  import ResetViewButton from "./ResetViewButton.svelte";
   import GameTimers from "./GameTimers.svelte";
-  import { setSelection } from "$lib/stores/selection-store.svelte";
-  import { buildPopupHtml } from "$lib/map/popup-builder";
-  import SearchBar from "$lib/components/search/SearchBar.svelte";
-  import Sidebar from "$lib/components/sidebar/Sidebar.svelte";
-  import DetailPanel from "$lib/components/detail/DetailPanel.svelte";
+  import ResetViewButton from "./ResetViewButton.svelte";
 
   let mapElement: HTMLDivElement;
   let map = $state<L.Map>(undefined!);
@@ -119,6 +73,7 @@
   let allClaims: L.LayerGroup;
   let allCaves: L.LayerGroup;
   let resourceLayers: Record<number, ResourceCanvasLayer> = {};
+  let enemyLayers: Record<number, ResourceCanvasLayer> = {};
   let liveLayer: L.FeatureGroup;
   const isMobile =
     typeof window !== "undefined" &&
@@ -538,10 +493,13 @@
         .catch(console.error);
     }
 
+    // Initialise SpacetimeDB relay connection for entity (resource/enemy) tracking
+    initRelayService(appConfig, () => resourceLayers, () => enemyLayers, [...regionState.selected]);
+
     // Backend resource/enemy loading
     loadBackendData(urlParams, map).catch(console.error);
 
-    // WebSocket player tracking from URL params
+    // Relay player tracking from URL params
     if (urlParams.playerId) {
       const playerIds = urlParams.playerId
         .split(",")
@@ -554,57 +512,8 @@
           followingPlayerId = id;
         }
         trackedPlayerIds.add(id);
-      }
-
-      // Fetch player info once for initial markers + tracking items
-      const playerInfoPromise = Promise.all(
-        playerIds.map((id) => lookupPlayer(id)),
-      );
-
-      playerInfoPromise.then((results) => {
-        results.forEach((info, i) => {
-          playerUsernames.set(playerIds[i], info.username);
-          if (info.locationX !== null && info.locationZ !== null) {
-            updatePlayerMarker(
-              {
-                entity_id: playerIds[i],
-                location_x: info.locationX,
-                location_z: info.locationZ,
-                destination_x: info.locationX,
-                destination_z: info.locationZ,
-              },
-              followingPlayerId === playerIds[i],
-              loadColorPreference('player', playerIds[i]) || "#00ff00",
-            );
-          }
-        });
-      });
-
-      const ws = connectWebSocket(
-        playerIds,
-        (state: PlayerState) => {
-          updatePlayerMarker(state, followingPlayerId === state.entity_id, loadColorPreference('player', state.entity_id) || "#00ff00");
-        },
-        () => {
-          playerInfoPromise.then((results) => {
-            playerIds.forEach((id, i) => {
-              const savedColor = loadColorPreference('player', id);
-              addTrackingItem({
-                id: -1,
-                entityId: id,
-                type: "player",
-                text: `Player: ${results[i].username}`,
-                color: savedColor || "#00ff00",
-                visible: true,
-              });
-            });
-          });
-        },
-      );
-      if (ws) {
-        for (const id of playerIds) {
-          playerWebSockets.set(id, ws);
-        }
+        const color = loadColorPreference('player', id) || "#00ff00";
+        _subscribePlayer(id, color);
       }
     }
 
@@ -619,11 +528,6 @@
 
     mapReady = true;
 
-    // Wire up resource WebSocket event handler
-    setResourceEventCallback((event) => {
-      handleResourceEvent(event, resourceUpdateCtx);
-    });
-
     const unregisterColorSync = registerColorSyncHandler((type, id, color) => {
       if (type === 'player') {
         const marker = playerStore.get(id as string);
@@ -644,33 +548,22 @@
 
     return () => {
       unregisterColorSync();
-      for (const ws of playerWebSockets.values()) {
-        ws.close();
-      }
-      closeResourceWebSocket();
-      cancelAllPendingRefetches();
+      destroyRelayService();
       map.remove();
     };
   });
 
-  // Resource tracking state
+  // Resource/enemy tracking state
   const trackedResourceIds = new Set<number>();
   const trackedEnemyIds = new Set<number>();
 
-  const resourceUpdateCtx: ResourceUpdateContext = {
-    get resourceLayers() {
-      return resourceLayers;
-    },
-    getActiveRegions: () => regionState.effectiveRegions,
-  };
 
   // Player tracking state
   const playerStore = new Map<string, L.Marker>();
-  const destinationStore = new Map<string, L.Polyline>();
-  const playerWebSockets = new Map<string, WebSocket>();
+  // Mutable selection data kept per player so the click handler always has current values.
+  const playerSelectionDataStore = new Map<string, any>();
   const trackedPlayerIds = new Set<string>();
   let followingPlayerId = $state<string | null>(null);
-  const playerUsernames = new Map<string, string>();
 
   const playerColorPalette = [
     "#00ff00",
@@ -690,7 +583,6 @@
   ): Promise<void> {
     if (trackedPlayerIds.has(entityId)) return;
     trackedPlayerIds.add(entityId);
-    playerUsernames.set(entityId, username);
     updatePlayerIdParam(trackedPlayerIds);
 
     const paletteColor =
@@ -698,54 +590,42 @@
     playerColorIndex++;
     const color = loadColorPreference('player', entityId) || paletteColor;
 
-    // Fetch initial location from API
-    const playerInfo = await lookupPlayer(entityId);
-    if (playerInfo.locationX !== null && playerInfo.locationZ !== null) {
-      updatePlayerMarker(
-        {
-          entity_id: entityId,
-          location_x: playerInfo.locationX,
-          location_z: playerInfo.locationZ,
-          destination_x: playerInfo.locationX,
-          destination_z: playerInfo.locationZ,
-        },
-        followingPlayerId == entityId,
-        color,
-      );
-    }
+    _subscribePlayer(entityId, color);
+  }
 
-    const ws = connectWebSocket(
-      [entityId],
-      (state: PlayerState) => {
-        updatePlayerMarker(state, followingPlayerId == state.entity_id, loadColorPreference('player', entityId) || color);
-      },
-      () => {
+  /**
+   * Subscribe a player to the relay and wire up the update callback.
+   * Adds a tracking item on first data, then calls updatePlayerMarker on
+   * every subsequent state/location change.
+   */
+  function _subscribePlayer(entityId: string, color: string): void {
+    let trackingItemAdded = false;
+
+    trackPlayer(entityId, (id, name, online, x, z) => {
+      if (!trackingItemAdded) {
+        trackingItemAdded = true;
         addTrackingItem({
           id: -1,
-          entityId,
+          entityId: id,
           type: "player",
-          text: `Player: ${playerInfo.username}`,
+          text: `Player: ${name}`,
           color,
           visible: true,
         });
-      },
-    );
-
-    if (ws) {
-      playerWebSockets.set(entityId, ws);
-    }
+      }
+      if (x !== null && z !== null) {
+        updatePlayerMarker(id, name, online, x, z, followingPlayerId === id, color);
+      }
+    });
   }
 
   function handleTogglePlayerVisibility(entityId: string): void {
     const marker = playerStore.get(entityId);
-    const dest = destinationStore.get(entityId);
     if (marker) {
       if (liveLayer.hasLayer(marker)) {
         liveLayer.removeLayer(marker);
-        if (dest) liveLayer.removeLayer(dest);
       } else {
         liveLayer.addLayer(marker);
-        if (dest) liveLayer.addLayer(dest);
       }
     }
   }
@@ -761,41 +641,34 @@
   }
 
   function updatePlayerMarker(
-    state: PlayerState,
+    entityId: string,
+    name: string,
+    online: boolean,
+    x: number,
+    z: number,
     followPlayer: boolean,
     color = "#00ff00",
   ): void {
-    const playerId = state.entity_id;
-    const playerLatLng = L.latLng(
-      state.location_z / 1000,
-      state.location_x / 1000,
-    );
-    const destLatLng = L.latLng(
-      state.destination_z / 1000,
-      state.destination_x / 1000,
-    );
-    const directionLine: L.LatLngExpression[] = [playerLatLng, destLatLng];
+    const playerLatLng = L.latLng(z, x);
+    const existingMarker = playerStore.get(entityId);
 
-    const existingMarker = playerStore.get(playerId);
-    const existingDest = destinationStore.get(playerId);
-
-    if (!existingMarker || !existingDest) {
+    if (!existingMarker) {
       const icon = createPlayerIcon(color);
       const marker = L.marker(playerLatLng, {
         icon,
         pane: "markerOnTop",
       }).addTo(liveLayer);
-      const username = playerUsernames.get(playerId) ?? playerId;
       const selectionData = {
         type: "player" as const,
-        name: username,
-        entityId: playerId,
-        username,
-        signedIn: true,
+        name,
+        entityId,
+        username: name,
+        signedIn: online,
         latlng: { lat: playerLatLng.lat, lng: playerLatLng.lng },
         color,
-        isFollowing: followingPlayerId == playerId,
+        isFollowing: followingPlayerId == entityId,
       };
+      playerSelectionDataStore.set(entityId, selectionData);
       marker.bindPopup(buildPopupHtml(selectionData), {
         className: "bcm-leaflet-popup",
         pane: "popupOnTop",
@@ -805,23 +678,21 @@
           lat: marker.getLatLng().lat,
           lng: marker.getLatLng().lng,
         };
-        selectionData.isFollowing = followingPlayerId == playerId;
+        selectionData.isFollowing = followingPlayerId == entityId;
         setSelection(selectionData);
         marker.setPopupContent(buildPopupHtml(selectionData));
       });
 
-      const trail = new L.Polyline(directionLine, {
-        color: "#ff0000ff",
-        weight: 1,
-        opacity: 1,
-        smoothFactor: 1,
-      }).addTo(liveLayer);
-
-      playerStore.set(playerId, marker);
-      destinationStore.set(playerId, trail);
+      playerStore.set(entityId, marker);
     } else {
       existingMarker.setLatLng(playerLatLng);
-      existingDest.setLatLngs(directionLine);
+      // Keep selectionData in sync for clicks after state changes
+      const selectionData = playerSelectionDataStore.get(entityId);
+      if (selectionData) {
+        selectionData.name = name;
+        selectionData.username = name;
+        selectionData.signedIn = online;
+      }
     }
 
     if (followPlayer) {
@@ -854,29 +725,8 @@
       visible: true,
     });
 
-    try {
-      const regions = regionState.effectiveRegions;
-      const results = await Promise.all(
-        regions.map((rId) => fetchResource(rId, resourceId)),
-      );
-
-      regions.forEach((rId, idx) => {
-        const geoJson = results[idx];
-        if (
-          geoJson.features[0]?.geometry &&
-          (geoJson.features[0].geometry as GeoJSON.MultiPoint).coordinates
-            ?.length > 0
-        ) {
-          const coords = (geoJson.features[0].geometry as GeoJSON.MultiPoint)
-            .coordinates;
-          canvasLayer.setRegionPoints(rId, coords as [number, number][]);
-        }
-      });
-
-      subscribeResource(resourceId);
-    } catch (err) {
-      console.error(`Failed to load resource ${resourceId}:`, err);
-    }
+    // Subscribe via SpacetimeDB relay; initial data arrives via onApplied callback.
+    trackEntity(resourceId, 'resource');
   }
 
   async function handleCreatureSelect(
@@ -884,7 +734,7 @@
     name: string,
     tier: number,
   ): Promise<void> {
-    if (resourceLayers[enemyId]) return; // already loaded
+    if (enemyLayers[enemyId]) return; // already loaded
 
     trackedEnemyIds.add(enemyId);
     updateEnemyIdParam(trackedEnemyIds);
@@ -892,7 +742,7 @@
     const color = loadColorPreference('enemy', enemyId) ||
       creatureIndex[enemyId]?.color || tierColors[tier] || "#3388ff";
     const canvasLayer = new ResourceCanvasLayer({ color, name, tier, id: enemyId });
-    resourceLayers[enemyId] = canvasLayer;
+    enemyLayers[enemyId] = canvasLayer;
     canvasLayer.addTo(map);
     canvasLayer.setLodEnabled(getLodEnabled());
 
@@ -904,27 +754,8 @@
       visible: true,
     });
 
-    try {
-      const regions = regionState.effectiveRegions;
-      const results = await Promise.all(
-        regions.map((rId) => fetchEnemy(rId, enemyId)),
-      );
-
-      regions.forEach((rId, idx) => {
-        const geoJson = results[idx];
-        if (
-          geoJson.features[0]?.geometry &&
-          (geoJson.features[0].geometry as GeoJSON.MultiPoint).coordinates
-            ?.length > 0
-        ) {
-          const coords = (geoJson.features[0].geometry as GeoJSON.MultiPoint)
-            .coordinates;
-          canvasLayer.setRegionPoints(rId, coords as [number, number][]);
-        }
-      });
-    } catch (err) {
-      console.error(`Failed to load creature ${enemyId}:`, err);
-    }
+    // Subscribe via SpacetimeDB relay; initial data arrives via onApplied callback.
+    trackEntity(enemyId, 'enemy');
   }
 
   async function loadBackendData(
@@ -939,8 +770,6 @@
 
     if (!resourceParam && !enemyParam) return;
 
-    const regionIds = regionState.effectiveRegions;
-
     let resourceIds: number[] = [];
     if (resourceParam) {
       if (!/^([0-9]\d*)(,([0-9]\d*))*$/.test(resourceParam)) return;
@@ -954,14 +783,11 @@
     if (enemyParam) {
       if (!/^([0-9]\d*)(,([0-9]\d*))*$/.test(enemyParam)) return;
       enemyIds = [...new Set(enemyParam.split(",").map(Number))];
+      for (const id of enemyIds) {
+        trackedEnemyIds.add(id);
+      }
     }
 
-    const fetchPromises: Promise<GeoJSON.FeatureCollection>[] = [];
-    const geoJsonMeta: {
-      region: number;
-      fillColor: string;
-      resource: number;
-    }[] = [];
     let trackingList: { text: string; color: string; id: number; type: 'resource' | 'enemy' }[] = [];
 
     for (const id of resourceIds) {
@@ -977,7 +803,14 @@
       resourceLayers[id] = new ResourceCanvasLayer({ color, name, tier, id });
       resourceLayers[id].addTo(map);
       resourceLayers[id].setLodEnabled(getLodEnabled());
+      trackingList.push({
+        text: "Tracking: " + name + ", Tier " + tier,
+        color,
+        id,
+        type: 'resource',
+      });
     }
+
     for (const id of enemyIds) {
       let color = loadColorPreference('enemy', id) ||
         creatureIndex[id]?.color ||
@@ -986,49 +819,15 @@
       if (noColors) color = "#3388ff";
       const tier = creatureIndex[id]?.tier || 0;
       const name = creatureIndex[id]?.name || "ID " + id;
-      resourceLayers[id] = new ResourceCanvasLayer({ color, name, tier, id });
-      resourceLayers[id].addTo(map);
-      resourceLayers[id].setLodEnabled(getLodEnabled());
-    }
-
-    for (const rId of regionIds) {
-      for (const resId of resourceIds) {
-        let color = loadColorPreference('resource', resId) ||
-          resourceIndexOverride[resId]?.color ||
-          tierColors[resourceIndexOverride[resId]?.tier] ||
-          resourceIndex[resId]?.color ||
-          tierColors[resourceIndex[resId]?.tier] ||
-          "#3388ff";
-        if (noColors) color = "#3388ff";
-        const tier =
-          resourceIndexOverride[resId]?.tier || resourceIndex[resId]?.tier || 0;
-        const name = resourceIndex[resId]?.name || "ID " + resId;
-        geoJsonMeta.push({ region: rId, fillColor: color, resource: resId });
-        fetchPromises.push(fetchResource(rId, resId));
-        trackingList.push({
-          text: "Tracking: " + name + ", Tier " + tier,
-          color,
-          id: resId,
-          type: 'resource',
-        });
-      }
-      for (const eId of enemyIds) {
-        let color = loadColorPreference('enemy', eId) ||
-          creatureIndex[eId]?.color ||
-          tierColors[creatureIndex[eId]?.tier] ||
-          "#3388ff";
-        if (noColors) color = "#3388ff";
-        const tier = creatureIndex[eId]?.tier || 0;
-        const name = creatureIndex[eId]?.name || "ID " + eId;
-        geoJsonMeta.push({ region: rId, fillColor: color, resource: eId });
-        fetchPromises.push(fetchEnemy(rId, eId));
-        trackingList.push({
-          text: "Tracking: " + name + ", Tier " + tier,
-          color,
-          id: eId,
-          type: 'enemy',
-        });
-      }
+      enemyLayers[id] = new ResourceCanvasLayer({ color, name, tier, id });
+      enemyLayers[id].addTo(map);
+      enemyLayers[id].setLodEnabled(getLodEnabled());
+      trackingList.push({
+        text: "Tracking: " + name + ", Tier " + tier,
+        color,
+        id,
+        type: 'enemy',
+      });
     }
 
     trackingList = filterUnique(trackingList);
@@ -1042,31 +841,13 @@
       });
     }
 
-    if (fetchPromises.length === 0) return;
-    const geoJsonResults = await Promise.all(fetchPromises);
-
-    geoJsonResults.forEach((geoJson, idx) => {
-      if (
-        geoJson.features[0]?.geometry &&
-        (geoJson.features[0].geometry as GeoJSON.MultiPoint).coordinates
-          ?.length > 0
-      ) {
-        const meta = geoJsonMeta[idx];
-        const coords = (geoJson.features[0].geometry as GeoJSON.MultiPoint)
-          .coordinates;
-        const canvasLayer = resourceLayers[meta.resource];
-        if (canvasLayer) {
-          canvasLayer.setRegionPoints(
-            meta.region,
-            coords as [number, number][],
-          );
-        }
-      }
-    });
-
-    // Subscribe to resource WebSocket channels
+    // Subscribe all entities via the SpacetimeDB relay. Initial data will
+    // arrive via each subscription's onApplied callback.
     for (const id of resourceIds) {
-      subscribeResource(id);
+      trackEntity(id, 'resource');
+    }
+    for (const id of enemyIds) {
+      trackEntity(id, 'enemy');
     }
   }
 
@@ -1083,8 +864,8 @@
     saveActiveLayers();
   }
 
-  function handleToggleResourceLayer(id: number): void {
-    const layer = resourceLayers[id];
+  function handleToggleResourceLayer(id: number, type: 'enemy' | 'resource'): void {
+    const layer = type === 'resource' ? resourceLayers[id] : enemyLayers[id];
     if (!layer || !map) return;
     if (map.hasLayer(layer)) {
       map.removeLayer(layer);
@@ -1093,76 +874,41 @@
     }
   }
 
-  function handleRemoveResource(id: number): void {
-    const layer = resourceLayers[id];
+  function handleRemoveResource(id: number, type: 'enemy' | 'resource'): void {
+    const layer = type === 'resource' ? resourceLayers[id] : enemyLayers[id];
     if (layer) {
       layer.remove();
-      delete resourceLayers[id];
+      if (type === 'resource') {
+        delete resourceLayers[id];
+      } else {
+        delete enemyLayers[id];
+      }
     }
-    trackedResourceIds.delete(id);
-    updateResourceIdParam(trackedResourceIds);
-    cancelPendingRefetches(id);
-    unsubscribeResource(id);
+    if (type === 'resource' && trackedResourceIds.has(id)) {
+      trackedResourceIds.delete(id);
+      updateResourceIdParam(trackedResourceIds);
+    } else if (type === 'enemy' && trackedEnemyIds.has(id)) {
+      trackedEnemyIds.delete(id);
+      updateEnemyIdParam(trackedEnemyIds);
+    }
+    untrackEntity(id, type);
   }
 
   function handleRemovePlayer(entityId: string): void {
-    // Remove markers
     const marker = playerStore.get(entityId);
-    const dest = destinationStore.get(entityId);
     if (marker) liveLayer.removeLayer(marker);
-    if (dest) liveLayer.removeLayer(dest);
     playerStore.delete(entityId);
-    destinationStore.delete(entityId);
-    playerUsernames.delete(entityId);
-
-    // Close WebSocket
-    const ws = playerWebSockets.get(entityId);
-    if (ws) {
-      ws.close();
-      playerWebSockets.delete(entityId);
-    }
+    playerSelectionDataStore.delete(entityId);
+    untrackPlayer(entityId);
     trackedPlayerIds.delete(entityId);
     updatePlayerIdParam(trackedPlayerIds);
   }
 
   function handleRegionsChange(): void {
     updateRegionIdParam(regionState.selected);
-
-    const currentTrackedIds = [...trackedResourceIds];
-    if (currentTrackedIds.length === 0) return;
-
-    cancelAllPendingRefetches();
-
-    // Clear all region data from canvas layers
-    for (const id of currentTrackedIds) {
-      const layer = resourceLayers[id];
-      if (layer) layer.clearAllRegions();
-    }
-
-    const regions = regionState.effectiveRegions;
-    for (const resourceId of currentTrackedIds) {
-      Promise.all(regions.map((rId) => fetchResource(rId, resourceId)))
-        .then((results) => {
-          const canvasLayer = resourceLayers[resourceId];
-          if (!canvasLayer) return;
-          regions.forEach((rId, idx) => {
-            const geoJson = results[idx];
-            if (
-              geoJson.features[0]?.geometry &&
-              (geoJson.features[0].geometry as GeoJSON.MultiPoint).coordinates
-                ?.length > 0
-            ) {
-              const coords = (
-                geoJson.features[0].geometry as GeoJSON.MultiPoint
-              ).coordinates;
-              canvasLayer.setRegionPoints(rId, coords as [number, number][]);
-            }
-          });
-        })
-        .catch((err) =>
-          console.error(`Failed to reload resource ${resourceId}:`, err),
-        );
-    }
+    // Delegate to the relay service: it will create new subscriptions with the
+    // updated region filter and drop the old ones after the server delta arrives.
+    updateAllEntityRegions([...regionState.selected]);
   }
 
   function isLayerActive(name: string): boolean {
diff --git a/src/lib/components/settings/SettingsPanel.svelte b/src/lib/components/settings/SettingsPanel.svelte
index 02a1ef15..9d7749a8 100644
--- a/src/lib/components/settings/SettingsPanel.svelte
+++ b/src/lib/components/settings/SettingsPanel.svelte
@@ -36,7 +36,7 @@
 		if (type === 'player') {
 			updateTrackingItemColorByEntityId(id, color);
 		} else {
-			updateTrackingItemColor(Number(id), color);
+			updateTrackingItemColor(Number(id), type, color);
 		}
 		refresh();
 	}
diff --git a/src/lib/components/sidebar/Sidebar.svelte b/src/lib/components/sidebar/Sidebar.svelte
index 3a56b71c..4bd07f85 100644
--- a/src/lib/components/sidebar/Sidebar.svelte
+++ b/src/lib/components/sidebar/Sidebar.svelte
@@ -27,9 +27,9 @@
 		onToggleLayer: (name: string) => void;
 		getBaseLayer: () => 'terrain' | 'game';
 		onSetBaseLayer: (layer: "terrain" | "game") => void;
-		onToggleResource: (id: number) => void;
+		onToggleResource: (id: number, type: 'enemy' | 'resource') => void;
 		onTogglePlayer: (entityId: string) => void;
-		onRemoveResource: (id: number) => void;
+		onRemoveResource: (id: number, type: 'enemy' | 'resource') => void;
 		onRemovePlayer: (entityId: string) => void;
 		onRegionsChange: () => void;
 	} = $props();
diff --git a/src/lib/components/tracking/TrackingPanel.svelte b/src/lib/components/tracking/TrackingPanel.svelte
index 2ed93d58..bc58cf10 100644
--- a/src/lib/components/tracking/TrackingPanel.svelte
+++ b/src/lib/components/tracking/TrackingPanel.svelte
@@ -8,9 +8,9 @@
 		onRemoveResource,
 		onRemovePlayer,
 	}: {
-		onToggleResource: (id: number) => void;
+		onToggleResource: (id: number, type: 'enemy' | 'resource') => void;
 		onTogglePlayer: (entityId: string) => void;
-		onRemoveResource: (id: number) => void;
+		onRemoveResource: (id: number, type: 'enemy' | 'resource') => void;
 		onRemovePlayer: (entityId: string) => void;
 	} = $props();
 
@@ -19,32 +19,32 @@
 
 {#if tracking.items.length > 0}
 	<div class="space-y-1">
-		{#each tracking.items as item (item.entityId ?? item.id)}
+		{#each tracking.items as item (item.entityId ?? (item.type + ":" + item.id))}
 			<TrackingItem
 				{item}
 				onToggle={() => {
 					if (item.type === 'player' && item.entityId) {
 						toggleTrackingItemByEntityId(item.entityId);
 						onTogglePlayer(item.entityId);
-					} else {
-						toggleTrackingItem(item.id);
-						if (item.id !== -1) onToggleResource(item.id);
+					} else if (item.type === 'resource' || item.type === 'enemy') {
+						toggleTrackingItem(item.id, item.type);
+						if (item.id !== -1) onToggleResource(item.id, item.type);
 					}
 				}}
 				onRemove={() => {
 					if (item.type === 'player' && item.entityId) {
 						removeTrackingItemByEntityId(item.entityId);
 						onRemovePlayer(item.entityId);
-					} else {
-						removeTrackingItem(item.id);
-						onRemoveResource(item.id);
+					} else if (item.type === 'resource' || item.type === 'enemy') {
+						removeTrackingItem(item.id, item.type);
+						onRemoveResource(item.id, item.type);
 					}
 				}}
 				onColorChange={(color) => {
 					if (item.type === 'player' && item.entityId) {
 						updateTrackingItemColorByEntityId(item.entityId, color);
-					} else {
-						updateTrackingItemColor(item.id, color);
+					} else if (item.type === 'resource' || item.type === 'enemy') {
+						updateTrackingItemColor(item.id, item.type, color);
 					}
 				}}
 			/>
diff --git a/src/lib/config/api.ts b/src/lib/config/api.ts
index b622a410..fa5e1025 100644
--- a/src/lib/config/api.ts
+++ b/src/lib/config/api.ts
@@ -3,9 +3,9 @@ import { env } from "$env/dynamic/public";
 
 export function createAppConfig(): AppConfig {
   return {
-    backendUrl: env.PUBLIC_BACKEND_URL ?? "https://bcmap-api.bitjita.com",
     gistApi: "https://api.github.com/gists/",
-    websocketUrl: env.PUBLIC_WEBSOCKET_URL ?? "wss://live.bitjita.com",
     exportsCdn: env.PUBLIC_EXPORTS_CDN ?? "https://exports.bitjita.com/bitcraftmap",
+    relayHost: env.PUBLIC_RELAY_HOST ?? "https://maincloud.spacetimedb.com", // STDB SDK converts this to ws/wss for us
+    relayModule: env.PUBLIC_RELAY_MODULE ?? "prism-relay",
   };
 }
diff --git a/src/lib/map/resource-canvas-layer.ts b/src/lib/map/resource-canvas-layer.ts
index dd3250f3..cfb189ca 100644
--- a/src/lib/map/resource-canvas-layer.ts
+++ b/src/lib/map/resource-canvas-layer.ts
@@ -71,7 +71,7 @@ export class ResourceCanvasLayer extends L.Layer {
 		map.on('moveend', this._onMoveEnd, this);
 		map.on('click', this._onClick, this);
 
-		this._reset();
+		this._reset(true);
 		return this;
 	}
 
@@ -143,7 +143,7 @@ export class ResourceCanvasLayer extends L.Layer {
 		this._reset();
 	}
 
-	private _reset(): void {
+	private _reset(force: boolean = false): void {
 		if (!this._map) return;
 
 		const size = this._map.getSize();
@@ -154,7 +154,7 @@ export class ResourceCanvasLayer extends L.Layer {
 		// Check cache BEFORE clearing — canvas.width = x clears even if unchanged
 		const p0 = this._map.latLngToContainerPoint([0, 0]);
 		const key = `${Math.round(p0.x)},${Math.round(p0.y)},${size.x},${size.y}`;
-		if (key === this._lastBoundsKey) return;
+		if (!force && key === this._lastBoundsKey) return;
 		this._lastBoundsKey = key;
 
 		// Only resize when the container size changes; _redraw() handles clearing
diff --git a/src/lib/services/player-service.ts b/src/lib/services/player-service.ts
index 45f127a4..50c1702a 100644
--- a/src/lib/services/player-service.ts
+++ b/src/lib/services/player-service.ts
@@ -1,29 +1,5 @@
-import type { PlayerSearchResult, PlayerSearchResponse } from '$lib/types/geojson';
-
-export interface PlayerLookupResult {
-	username: string;
-	locationX: number | null;
-	locationZ: number | null;
-}
-
-export async function lookupPlayer(entityId: string): Promise<PlayerLookupResult> {
-	try {
-		const response = await fetch(`/api/players/${entityId}`);
-		if (!response.ok) return { username: entityId, locationX: null, locationZ: null };
-		const data = await response.json();
-		const player = data.player;
-		// TODO initial bitjita fetch returns small hex tile coords, but mobile entity state uses float hex tile * 1000
-		const locationX = player?.locationX ? player.locationX * 1000 : null;
-		const locationZ = player?.locationZ ? player.locationZ * 1000 : null;
-		return {
-			username: player?.username || entityId,
-			locationX: locationX,
-			locationZ: locationZ
-		};
-	} catch {
-		return { username: entityId, locationX: null, locationZ: null };
-	}
-}
+import type { PlayerSearchResult } from '$lib/types/geojson';
+import { createAppConfig } from '$lib/config/api';
 
 let abortController: AbortController | null = null;
 
@@ -38,16 +14,15 @@ export async function searchPlayers(query: string): Promise<PlayerSearchResult[]
 
 	abortController = new AbortController();
 
+	const config = createAppConfig();
+	const url = `${config.relayHost}/v1/database/${config.relayModule}/route/players?q=${encodeURIComponent(query.trim())}`;
+
 	try {
-		const response = await fetch(
-			`/api/players?q=${encodeURIComponent(query.trim())}`,
-			{ signal: abortController.signal }
-		);
+		const response = await fetch(url, { signal: abortController.signal });
 
 		if (!response.ok) return [];
 
-		const data: PlayerSearchResponse = await response.json();
-		return data.players;
+		return await response.json() as PlayerSearchResult[];
 	} catch (err) {
 		if (err instanceof DOMException && err.name === 'AbortError') {
 			return [];
diff --git a/src/lib/services/relay-service.ts b/src/lib/services/relay-service.ts
new file mode 100644
index 00000000..af380ae4
--- /dev/null
+++ b/src/lib/services/relay-service.ts
@@ -0,0 +1,732 @@
+/**
+ * relay-service.ts
+ *
+ * Manages the SpacetimeDB relay connection for tracking resource and enemy
+ * entity locations on the map.
+ *
+ * Connection lifecycle
+ * --------------------
+ * The builder is created once (initRelayService). build() is called only when
+ * at least one entity is being tracked. When all entities are removed the
+ * connection is cleanly disconnected. If the connection drops unexpectedly
+ * (error) while entities are still tracked it is automatically re-established.
+ * On planned teardown (destroyRelayService / last entity removed) reconnection
+ * is suppressed.
+ *
+ * Each reconnect re-registers all table callbacks and recreates every active
+ * subscription from scratch.
+ *
+ * Subscriptions
+ * -------------
+ * Each tracked entity has its own SubscriptionHandle (returned by
+ * subscriptionBuilder().subscribe(queries)). For a single region filter an
+ * array with one typed query is used; for multiple regions the array contains
+ * one query per region (SpacetimeDB merges them as a UNION in the client
+ * cache). The typed query builders from the relay-bindings are used — no raw
+ * SQL strings.
+ *
+ * Initial population vs real-time updates
+ * ----------------------------------------
+ * When the subscription's onApplied fires the canvas layer is bulk-populated
+ * from the local client cache in one pass (O(n)). Individual row callbacks
+ * (onInsert / onDelete / onUpdate) are ignored until initialLoadComplete is
+ * true so the initial burst of inserts doesn't cause O(n²) cache iterations.
+ * After that each callback rebuilds only the single affected region.
+ *
+ * Region changes
+ * --------------
+ * A new subscription is made first; the old one is unsubscribed inside the
+ * new subscription's onApplied so the server sends us only the delta.
+ */
+
+import type {ResourceCanvasLayer} from '$lib/map/resource-canvas-layer';
+import type {AppConfig} from '$lib/types/map';
+import type {RowTypedQuery} from 'spacetimedb';
+import {DbConnection, DbConnectionBuilder, type ErrorContext, type EventContext, type SubscriptionHandle, tables,} from '../../relay-bindings';
+import type {EnemyLocation, PlayerLocation, PlayerState, ResourceLocation} from '../../relay-bindings/types';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type EntityType = 'resource' | 'enemy';
+
+interface TrackedEntity {
+	type: EntityType;
+	subscription: SubscriptionHandle | null;
+}
+
+/**
+ * Called whenever a tracked player's state or location changes.
+ * x and z are already divided by 1000 (map coordinates). Both are null if the
+ * player has no location row (e.g. offline / not yet loaded).
+ */
+export type PlayerUpdateCallback = (
+	entityId: string,
+	name: string,
+	online: boolean,
+	x: number | null,
+	z: number | null,
+) => void;
+
+interface TrackedPlayer {
+	callback: PlayerUpdateCallback;
+	subscription: SubscriptionHandle | null;
+}
+
+// ---------------------------------------------------------------------------
+// Module-level singleton state
+// ---------------------------------------------------------------------------
+
+let builder: DbConnectionBuilder | null = null;
+let connection: DbConnection | null = null;
+let isConnecting = false;
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let regionChangeTimer: ReturnType<typeof setTimeout> | null = null;
+
+const RECONNECT_DELAY_MS = 5_000;
+const REBUILD_DEBOUNCE_MS = 500;
+
+// Dirty tracking for batched rebuilds
+const dirtyResourceRegions = new Set<string>();
+const dirtyEnemyRegions = new Set<string>();
+let rebuildTimer: ReturnType<typeof setTimeout> | null = null;
+
+class TrackedEntities {
+	resources = new Map<number, TrackedEntity>();
+	enemies = new Map<number, TrackedEntity>();
+	size() {
+		return this.resources.size + this.enemies.size;
+	}
+	* entries() {
+		yield* this.resources.entries();
+		yield* this.enemies.entries();
+	}
+	* values() {
+		yield* this.resources.values();
+		yield* this.enemies.values();
+	}
+	clear() {
+		this.resources.clear();
+		this.enemies.clear();
+	}
+	has(id: number, type: EntityType) {
+		if (type === 'resource') {
+			return this.resources.has(id);
+		} else {
+			return this.enemies.has(id);
+		}
+	}
+	get(id: number, type: EntityType) {
+		if (type === 'resource') {
+			return this.resources.get(id);
+		} else {
+			return this.enemies.get(id);
+		}
+	}
+	set(id: number, type: EntityType, value: TrackedEntity) {
+		if (type === 'resource') {
+			return this.resources.set(id, value);
+		} else {
+			return this.enemies.set(id, value);
+		}
+	}
+	delete(id: number, type: EntityType) {
+		if (type === 'resource') {
+			return this.resources.delete(id);
+		} else {
+			return this.enemies.delete(id);
+		}
+	}
+}
+
+const trackedEntities = new TrackedEntities();
+const trackedPlayers = new Map<string, TrackedPlayer>();
+let resourceAccessor: () => Record<number, ResourceCanvasLayer>;
+let enemyAccessor: () => Record<number, ResourceCanvasLayer>;
+let regions: number[] = [];
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Initialize the relay service. Creates and stores the connection builder but
+ * does NOT open a connection yet — that happens lazily when the first entity
+ * is tracked.
+ */
+export function initRelayService(
+	config: AppConfig,
+	getResourceLayersFn: () => Record<number, ResourceCanvasLayer>,
+	getEnemyLayersFn: () => Record<number, ResourceCanvasLayer>,
+	initialRegions: number[]
+): void {
+	if (builder) {
+		console.warn('[Relay] Already initialised – ignoring duplicate call');
+		return;
+	}
+
+	resourceAccessor = getResourceLayersFn;
+	enemyAccessor = getEnemyLayersFn;
+	regions = initialRegions;
+
+	const tokenKey = `prism:${config.relayHost}/${config.relayModule}/auth_token`;
+
+	// Build the builder once. onConnect / onDisconnect / onConnectError are
+	// registered here; they carry through to every connection opened via build().
+	builder = DbConnection.builder()
+		.withUri(config.relayHost)
+		.withDatabaseName(config.relayModule)
+		.withToken(localStorage.getItem(tokenKey) ?? undefined)
+		.onConnect((conn, identity, token) => {
+			isConnecting = false;
+			localStorage.setItem(tokenKey, token);
+			console.log('[Relay] Connected, identity:', identity.toHexString());
+
+			// Register table-level row callbacks on this connection instance.
+			conn.db.resource_location.onInsert(handleResourceInsert);
+			conn.db.resource_location.onDelete(handleResourceDelete);
+			conn.db.resource_location.onUpdate(handleResourceUpdate);
+			conn.db.enemy_location.onInsert(handleEnemyInsert);
+			conn.db.enemy_location.onDelete(handleEnemyDelete);
+			conn.db.enemy_location.onUpdate(handleEnemyUpdate);
+			conn.db.player_state.onInsert(handlePlayerStateInsert);
+			conn.db.player_state.onUpdate(handlePlayerStateUpdate);
+			// leave the frontend stale, they'll probably re-appear in another region soon
+			// conn.db.player_state.onDelete(handlePlayerStateDelete);
+			conn.db.player_location.onInsert(handlePlayerLocationInsert);
+			conn.db.player_location.onUpdate(handlePlayerLocationUpdate);
+			conn.db.player_location.onDelete(handlePlayerLocationDelete);
+
+			// Recreate subscriptions for all already-tracked entities.
+			for (const [id, entity] of trackedEntities.entries()) {
+				entity.subscription = _createSubscription(conn, id, entity);
+			}
+			for (const [entityId, player] of trackedPlayers.entries()) {
+				player.subscription = _createPlayerSubscription(conn, entityId);
+			}
+		})
+		.onDisconnect((ctx: ErrorContext) => {
+			isConnecting = false;
+			connection = null;
+			for (const entity of trackedEntities.values()) {
+				entity.subscription = null;
+			}
+			for (const player of trackedPlayers.values()) {
+				player.subscription = null;
+			}
+
+			if (ctx.event) {
+				console.log("[Relay] Disconnected abnormally:", ctx.event)
+				if (trackedEntities.size() || trackedPlayers.size) {
+					console.log("[Relay] Attempting to reconnect in", RECONNECT_DELAY_MS, 'ms...')
+					reconnectTimer = setTimeout(_connect, RECONNECT_DELAY_MS);
+				}
+			} else {
+				console.log("[Relay] Disconnected.")
+			}
+		})
+		.onConnectError((ctx: ErrorContext) => {
+			isConnecting = false;
+			if (ctx.event) {
+				console.error('[Relay] Connection error:', ctx.event);
+			}
+			if (trackedEntities.size() === 0 && trackedPlayers.size === 0) return;
+			console.warn('[Relay] Attempting to reconnect in', RECONNECT_DELAY_MS, 'ms...');
+			reconnectTimer = setTimeout(_connect, RECONNECT_DELAY_MS);
+		});
+}
+
+/**
+ * Disconnect from the relay, suppress auto-reconnect, and reset all state.
+ * Call from MapContainer's onMount cleanup function.
+ */
+export function destroyRelayService(): void {
+	_disconnect();
+	if (rebuildTimer !== null) {
+		clearTimeout(rebuildTimer);
+		rebuildTimer = null;
+	}
+	if (regionChangeTimer !== null) {
+		clearTimeout(regionChangeTimer);
+		regionChangeTimer = null;
+	}
+	dirtyResourceRegions.clear();
+	dirtyEnemyRegions.clear();
+	trackedEntities.clear();
+	for (const player of trackedPlayers.values()) {
+		player.subscription?.unsubscribe();
+	}
+	trackedPlayers.clear();
+	builder = null;
+	resourceAccessor = () => ({});
+	enemyAccessor = () => ({});
+}
+
+/**
+ * Begin tracking an entity. Creates a SpacetimeDB subscription filtered to
+ * the given entity ID and region list. Opens the connection if needed.
+ *
+ * The canvas layer must already be registered in the map returned by
+ * getLayers() before this is called (onApplied needs to find it).
+ */
+export function trackEntity(
+	id: number,
+	type: EntityType,
+): void {
+	if (trackedEntities.has(id, type)) return;
+
+	const entity: TrackedEntity = {
+		type,
+		subscription: null,
+	};
+	trackedEntities.set(id, type, entity);
+
+	if (!connection?.isActive) {
+		// Not connected — connect now; onConnect will create the subscription.
+		_connect();
+	} else {
+		entity.subscription = _createSubscription(connection, id, entity);
+	}
+}
+
+/**
+ * Stop tracking an entity. Unsubscribes and clears the canvas layer.
+ * Disconnects from the relay when no entities remain.
+ */
+export function untrackEntity(id: number, type: 'enemy' | 'resource'): void {
+	const entity = trackedEntities.get(id, type);
+	if (!entity) return;
+
+	entity.subscription?.unsubscribe();
+	trackedEntities.delete(id, type);
+
+	// Drop the connection when nothing left to track.
+	if (trackedEntities.size() === 0 && trackedPlayers.size === 0) {
+		_disconnect();
+	}
+}
+
+/**
+ * Update the tracked region set for every currently-tracked entity.
+ * Creates a new subscription first; the old one is dropped only after the new
+ * subscription's onApplied fires so the server computes the minimal delta.
+ */
+export function updateAllEntityRegions(newRegions: number[]): void {
+	if (!connection?.isActive) {
+		regions = newRegions;
+		return;
+	}
+
+	// we throttle this so that rapidly toggling regions on/off in the panel doesn't cause
+	// high subscription volume. all subscriptions will be re-sent once the user makes up their mind.
+	function _update(_new: number[]) {
+		if (!connection?.isActive) return;
+		regions = newRegions;
+		for (const [id, entity] of trackedEntities.entries()) {
+			_updateEntityRegions(connection, id, entity);
+		}
+	}
+	if (regionChangeTimer !== null) {
+		clearTimeout(regionChangeTimer);
+	}
+	regionChangeTimer = setTimeout(_update, 1500, newRegions);
+}
+
+/**
+ * Begin tracking a player. Subscribes to player_state and player_location for
+ * the given entity ID. The callback is invoked on initial population and on
+ * every subsequent state or location change.
+ */
+export function trackPlayer(entityId: string, callback: PlayerUpdateCallback): void {
+	if (trackedPlayers.has(entityId)) return;
+
+	const player: TrackedPlayer = { callback, subscription: null };
+	trackedPlayers.set(entityId, player);
+
+	if (!connection?.isActive) {
+		_connect();
+	} else {
+		player.subscription = _createPlayerSubscription(connection, entityId);
+	}
+}
+
+/**
+ * Stop tracking a player. Unsubscribes and removes from the tracked set.
+ * Disconnects from the relay when no entities or players remain.
+ */
+export function untrackPlayer(entityId: string): void {
+	const player = trackedPlayers.get(entityId);
+	if (!player) return;
+
+	player.subscription?.unsubscribe();
+	trackedPlayers.delete(entityId);
+
+	if (trackedEntities.size() === 0 && trackedPlayers.size === 0) {
+		_disconnect();
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Connection management
+// ---------------------------------------------------------------------------
+
+function _connect(): void {
+	if (!builder || connection?.isActive || isConnecting) return;
+
+	if (reconnectTimer !== null) {
+		clearTimeout(reconnectTimer);
+		reconnectTimer = null;
+	}
+
+	isConnecting = true;
+	connection = builder.build();
+}
+
+function _disconnect(): void {
+	if (reconnectTimer !== null) {
+		clearTimeout(reconnectTimer);
+		reconnectTimer = null;
+	}
+	if (connection) {
+		connection.disconnect();
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Subscription helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build an array of typed queries for a given entity + region list.
+ *
+ * We produce one query per region so that the subscription array acts as a
+ * UNION in the client cache. When regions is empty a single unfiltered-by-
+ * region query is emitted (use with care on large tables).
+ */
+function _buildQueries(
+	type: EntityType,
+	id: number
+): RowTypedQuery<any, any>[] {
+	if (type === 'resource') {
+		if (regions.length === 0) {
+			return [tables.resource_location.where(r => r.resourceId.eq(id))];
+		}
+		return regions.map(rg =>
+			tables.resource_location.where(r => r.resourceId.eq(id).and(r.regionId.eq(rg)))
+		);
+	} else {
+		if (regions.length === 0) {
+			return [tables.enemy_location.where(r => r.enemyType.eq(id))];
+		}
+		return regions.map(rg =>
+			tables.enemy_location.where(r => r.enemyType.eq(id).and(r.regionId.eq(rg)))
+		);
+	}
+}
+
+function _createSubscription(
+	conn: DbConnection,
+	id: number,
+	entity: TrackedEntity
+): SubscriptionHandle {
+	return conn
+		.subscriptionBuilder()
+		.onApplied(() => {
+			_populateFromCache(conn, id, entity.type);
+		})
+		.onError((ctx: ErrorContext) => {
+			console.error(`[Relay] Subscription error for ${entity.type} ${id}:`, ctx.event);
+		})
+		.subscribe(_buildQueries(entity.type, id));
+}
+
+function _updateEntityRegions(
+	conn: DbConnection,
+	id: number,
+	entity: TrackedEntity,
+): void {
+	const oldSub = entity.subscription;
+
+	entity.subscription = conn
+		.subscriptionBuilder()
+		.onApplied(() => {
+			// Drop the old subscription now that the server has sent us the delta.
+			oldSub?.unsubscribe();
+			_populateFromCache(conn, id, entity.type);
+		})
+		.onError((ctx: ErrorContext) => {
+			console.error(`[Relay] Subscription update error for ${entity.type} ${id}:`, ctx.event);
+		})
+		.subscribe(_buildQueries(entity.type, id));
+}
+
+function _createPlayerSubscription(conn: DbConnection, entityId: string): SubscriptionHandle {
+	const bigId = BigInt(entityId);
+	return conn
+		.subscriptionBuilder()
+		.onApplied(() => {
+			_populatePlayerFromCache(conn, entityId, bigId);
+		})
+		.onError((ctx: ErrorContext) => {
+			console.error(`[Relay] Subscription error for player ${entityId}:`, ctx.event);
+		})
+		.subscribe([
+			tables.player_state.where(r => r.entityId.eq(bigId)),
+			tables.player_location.where(r => r.entityId.eq(bigId)),
+		]);
+}
+
+// ---------------------------------------------------------------------------
+// Cache helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Bulk-populate a canvas layer from the local client cache.
+ * Called once per entity per (re)connect, from onApplied.
+ */
+function _populateFromCache(conn: DbConnection, id: number, type: EntityType): void {
+	const layer = type === 'resource' ? resourceAccessor()[id] : enemyAccessor()[id];
+	if (!layer) return;
+
+	const byRegion = new Map<number, [number, number][]>();
+
+	if (type === 'resource') {
+		for (const row of conn.db.resource_location.iter()) {
+			if (row.resourceId !== id) continue;
+			const rid = row.regionId as number;
+			let pts = byRegion.get(rid);
+			if (!pts) { pts = []; byRegion.set(rid, pts); }
+			pts.push([row.x, row.z]);
+		}
+	} else {
+		for (const row of conn.db.enemy_location.iter()) {
+			if (row.enemyType !== id) continue;
+			const rid = row.regionId as number;
+			let pts = byRegion.get(rid);
+			if (!pts) { pts = []; byRegion.set(rid, pts); }
+			pts.push([row.x / 1000, row.z / 1000]);
+		}
+	}
+
+	layer.clearAllRegions();
+	for (const [regionId, coords] of byRegion.entries()) {
+		layer.setRegionPoints(regionId, coords);
+	}
+}
+
+/**
+ * Notify a tracked player's callback with current state from the client cache.
+ * Called from the player subscription's onApplied.
+ */
+function _populatePlayerFromCache(conn: DbConnection, entityId: string, bigId: bigint): void {
+	const tracked = trackedPlayers.get(entityId);
+	if (!tracked) return;
+
+	const state = conn.db.player_state.entity_id.find(bigId);
+	if (!state) return;
+
+	const loc = conn.db.player_location.entity_id.find(bigId);
+	tracked.callback(
+		entityId,
+		state.name,
+		state.online,
+		loc ? loc.x / 1000 : null,
+		loc ? loc.z / 1000 : null,
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Row change callbacks
+// These are registered on each new connection instance inside onConnect.
+// The ctx.db accessor gives us the table cache for that connection.
+// ---------------------------------------------------------------------------
+
+function handleResourceInsert(ctx: EventContext, row: ResourceLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	_markRegionDirty('resource', row.resourceId, row.regionId as number);
+}
+
+function handleResourceDelete(ctx: EventContext, row: ResourceLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	_markRegionDirty('resource', row.resourceId, row.regionId as number);
+}
+
+function handleResourceUpdate(ctx: EventContext, _old: ResourceLocation, row: ResourceLocation): void {
+	handleResourceInsert(ctx, row);
+}
+
+function handleEnemyInsert(ctx: EventContext, row: EnemyLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	_markRegionDirty('enemy', row.enemyType, row.regionId as number);
+}
+
+function handleEnemyDelete(ctx: EventContext, row: EnemyLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	_markRegionDirty('enemy', row.enemyType, row.regionId as number);
+}
+
+function handleEnemyUpdate(ctx: EventContext, _old: EnemyLocation, row: EnemyLocation): void {
+	handleEnemyInsert(ctx, row);
+}
+
+function handlePlayerStateInsert(ctx: EventContext, row: PlayerState): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	const entityId = row.entityId.toString();
+	const tracked = trackedPlayers.get(entityId);
+	if (!tracked) return;
+	const loc = connection?.db.player_location.entity_id.find(row.entityId);
+	tracked.callback(entityId, row.name, row.online, loc ? loc.x / 1000 : null, loc ? loc.z / 1000 : null);
+}
+
+function handlePlayerStateUpdate(ctx: EventContext, _old: PlayerState, row: PlayerState): void {
+	handlePlayerStateInsert(ctx, row);
+}
+
+function handlePlayerLocationInsert(ctx: EventContext, row: PlayerLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	const entityId = row.entityId.toString();
+	const tracked = trackedPlayers.get(entityId);
+	if (!tracked) return;
+	const state = connection?.db.player_state.entity_id.find(row.entityId);
+	if (!state) return;
+	tracked.callback(entityId, state.name, state.online, row.x / 1000, row.z / 1000);
+}
+
+function handlePlayerLocationUpdate(ctx: EventContext, _old: PlayerLocation, row: PlayerLocation): void {
+	handlePlayerLocationInsert(ctx, row);
+}
+
+function handlePlayerLocationDelete(ctx: EventContext, row: PlayerLocation): void {
+	if (ctx.event.tag === "SubscribeApplied") return;
+	const entityId = row.entityId.toString();
+	const tracked = trackedPlayers.get(entityId);
+	if (!tracked) return;
+	const state = connection?.db.player_state.entity_id.find(row.entityId);
+	if (!state) return;
+	tracked.callback(entityId, state.name, state.online, null, null);
+}
+
+/**
+ * Mark a region/entity as dirty and schedule batch rebuild if not already scheduled.
+ */
+function _markRegionDirty(type: EntityType, entityId: number, regionId: number): void {
+	const key = `${entityId}:${regionId}`;
+	if (type === 'resource') {
+		dirtyResourceRegions.add(key);
+	} else {
+		dirtyEnemyRegions.add(key);
+	}
+
+	if (rebuildTimer === null) {
+		rebuildTimer = setTimeout(_processDirtyRegions, REBUILD_DEBOUNCE_MS);
+	}
+}
+
+/**
+ * Process all accumulated dirty regions and rebuild their layers at once.
+ * Single pass through each table's cache, collecting data for all dirty regions.
+ */
+function _processDirtyRegions(): void {
+	if (!connection?.isActive) {
+		dirtyResourceRegions.clear();
+		dirtyEnemyRegions.clear();
+		rebuildTimer = null;
+		return;
+	}
+
+	const db = connection.db;
+
+	// Single pass for resources: collect by entityId -> regionId
+	if (dirtyResourceRegions.size > 0) {
+		const dirtyByEntity = new Map<number, Map<number, [number, number][]>>();
+
+		// Populate the nested map from dirty keys
+		for (const key of dirtyResourceRegions) {
+			const [entityIdStr, regionIdStr] = key.split(':');
+			const entityId = parseInt(entityIdStr, 10);
+			const regionId = parseInt(regionIdStr, 10);
+
+			if (!dirtyByEntity.has(entityId)) {
+				dirtyByEntity.set(entityId, new Map());
+			}
+			dirtyByEntity.get(entityId)!.set(regionId, []);
+		}
+
+		// Single iteration: collect points for all dirty entity/region combinations
+		for (const row of db.resource_location.iter()) {
+			const entityMap = dirtyByEntity.get(row.resourceId);
+			if (!entityMap) continue;
+
+			const regionId = row.regionId as number;
+			const pts = entityMap.get(regionId);
+			if (!pts) continue;
+
+			pts.push([row.x, row.z]);
+		}
+
+		// Update layers
+		for (const [entityId, regionMap] of dirtyByEntity) {
+			const layer = resourceAccessor()[entityId];
+			if (!layer) continue;
+
+			for (const [regionId, coords] of regionMap) {
+				if (coords.length > 0) {
+					layer.setRegionPoints(regionId, coords);
+				} else {
+					layer.clearRegion(regionId);
+				}
+			}
+		}
+
+		dirtyResourceRegions.clear();
+	}
+
+	// Single pass for enemies: collect by entityId -> regionId
+	if (dirtyEnemyRegions.size > 0) {
+		const dirtyByEntity = new Map<number, Map<number, [number, number][]>>();
+
+		// Populate the nested map from dirty keys
+		for (const key of dirtyEnemyRegions) {
+			const [entityIdStr, regionIdStr] = key.split(':');
+			const entityId = parseInt(entityIdStr, 10);
+			const regionId = parseInt(regionIdStr, 10);
+
+			if (!dirtyByEntity.has(entityId)) {
+				dirtyByEntity.set(entityId, new Map());
+			}
+			dirtyByEntity.get(entityId)!.set(regionId, []);
+		}
+
+		// Single iteration: collect points for all dirty entity/region combinations
+		for (const row of db.enemy_location.iter()) {
+			const entityMap = dirtyByEntity.get(row.enemyType);
+			if (!entityMap) continue;
+
+			const regionId = row.regionId as number;
+			const pts = entityMap.get(regionId);
+			if (!pts) continue;
+
+			pts.push([row.x / 1000, row.z / 1000]);
+		}
+
+		// Update layers
+		for (const [entityId, regionMap] of dirtyByEntity) {
+			const layer = enemyAccessor()[entityId];
+			if (!layer) continue;
+
+			for (const [regionId, coords] of regionMap) {
+				if (coords.length > 0) {
+					layer.setRegionPoints(regionId, coords);
+				} else {
+					layer.clearRegion(regionId);
+				}
+			}
+		}
+
+		dirtyEnemyRegions.clear();
+	}
+
+	rebuildTimer = null;
+}
+
diff --git a/src/lib/services/resource-service.ts b/src/lib/services/resource-service.ts
deleted file mode 100644
index b2f58a39..00000000
--- a/src/lib/services/resource-service.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { ResourceSearchResult, ResourceSearchResponse } from '$lib/types/geojson';
-import { resourceIndex } from '$lib/data/resource-index';
-
-let abortController: AbortController | null = null;
-
-function localSearch(query: string): ResourceSearchResult[] {
-	const q = query.trim().toLowerCase();
-	const results: ResourceSearchResult[] = [];
-
-	for (const [id, entry] of Object.entries(resourceIndex)) {
-		if (entry.name.toLowerCase().includes(q) || (entry.tag ?? '').toLowerCase().includes(q)) {
-			results.push({
-				id: Number(id),
-				name: entry.name,
-				tier: entry.tier,
-				tag: entry.tag ?? '',
-				rarity: -1
-			});
-		}
-	}
-
-	return results;
-}
-
-export async function searchResources(query: string): Promise<ResourceSearchResult[]> {
-	if (abortController) {
-		abortController.abort();
-	}
-
-	if (!query || query.trim().length < 2) {
-		return [];
-	}
-
-	abortController = new AbortController();
-
-	try {
-		const response = await fetch(
-			`/api/resources?q=${encodeURIComponent(query.trim())}`,
-			{ signal: AbortSignal.any([abortController.signal, AbortSignal.timeout(3000)]) }
-		);
-
-		if (!response.ok) return localSearch(query);
-
-		const data: ResourceSearchResponse = await response.json();
-		return data.resources;
-	} catch (err) {
-		if (err instanceof DOMException && err.name === 'AbortError') {
-			return [];
-		}
-		console.error('Resource search failed, falling back to local index:', err);
-		return localSearch(query);
-	} finally {
-		abortController = null;
-	}
-}
diff --git a/src/lib/stores/search-store.svelte.ts b/src/lib/stores/search-store.svelte.ts
index dfa6f84f..1467e103 100644
--- a/src/lib/stores/search-store.svelte.ts
+++ b/src/lib/stores/search-store.svelte.ts
@@ -1,8 +1,7 @@
 import type L from 'leaflet';
 import type { MapSelection } from '$lib/types/map';
 import { searchPlayers } from '$lib/services/player-service';
-import { searchResources } from '$lib/services/resource-service';
-import { creatureIndex } from '$lib/data/resource-index';
+import {creatureIndex, resourceIndex} from '$lib/data/resource-index';
 
 export interface SearchEntry {
 	title: string;
@@ -46,7 +45,6 @@ let query = $state('');
 let selectedIndex = $state(-1);
 let isOpen = $state(false);
 let playerResults = $state<PlayerEntry[]>([]);
-let resourceResults = $state<ResourceEntry[]>([]);
 let isLoadingRemote = $state(false);
 let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
@@ -55,7 +53,6 @@ function triggerRemoteSearch(q: string): void {
 
 	if (!q || q.trim().length < 2) {
 		playerResults = [];
-		resourceResults = [];
 		isLoadingRemote = false;
 		return;
 	}
@@ -71,16 +68,7 @@ function triggerRemoteSearch(q: string): void {
 					signedIn: p.signedIn
 				}));
 			});
-			const resourcePromise = searchResources(q).then(resources => {
-				resourceResults = resources.map((r) => ({
-					type: 'resource' as const,
-					id: r.id,
-					name: r.name,
-					tier: r.tier,
-					tag: r.tag
-				}));
-			});
-			await Promise.allSettled([playerPromise, resourcePromise]);
+			await Promise.allSettled([playerPromise]);
 		} catch (err) {
 			console.error('Search failed:', err);
 		} finally {
@@ -118,7 +106,18 @@ export function getSearchState() {
 		},
 
 		get resourceResults(): ResourceEntry[] {
-			return resourceResults;
+			if (!query.trim()) return [];
+			const lower = query.toLowerCase();
+			return Object.entries(resourceIndex)
+				.filter(([, r]) => r.name.toLowerCase().includes(lower))
+				.slice(0, 50)
+				.map(([id, r]) => ({
+					type: 'resource' as const,
+					id: Number(id),
+					name: r.name,
+					tier: r.tier,
+					tag: r.tag ?? "",
+				}));
 		},
 
 		get creatureResults(): CreatureSearchEntry[] {
@@ -151,7 +150,6 @@ export function clearSearch(): void {
 	selectedIndex = -1;
 	isOpen = false;
 	playerResults = [];
-	resourceResults = [];
 	isLoadingRemote = false;
 	if (debounceTimer) clearTimeout(debounceTimer);
 }
diff --git a/src/lib/stores/tracking-store.svelte.ts b/src/lib/stores/tracking-store.svelte.ts
index 3fad2f67..9799a316 100644
--- a/src/lib/stores/tracking-store.svelte.ts
+++ b/src/lib/stores/tracking-store.svelte.ts
@@ -125,34 +125,34 @@ export function addTrackingItem(item: TrackingItem): void {
 			saveDisplayName(item.type, item.entityId, item.text);
 		}
 	} else {
-		if (!items.some((i) => i.id === item.id)) {
+		if (!items.some((i) => i.id === item.id && i.type === item.type)) {
 			items = [...items, item];
 			if (item.type) saveDisplayName(item.type, item.id, item.text);
 		}
 	}
 }
 
-export function toggleTrackingItem(id: number): void {
-	items = items.map((i) => (i.id === id ? { ...i, visible: !i.visible } : i));
+export function toggleTrackingItem(id: number, type: 'enemy' | 'resource'): void {
+	items = items.map((i) => (i.id === id && i.type == type ? { ...i, visible: !i.visible } : i));
 }
 
 export function toggleTrackingItemByEntityId(entityId: string): void {
 	items = items.map((i) => (i.entityId === entityId ? { ...i, visible: !i.visible } : i));
 }
 
-export function removeTrackingItem(id: number): void {
-	items = items.filter((i) => i.id !== id);
+export function removeTrackingItem(id: number, type: 'enemy' | 'resource'): void {
+	items = items.filter((i) => !(i.id === id && i.type === type));
 }
 
 export function removeTrackingItemByEntityId(entityId: string): void {
 	items = items.filter((i) => i.entityId !== entityId);
 }
 
-export function updateTrackingItemColor(id: number, color: string): void {
+export function updateTrackingItemColor(id: number, type: 'enemy' | 'resource', color: string): void {
 	if (!isValidColor(color)) return;
-	const item = items.find((i) => i.id === id);
+	const item = items.find((i) => i.id === id && i.type === type);
 	if (item) saveColorPreference(item.type, id, color);
-	items = items.map((i) => (i.id === id ? { ...i, color } : i));
+	items = items.map((i) => (i.id === id && i.type === type ? { ...i, color } : i));
 	if (item?.type) colorSyncHandler?.(item.type, id, color);
 }
 
diff --git a/src/lib/types/geojson.ts b/src/lib/types/geojson.ts
index a5c0afee..468efefa 100644
--- a/src/lib/types/geojson.ts
+++ b/src/lib/types/geojson.ts
@@ -55,24 +55,6 @@ export interface PlayerSearchResult {
 	lastLoginTimestamp: string | null;
 }
 
-export interface PlayerSearchResponse {
-	players: PlayerSearchResult[];
-	total: number;
-}
-
-export interface ResourceSearchResult {
-	id: number;
-	name: string;
-	tier: number;
-	tag: string;
-	rarity: number;
-}
-
-export interface ResourceSearchResponse {
-	resources: ResourceSearchResult[];
-	count: number;
-}
-
 export interface UrlParams {
 	heatmap: boolean;
 	gistId: string | null;
diff --git a/src/lib/types/map.ts b/src/lib/types/map.ts
index 914f3b46..b26fefac 100644
--- a/src/lib/types/map.ts
+++ b/src/lib/types/map.ts
@@ -16,10 +16,10 @@ export interface MapConfig {
 }
 
 export interface AppConfig {
-	backendUrl: string;
 	gistApi: string;
-	websocketUrl: string;
 	exportsCdn: string;
+	relayHost: string;
+	relayModule: string;
 }
 
 // --- Map Selection Types ---
diff --git a/src/relay-bindings/enemy_location_table.ts b/src/relay-bindings/enemy_location_table.ts
new file mode 100644
index 00000000..1508f56f
--- /dev/null
+++ b/src/relay-bindings/enemy_location_table.ts
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  TypeBuilder as __TypeBuilder,
+  t as __t,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type Infer as __Infer,
+} from "spacetimedb";
+
+export default __t.row({
+  entityId: __t.u64().primaryKey().name("entity_id"),
+  enemyType: __t.i32().name("enemy_type"),
+  x: __t.i32(),
+  z: __t.i32(),
+  regionId: __t.u8().name("region_id"),
+});
diff --git a/src/relay-bindings/index.ts b/src/relay-bindings/index.ts
new file mode 100644
index 00000000..b5365d61
--- /dev/null
+++ b/src/relay-bindings/index.ts
@@ -0,0 +1,182 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb cli version 2.3.0 (commit aa73d1c35b4b346b98eeba10a3d756b4ae72162f).
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  DbConnectionBuilder as __DbConnectionBuilder,
+  DbConnectionImpl as __DbConnectionImpl,
+  SubscriptionBuilderImpl as __SubscriptionBuilderImpl,
+  TypeBuilder as __TypeBuilder,
+  Uuid as __Uuid,
+  convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
+  procedureSchema as __procedureSchema,
+  procedures as __procedures,
+  reducerSchema as __reducerSchema,
+  reducers as __reducers,
+  schema as __schema,
+  t as __t,
+  table as __table,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type DbConnectionConfig as __DbConnectionConfig,
+  type ErrorContextInterface as __ErrorContextInterface,
+  type Event as __Event,
+  type EventContextInterface as __EventContextInterface,
+  type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
+  type ReducerEventContextInterface as __ReducerEventContextInterface,
+  type RemoteModule as __RemoteModule,
+  type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
+  type SubscriptionHandleImpl as __SubscriptionHandleImpl,
+} from "spacetimedb";
+
+// Import all reducer arg schemas
+
+// Import all procedure arg schemas
+
+// Import all table schema definitions
+import EnemyLocationRow from "./enemy_location_table";
+import PlayerLocationRow from "./player_location_table";
+import PlayerStateRow from "./player_state_table";
+import ResourceLocationRow from "./resource_location_table";
+
+/** Type-only namespace exports for generated type groups. */
+
+/** The schema information for all tables in this module. This is defined the same was as the tables would have been defined in the server. */
+const tablesSchema = __schema({
+  enemy_location: __table({
+    name: 'enemy_location',
+    indexes: [
+      { accessor: 'by_enemy_type', name: 'enemy_location_enemy_type_idx_btree', algorithm: 'btree', columns: [
+        'enemyType',
+      ] },
+      { accessor: 'by_enemy_type_and_region', name: 'enemy_location_enemy_type_region_id_idx_btree', algorithm: 'btree', columns: [
+        'enemyType',
+        'regionId',
+      ] },
+      { accessor: 'entity_id', name: 'enemy_location_entity_id_idx_btree', algorithm: 'btree', columns: [
+        'entityId',
+      ] },
+      { accessor: 'by_region', name: 'enemy_location_region_id_idx_btree', algorithm: 'btree', columns: [
+        'regionId',
+      ] },
+    ],
+    constraints: [
+      { name: 'enemy_location_entity_id_key', constraint: 'unique', columns: ['entityId'] },
+    ],
+  }, EnemyLocationRow),
+  player_location: __table({
+    name: 'player_location',
+    indexes: [
+      { accessor: 'entity_id', name: 'player_location_entity_id_idx_btree', algorithm: 'btree', columns: [
+        'entityId',
+      ] },
+      { accessor: 'by_region', name: 'player_location_region_id_idx_btree', algorithm: 'btree', columns: [
+        'regionId',
+      ] },
+    ],
+    constraints: [
+      { name: 'player_location_entity_id_key', constraint: 'unique', columns: ['entityId'] },
+    ],
+  }, PlayerLocationRow),
+  player_state: __table({
+    name: 'player_state',
+    indexes: [
+      { accessor: 'entity_id', name: 'player_state_entity_id_idx_btree', algorithm: 'btree', columns: [
+        'entityId',
+      ] },
+      { accessor: 'by_region', name: 'player_state_region_id_idx_btree', algorithm: 'btree', columns: [
+        'regionId',
+      ] },
+    ],
+    constraints: [
+      { name: 'player_state_entity_id_key', constraint: 'unique', columns: ['entityId'] },
+    ],
+  }, PlayerStateRow),
+  resource_location: __table({
+    name: 'resource_location',
+    indexes: [
+      { accessor: 'entity_id', name: 'resource_location_entity_id_idx_btree', algorithm: 'btree', columns: [
+        'entityId',
+      ] },
+      { accessor: 'by_region', name: 'resource_location_region_id_idx_btree', algorithm: 'btree', columns: [
+        'regionId',
+      ] },
+      { accessor: 'by_resource', name: 'resource_location_resource_id_idx_btree', algorithm: 'btree', columns: [
+        'resourceId',
+      ] },
+      { accessor: 'by_resource_and_region', name: 'resource_location_resource_id_region_id_idx_btree', algorithm: 'btree', columns: [
+        'resourceId',
+        'regionId',
+      ] },
+    ],
+    constraints: [
+      { name: 'resource_location_entity_id_key', constraint: 'unique', columns: ['entityId'] },
+    ],
+  }, ResourceLocationRow),
+});
+
+/** The schema information for all reducers in this module. This is defined the same way as the reducers would have been defined in the server, except the body of the reducer is omitted in code generation. */
+const reducersSchema = __reducers(
+);
+
+/** The schema information for all procedures in this module. This is defined the same way as the procedures would have been defined in the server. */
+const proceduresSchema = __procedures(
+);
+
+/** The remote SpacetimeDB module schema, both runtime and type information. */
+const REMOTE_MODULE = {
+  versionInfo: {
+    cliVersion: "2.3.0" as const,
+  },
+  tables: tablesSchema.schemaType.tables,
+  reducers: reducersSchema.reducersType.reducers,
+  ...proceduresSchema,
+} satisfies __RemoteModule<
+  typeof tablesSchema.schemaType,
+  typeof reducersSchema.reducersType,
+  typeof proceduresSchema
+>;
+
+/** The tables available in this remote SpacetimeDB module. Each table reference doubles as a query builder. */
+export const tables: __QueryBuilder<typeof tablesSchema.schemaType> = __makeQueryBuilder(tablesSchema.schemaType);
+
+/** The reducers available in this remote SpacetimeDB module. */
+export const reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);
+
+/** The procedures available in this remote SpacetimeDB module. */
+export const procedures = __convertToAccessorMap(proceduresSchema.procedures);
+
+/** The context type returned in callbacks for all possible events. */
+export type EventContext = __EventContextInterface<typeof REMOTE_MODULE>;
+/** The context type returned in callbacks for reducer events. */
+export type ReducerEventContext = __ReducerEventContextInterface<typeof REMOTE_MODULE>;
+/** The context type returned in callbacks for subscription events. */
+export type SubscriptionEventContext = __SubscriptionEventContextInterface<typeof REMOTE_MODULE>;
+/** The context type returned in callbacks for error events. */
+export type ErrorContext = __ErrorContextInterface<typeof REMOTE_MODULE>;
+/** The subscription handle type to manage active subscriptions created from a {@link SubscriptionBuilder}. */
+export type SubscriptionHandle = __SubscriptionHandleImpl<typeof REMOTE_MODULE>;
+
+/** Builder class to configure a new subscription to the remote SpacetimeDB instance. */
+export class SubscriptionBuilder extends __SubscriptionBuilderImpl<typeof REMOTE_MODULE> {}
+
+/** Builder class to configure a new database connection to the remote SpacetimeDB instance. */
+export class DbConnectionBuilder extends __DbConnectionBuilder<DbConnection> {}
+
+/** The typed database connection to manage connections to the remote SpacetimeDB instance. This class has type information specific to the generated module. */
+export class DbConnection extends __DbConnectionImpl<typeof REMOTE_MODULE> {
+  /** Creates a new {@link DbConnectionBuilder} to configure and connect to the remote SpacetimeDB instance. */
+  static builder = (): DbConnectionBuilder => {
+    return new DbConnectionBuilder(REMOTE_MODULE, (config: __DbConnectionConfig<typeof REMOTE_MODULE>) => new DbConnection(config));
+  };
+
+  /** Creates a new {@link SubscriptionBuilder} to configure a subscription to the remote SpacetimeDB instance. */
+  override subscriptionBuilder = (): SubscriptionBuilder => {
+    return new SubscriptionBuilder(this);
+  };
+}
+
diff --git a/src/relay-bindings/player_location_table.ts b/src/relay-bindings/player_location_table.ts
new file mode 100644
index 00000000..5e95315f
--- /dev/null
+++ b/src/relay-bindings/player_location_table.ts
@@ -0,0 +1,18 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  TypeBuilder as __TypeBuilder,
+  t as __t,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type Infer as __Infer,
+} from "spacetimedb";
+
+export default __t.row({
+  entityId: __t.u64().primaryKey().name("entity_id"),
+  x: __t.i32(),
+  z: __t.i32(),
+  regionId: __t.u8().name("region_id"),
+});
diff --git a/src/relay-bindings/player_state_table.ts b/src/relay-bindings/player_state_table.ts
new file mode 100644
index 00000000..435a8382
--- /dev/null
+++ b/src/relay-bindings/player_state_table.ts
@@ -0,0 +1,18 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  TypeBuilder as __TypeBuilder,
+  t as __t,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type Infer as __Infer,
+} from "spacetimedb";
+
+export default __t.row({
+  entityId: __t.u64().primaryKey().name("entity_id"),
+  regionId: __t.u8().name("region_id"),
+  online: __t.bool(),
+  name: __t.string(),
+});
diff --git a/src/relay-bindings/resource_location_table.ts b/src/relay-bindings/resource_location_table.ts
new file mode 100644
index 00000000..720068bd
--- /dev/null
+++ b/src/relay-bindings/resource_location_table.ts
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  TypeBuilder as __TypeBuilder,
+  t as __t,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type Infer as __Infer,
+} from "spacetimedb";
+
+export default __t.row({
+  entityId: __t.u64().primaryKey().name("entity_id"),
+  resourceId: __t.i32().name("resource_id"),
+  regionId: __t.u8().name("region_id"),
+  x: __t.i32(),
+  z: __t.i32(),
+});
diff --git a/src/relay-bindings/types.ts b/src/relay-bindings/types.ts
new file mode 100644
index 00000000..19a3c5e9
--- /dev/null
+++ b/src/relay-bindings/types.ts
@@ -0,0 +1,46 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import {
+  TypeBuilder as __TypeBuilder,
+  t as __t,
+  type AlgebraicTypeType as __AlgebraicTypeType,
+  type Infer as __Infer,
+} from "spacetimedb";
+
+export const EnemyLocation = __t.object("EnemyLocation", {
+  entityId: __t.u64(),
+  enemyType: __t.i32(),
+  x: __t.i32(),
+  z: __t.i32(),
+  regionId: __t.u8(),
+});
+export type EnemyLocation = __Infer<typeof EnemyLocation>;
+
+export const PlayerLocation = __t.object("PlayerLocation", {
+  entityId: __t.u64(),
+  x: __t.i32(),
+  z: __t.i32(),
+  regionId: __t.u8(),
+});
+export type PlayerLocation = __Infer<typeof PlayerLocation>;
+
+export const PlayerState = __t.object("PlayerState", {
+  entityId: __t.u64(),
+  regionId: __t.u8(),
+  online: __t.bool(),
+  name: __t.string(),
+});
+export type PlayerState = __Infer<typeof PlayerState>;
+
+export const ResourceLocation = __t.object("ResourceLocation", {
+  entityId: __t.u64(),
+  resourceId: __t.i32(),
+  regionId: __t.u8(),
+  x: __t.i32(),
+  z: __t.i32(),
+});
+export type ResourceLocation = __Infer<typeof ResourceLocation>;
+
diff --git a/src/relay-bindings/types/procedures.ts b/src/relay-bindings/types/procedures.ts
new file mode 100644
index 00000000..d5ac825c
--- /dev/null
+++ b/src/relay-bindings/types/procedures.ts
@@ -0,0 +1,10 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import { type Infer as __Infer } from "spacetimedb";
+
+// Import all procedure arg schemas
+
+
diff --git a/src/relay-bindings/types/reducers.ts b/src/relay-bindings/types/reducers.ts
new file mode 100644
index 00000000..f090c776
--- /dev/null
+++ b/src/relay-bindings/types/reducers.ts
@@ -0,0 +1,8 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+/* eslint-disable */
+/* tslint:disable */
+import { type Infer as __Infer } from "spacetimedb";
+
+// Import all reducer arg schemas
diff --git a/src/routes/api/players/+server.ts b/src/routes/api/players/+server.ts
deleted file mode 100644
index 15bbecdf..00000000
--- a/src/routes/api/players/+server.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { json } from '@sveltejs/kit';
-import type { RequestHandler } from './$types';
-import type { PlayerSearchResponse } from '$lib/types/geojson';
-
-export const GET: RequestHandler = async ({ url, fetch }) => {
-	const query = url.searchParams.get('q');
-	if (!query || query.trim().length < 2) {
-		return json({ players: [], total: 0 });
-	}
-
-	try {
-		const response = await fetch(
-			`https://bitjita.com/api/players?q=${encodeURIComponent(query.trim())}`
-		);
-
-		if (!response.ok) {
-			return json({ players: [], total: 0 }, { status: response.status });
-		}
-
-		const data: PlayerSearchResponse = await response.json();
-		return json(data);
-	} catch {
-		return json({ players: [], total: 0 }, { status: 500 });
-	}
-};
diff --git a/src/routes/api/players/[id]/+server.ts b/src/routes/api/players/[id]/+server.ts
deleted file mode 100644
index 89f90f41..00000000
--- a/src/routes/api/players/[id]/+server.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { json } from '@sveltejs/kit';
-import type { RequestHandler } from './$types';
-
-export const GET: RequestHandler = async ({ params, fetch }) => {
-	const { id } = params;
-	if (!id || !/^[0-9]{1,32}$/.test(id)) {
-		return json({ error: 'Invalid player ID' }, { status: 400 });
-	}
-
-	try {
-		const response = await fetch(`https://bitjita.com/api/players/${id}`);
-		if (!response.ok) {
-			return json({ error: 'Player not found' }, { status: response.status });
-		}
-		const data = await response.json();
-		return json(data);
-	} catch {
-		return json({ error: 'Failed to fetch player' }, { status: 500 });
-	}
-};
diff --git a/src/routes/api/resources/+server.ts b/src/routes/api/resources/+server.ts
deleted file mode 100644
index ca84ebe0..00000000
--- a/src/routes/api/resources/+server.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { json } from '@sveltejs/kit';
-import type { RequestHandler } from './$types';
-
-export const GET: RequestHandler = async ({ url, fetch }) => {
-	const query = url.searchParams.get('q');
-	if (!query || query.trim().length < 2) {
-		return json({ resources: [], count: 0 });
-	}
-
-	try {
-		const response = await fetch(
-			`https://bitjita.com/api/resources?q=${encodeURIComponent(query.trim())}`
-		);
-
-		if (!response.ok) {
-			return json({ resources: [], count: 0 }, { status: response.status });
-		}
-
-		const data = await response.json();
-		return json(data);
-	} catch {
-		return json({ resources: [], count: 0 }, { status: 500 });
-	}
-};