Merge pull request #585 from guarzo/guarzo/addsysfromapi

feat: auto add system on sig addition

.env.example

@@ -16,3 +16,8 @@ export WANDERER_SSE_ENABLED="true"
 export WANDERER_WEBHOOKS_ENABLED="true"
 export WANDERER_SSE_MAX_CONNECTIONS="1000"
 export WANDERER_WEBHOOK_TIMEOUT_MS="15000"
+
+# Promo codes for map subscriptions (optional)
+# Format: CODE:DISCOUNT_PERCENT,CODE2:DISCOUNT_PERCENT2
+# Codes are case-insensitive, discounts stack with period discounts
+# export WANDERER_PROMO_CODES="PROMO2025:10,NEWUSER:20"

.gitignore

@@ -17,6 +17,9 @@ repomix*
 /priv/static/images/
 /priv/static/*.js
 /priv/static/*.css
+/priv/static/*-*.png
+/priv/static/*-*.webp
+/priv/static/*-*.webmanifest
 
 # Dialyzer PLT files
 /priv/plts/

CHANGELOG.md

@@ -2,6 +2,312 @@
 
 <!-- changelog -->
 
+## [v1.92.0](https://github.com/wanderer-industries/wanderer/compare/v1.91.11...v1.92.0) (2026-01-14)
+
+
+
+
+### Features:
+
+* Added ability to select a range of wh classes for k162.
+
+### Bug Fixes:
+
+* core: Show c1/c2/c3 or c4/c5 or link signature modal
+
+## [v1.91.11](https://github.com/wanderer-industries/wanderer/compare/v1.91.10...v1.91.11) (2026-01-13)
+
+
+
+
+### Bug Fixes:
+
+* allow sig api when map relay is off
+
+## [v1.91.10](https://github.com/wanderer-industries/wanderer/compare/v1.91.9...v1.91.10) (2026-01-07)
+
+
+
+
+### Bug Fixes:
+
+* remove actor context requirement from sig api
+
+## [v1.91.9](https://github.com/wanderer-industries/wanderer/compare/v1.91.8...v1.91.9) (2026-01-06)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed rally point cancel logic
+
+## [v1.91.8](https://github.com/wanderer-industries/wanderer/compare/v1.91.7...v1.91.8) (2026-01-06)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed rally point cancel logic
+
+## [v1.91.7](https://github.com/wanderer-industries/wanderer/compare/v1.91.6...v1.91.7) (2026-01-05)
+
+
+
+
+## [v1.91.6](https://github.com/wanderer-industries/wanderer/compare/v1.91.5...v1.91.6) (2026-01-04)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed new connections got deleted after linked signature cleanup
+
+## [v1.91.5](https://github.com/wanderer-industries/wanderer/compare/v1.91.4...v1.91.5) (2025-12-30)
+
+
+
+
+## [v1.91.4](https://github.com/wanderer-industries/wanderer/compare/v1.91.3...v1.91.4) (2025-12-30)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed connections create between k-space systems (considered as wh connection)
+
+## [v1.91.3](https://github.com/wanderer-industries/wanderer/compare/v1.91.2...v1.91.3) (2025-12-28)
+
+
+
+
+## [v1.91.2](https://github.com/wanderer-industries/wanderer/compare/v1.91.1...v1.91.2) (2025-12-27)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed map scopes updates & logic
+
+## [v1.91.1](https://github.com/wanderer-industries/wanderer/compare/v1.91.0...v1.91.1) (2025-12-25)
+
+
+
+
+## [v1.91.0](https://github.com/wanderer-industries/wanderer/compare/v1.90.13...v1.91.0) (2025-12-24)
+
+
+
+
+### Features:
+
+* admin: added maps administration view with basic info, search, restore/delete, acls view and edit options
+
+## [v1.90.13](https://github.com/wanderer-industries/wanderer/compare/v1.90.12...v1.90.13) (2025-12-19)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed welcome page
+
+## [v1.90.12](https://github.com/wanderer-industries/wanderer/compare/v1.90.11...v1.90.12) (2025-12-19)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed permissions update after character corp updates
+
+## [v1.90.11](https://github.com/wanderer-industries/wanderer/compare/v1.90.10...v1.90.11) (2025-12-18)
+
+
+
+
+## [v1.90.10](https://github.com/wanderer-industries/wanderer/compare/v1.90.9...v1.90.10) (2025-12-18)
+
+
+
+
+## [v1.90.9](https://github.com/wanderer-industries/wanderer/compare/v1.90.8...v1.90.9) (2025-12-15)
+
+
+
+
+### Bug Fixes:
+
+* core: reduce chracters untrack grace period to 15 mins (after change/close/disconnect from map)
+
+## [v1.90.8](https://github.com/wanderer-industries/wanderer/compare/v1.90.7...v1.90.8) (2025-12-15)
+
+
+
+
+### Bug Fixes:
+
+* core: skip systems or connections cleanup for not started maps
+
+## [v1.90.7](https://github.com/wanderer-industries/wanderer/compare/v1.90.6...v1.90.7) (2025-12-15)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed scopes
+
+## [v1.90.6](https://github.com/wanderer-industries/wanderer/compare/v1.90.5...v1.90.6) (2025-12-12)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed map scopes
+
+## [v1.90.5](https://github.com/wanderer-industries/wanderer/compare/v1.90.4...v1.90.5) (2025-12-12)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed map scopes
+
+## [v1.90.4](https://github.com/wanderer-industries/wanderer/compare/v1.90.3...v1.90.4) (2025-12-12)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed map scopes & signatures clean up behaviour
+
+## [v1.90.3](https://github.com/wanderer-industries/wanderer/compare/v1.90.2...v1.90.3) (2025-12-11)
+
+
+
+
+### Bug Fixes:
+
+* core: added pagination for long ACL lists
+
+## [v1.90.2](https://github.com/wanderer-industries/wanderer/compare/v1.90.1...v1.90.2) (2025-12-10)
+
+
+
+
+### Bug Fixes:
+
+* core: added system position updates to SSE
+
+## [v1.90.1](https://github.com/wanderer-industries/wanderer/compare/v1.90.0...v1.90.1) (2025-12-08)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed connections and signatures remove issues, added comprehensive audit log for auto removed connections and signatures
+
+## [v1.90.0](https://github.com/wanderer-industries/wanderer/compare/v1.89.6...v1.90.0) (2025-12-06)
+
+
+
+
+### Features:
+
+* core: Added several map scopes support (Wh, Hi, Low, Null, Pochven)
+
+### Bug Fixes:
+
+* core: fixed clean up for linked signatures
+
+* core: fixed issue with default select mode
+
+* apiV1 default fields updates
+
+## [v1.89.6](https://github.com/wanderer-industries/wanderer/compare/v1.89.5...v1.89.6) (2025-12-02)
+
+
+
+
+### Bug Fixes:
+
+* kills: fixed zkb links (added "allow-popups-to-escape-sandbox" to CSP)
+
+## [v1.89.5](https://github.com/wanderer-industries/wanderer/compare/v1.89.4...v1.89.5) (2025-12-02)
+
+
+
+
+## [v1.89.4](https://github.com/wanderer-industries/wanderer/compare/v1.89.3...v1.89.4) (2025-12-02)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed acl character update issues
+
+## [v1.89.3](https://github.com/wanderer-industries/wanderer/compare/v1.89.2...v1.89.3) (2025-11-30)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed tracking issues
+
+## [v1.89.2](https://github.com/wanderer-industries/wanderer/compare/v1.89.1...v1.89.2) (2025-11-30)
+
+
+
+
+## [v1.89.1](https://github.com/wanderer-industries/wanderer/compare/v1.89.0...v1.89.1) (2025-11-30)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed tracking issues
+
+## [v1.89.0](https://github.com/wanderer-industries/wanderer/compare/v1.88.13...v1.89.0) (2025-11-30)
+
+
+
+
+### Features:
+
+* removed unnecessary command
+
+* rework wormholes reference
+
+## [v1.88.13](https://github.com/wanderer-industries/wanderer/compare/v1.88.12...v1.88.13) (2025-11-29)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed tracking issues
+
+## [v1.88.12](https://github.com/wanderer-industries/wanderer/compare/v1.88.11...v1.88.12) (2025-11-29)
+
+
+
+
+### Bug Fixes:
+
+* core: fixed c4 -> ns connections auto size issues
+
 ## [v1.88.11](https://github.com/wanderer-industries/wanderer/compare/v1.88.10...v1.88.11) (2025-11-29)
 
 

Makefile

@@ -32,6 +32,56 @@ format f:
 test t:
 	MIX_ENV=test mix test
 
+# Run tests in 4 parallel partitions (useful for CI or faster local runs)
+test-parallel tp:
+	@echo "Running tests in 4 parallel partitions..."
+	@mkdir -p /tmp/wanderer_test_results
+	@rm -f /tmp/wanderer_test_results/partition_*.txt /tmp/wanderer_test_results/exit_*.txt
+	@for i in 1 2 3 4; do \
+		(MIX_TEST_PARTITION=$$i MIX_ENV=test mix test --partitions 4 2>&1; echo $$? > /tmp/wanderer_test_results/exit_$$i.txt) | \
+		tee /tmp/wanderer_test_results/partition_$$i.txt | sed "s/^/[P$$i] /" & \
+	done; \
+	wait
+	@echo ""
+	@echo "========================================"
+	@echo "        TEST RESULTS SUMMARY"
+	@echo "========================================"
+	@total_tests=0; total_failures=0; total_excluded=0; all_passed=true; \
+	for i in 1 2 3 4; do \
+		exit_code=$$(cat /tmp/wanderer_test_results/exit_$$i.txt 2>/dev/null || echo "1"); \
+		if [ "$$exit_code" != "0" ]; then all_passed=false; fi; \
+		summary=$$(grep -E "^[0-9]+ (tests?|doctest)" /tmp/wanderer_test_results/partition_$$i.txt | tail -1 || echo "No results"); \
+		tests=$$(echo "$$summary" | grep -oE "^[0-9]+" || echo "0"); \
+		failures=$$(echo "$$summary" | grep -oE "[0-9]+ failures?" | grep -oE "^[0-9]+" || echo "0"); \
+		excluded=$$(echo "$$summary" | grep -oE "[0-9]+ excluded" | grep -oE "^[0-9]+" || echo "0"); \
+		total_tests=$$((total_tests + tests)); \
+		total_failures=$$((total_failures + failures)); \
+		total_excluded=$$((total_excluded + excluded)); \
+		if [ "$$exit_code" = "0" ]; then \
+			echo "Partition $$i: ✓ $$summary"; \
+		else \
+			echo "Partition $$i: ✗ $$summary (exit code: $$exit_code)"; \
+		fi; \
+	done; \
+	echo "========================================"; \
+	echo "TOTAL: $$total_tests tests, $$total_failures failures, $$total_excluded excluded"; \
+	echo "========================================"; \
+	if [ "$$all_passed" = "true" ]; then \
+		echo "✓ All partitions passed!"; \
+	else \
+		echo "✗ Some partitions failed. Details below:"; \
+		echo ""; \
+		for i in 1 2 3 4; do \
+			exit_code=$$(cat /tmp/wanderer_test_results/exit_$$i.txt 2>/dev/null || echo "1"); \
+			if [ "$$exit_code" != "0" ]; then \
+				echo "======== PARTITION $$i FAILURES ========"; \
+				grep -A 50 "Failures:" /tmp/wanderer_test_results/partition_$$i.txt 2>/dev/null || cat /tmp/wanderer_test_results/partition_$$i.txt; \
+				echo ""; \
+			fi; \
+		done; \
+		exit 1; \
+	fi
+
 coverage cover co:
 	MIX_ENV=test mix test --cover
 

assets/css/app.css

@@ -1001,3 +1001,27 @@ body > div:first-of-type {
 .verticalTabsContainer .p-tabview-panel {
   flex-grow: 1;
 }
+
+/* Blog post CTA links - only in main post content */
+.post-content a {
+  display: inline-block;
+  background: linear-gradient(135deg, #ec4899 0%, #8b5cf6 100%);
+  color: white !important;
+  padding: 0.5rem 1.25rem;
+  border-radius: 0.5rem;
+  text-decoration: none !important;
+  font-weight: 600;
+  transition: all 0.3s ease;
+  box-shadow: 0 4px 15px rgba(236, 72, 153, 0.3);
+}
+
+.post-content a:hover {
+  background: linear-gradient(135deg, #db2777 0%, #7c3aed 100%);
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(236, 72, 153, 0.4);
+}
+
+.post-content a:active {
+  transform: translateY(0);
+  box-shadow: 0 2px 10px rgba(236, 72, 153, 0.3);
+}

assets/js/hooks/Mapper/components/map/hooks/useSolarSystemNode.ts

@@ -72,7 +72,7 @@ export const useSolarSystemNode = (props: NodeProps<MapSolarSystemType>): SolarS
 
   const {
     storedSettings: { interfaceSettings },
-    data: { systemSignatures: mapSystemSignatures },
+    data: { systemSignatures: mapSystemSignatures, pings },
   } = useMapRootState();
 
   const systemStaticInfo = useMemo(() => {
@@ -108,7 +108,6 @@ export const useSolarSystemNode = (props: NodeProps<MapSolarSystemType>): SolarS
       visibleNodes,
       showKSpaceBG,
       isThickConnections,
-      pings,
       systemHighlighted,
     },
     outCommand,

assets/js/hooks/Mapper/components/mapInterface/components/PingsInterface/PingsInterface.tsx

@@ -121,6 +121,7 @@ export const PingsInterface = ({ hasLeftOffset }: PingsInterfaceProps) => {
 
   useEffect(() => {
     if (!ping) {
+      setIsShow(false);
       return;
     }
 
@@ -161,27 +162,26 @@ export const PingsInterface = ({ hasLeftOffset }: PingsInterfaceProps) => {
     };
   }, [interfaceSettings]);
 
-  if (!ping) {
-    return null;
-  }
-
-  const isShowSelectedSystem = selectedSystem != null && selectedSystem !== ping.solar_system_id;
+  const isShowSelectedSystem = ping && selectedSystem != null && selectedSystem !== ping.solar_system_id;
 
+  // Only render Toast when there's a ping
   return (
     <>
-      <Toast
-        position={placement as never}
-        className={clsx('!max-w-[initial] w-[500px]', hasLeftOffset ? offsets.withLeftMenu : offsets.default)}
-        ref={toast}
-        content={({ message }) => (
-          <section
-            className={clsx(
-              'flex flex-col p-3 w-full border border-stone-800 shadow-md animate-fadeInDown rounded-[5px]',
-              'bg-gradient-to-tr from-transparent to-sky-700/60 bg-stone-900/70',
-            )}
-          >
-            <div className="flex gap-3">
-              <i className={clsx('pi text-yellow-500 text-2xl', 'relative top-[2px]', ICONS[ping.type])}></i>
+      {ping && (
+        <Toast
+          key={ping.id}
+          position={placement as never}
+          className={clsx('!max-w-[initial] w-[500px]', hasLeftOffset ? offsets.withLeftMenu : offsets.default)}
+          ref={toast}
+          content={({ message }) => (
+            <section
+              className={clsx(
+                'flex flex-col p-3 w-full border border-stone-800 shadow-md animate-fadeInDown rounded-[5px]',
+                'bg-gradient-to-tr from-transparent to-sky-700/60 bg-stone-900/70',
+              )}
+            >
+              <div className="flex gap-3">
+                <i className={clsx('pi text-yellow-500 text-2xl', 'relative top-[2px]', ICONS[ping.type])}></i>
               <div className="flex flex-col gap-1 w-full">
                 <div className="flex justify-between">
                   <div>
@@ -253,28 +253,33 @@ export const PingsInterface = ({ hasLeftOffset }: PingsInterfaceProps) => {
               {/*/>*/}
             </div>
           </section>
-        )}
-      ></Toast>
+          )}
+        ></Toast>
+      )}
 
-      <WdButton
-        icon="pi pi-bell"
-        severity="warning"
-        aria-label="Notification"
-        size="small"
-        className="w-[33px] h-[33px]"
-        outlined
-        onClick={handleClickShow}
-        disabled={isShow}
-      />
+      {ping && (
+        <>
+          <WdButton
+            icon="pi pi-bell"
+            severity="warning"
+            aria-label="Notification"
+            size="small"
+            className="w-[33px] h-[33px]"
+            outlined
+            onClick={handleClickShow}
+            disabled={isShow}
+          />
 
-      <ConfirmPopup
-        target={cfRef.current}
-        visible={cfVisible}
-        onHide={cfHide}
-        message="Are you sure you want to delete ping?"
-        icon="pi pi-exclamation-triangle text-orange-400"
-        accept={removePing}
-      />
+          <ConfirmPopup
+            target={cfRef.current}
+            visible={cfVisible}
+            onHide={cfHide}
+            message="Are you sure you want to delete ping?"
+            icon="pi pi-exclamation-triangle text-orange-400"
+            accept={removePing}
+          />
+        </>
+      )}
     </>
   );
 };

assets/js/hooks/Mapper/components/mapInterface/components/SystemLinkSignatureDialog/SystemLinkSignatureDialog.tsx

@@ -3,9 +3,9 @@ import { useCallback, useEffect, useMemo, useRef } from 'react';
 
 import { useSystemInfo } from '@/hooks/Mapper/components/hooks';
 import {
-  SOLAR_SYSTEM_CLASS_IDS,
-  SOLAR_SYSTEM_CLASSES_TO_CLASS_GROUPS,
-  WORMHOLES_ADDITIONAL_INFO_BY_SHORT_NAME,
+    SOLAR_SYSTEM_CLASS_IDS,
+    SOLAR_SYSTEM_CLASSES_TO_CLASS_GROUPS,
+    WORMHOLES_ADDITIONAL_INFO_BY_SHORT_NAME,
 } from '@/hooks/Mapper/components/map/constants.ts';
 import { SystemSignaturesContent } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignaturesContent';
 import { K162_TYPES_MAP } from '@/hooks/Mapper/constants.ts';
@@ -91,7 +91,7 @@ export const SystemLinkSignatureDialog = ({ data, setVisible }: SystemLinkSignat
 
           if (k162TypeInfo) {
             // Check if the k162Type matches our target system class
-            return customInfo.k162Type === targetSystemClassGroup;
+            return k162TypeInfo.value.includes(targetSystemClassGroup);
           }
         }
 

assets/js/hooks/Mapper/components/mapRootContent/MapRootContent.tsx

@@ -9,6 +9,7 @@ import { MapContextMenu } from '@/hooks/Mapper/components/mapRootContent/compone
 import { useSkipContextMenu } from '@/hooks/Mapper/hooks/useSkipContextMenu';
 import { MapSettings } from '@/hooks/Mapper/components/mapRootContent/components/MapSettings';
 import { CharacterActivity } from '@/hooks/Mapper/components/mapRootContent/components/CharacterActivity';
+import { WormholeSignaturesDialog } from '@/hooks/Mapper/components/mapRootContent/components/WormholeSignaturesDialog';
 import { useCharacterActivityHandlers } from './hooks/useCharacterActivityHandlers';
 import { TrackingDialog } from '@/hooks/Mapper/components/mapRootContent/components/TrackingDialog';
 import { useMapEventListener } from '@/hooks/Mapper/events';
@@ -34,6 +35,7 @@ export const MapRootContent = ({}: MapRootContentProps) => {
   const [showOnTheMap, setShowOnTheMap] = useState(false);
   const [showMapSettings, setShowMapSettings] = useState(false);
   const [showTrackingDialog, setShowTrackingDialog] = useState(false);
+  const [showWormholeList, setShowWormholeList] = useState(false);
 
   /* Important Notice - this solution needs for use one instance of MapInterface */
   const mapInterface = isReady ? <MapInterface /> : null;
@@ -41,6 +43,7 @@ export const MapRootContent = ({}: MapRootContentProps) => {
   const handleShowOnTheMap = useCallback(() => setShowOnTheMap(true), []);
   const handleShowMapSettings = useCallback(() => setShowMapSettings(true), []);
   const handleShowTrackingDialog = useCallback(() => setShowTrackingDialog(true), []);
+  const handleShowWormholesReference = useCallback(() => setShowWormholeList(true), []);
 
   useMapEventListener(event => {
     if (event.name === Commands.showTracking) {
@@ -65,6 +68,7 @@ export const MapRootContent = ({}: MapRootContentProps) => {
                 onShowOnTheMap={handleShowOnTheMap}
                 onShowMapSettings={handleShowMapSettings}
                 onShowTrackingDialog={handleShowTrackingDialog}
+                onShowWormholesReference={handleShowWormholesReference}
                 additionalContent={<PingsInterface hasLeftOffset />}
               />
             </div>
@@ -79,6 +83,7 @@ export const MapRootContent = ({}: MapRootContentProps) => {
                   onShowOnTheMap={handleShowOnTheMap}
                   onShowMapSettings={handleShowMapSettings}
                   onShowTrackingDialog={handleShowTrackingDialog}
+                  onShowWormholesReference={handleShowWormholesReference}
                 />
               </div>
             </Topbar>
@@ -93,6 +98,7 @@ export const MapRootContent = ({}: MapRootContentProps) => {
         {showTrackingDialog && (
           <TrackingDialog visible={showTrackingDialog} onHide={() => setShowTrackingDialog(false)} />
         )}
+        <WormholeSignaturesDialog visible={showWormholeList} onHide={() => setShowWormholeList(false)} />
 
         {hasOldSettings && <OldSettingsDialog />}
       </Layout>

assets/js/hooks/Mapper/components/mapRootContent/components/MapContextMenu/MapContextMenu.tsx

@@ -12,9 +12,15 @@ export interface MapContextMenuProps {
   onShowOnTheMap?: () => void;
   onShowMapSettings?: () => void;
   onShowTrackingDialog?: () => void;
+  onShowWormholesReference?: () => void;
 }
 
-export const MapContextMenu = ({ onShowOnTheMap, onShowMapSettings, onShowTrackingDialog }: MapContextMenuProps) => {
+export const MapContextMenu = ({
+  onShowOnTheMap,
+  onShowMapSettings,
+  onShowTrackingDialog,
+  onShowWormholesReference,
+}: MapContextMenuProps) => {
   const {
     outCommand,
     storedSettings: { setInterfaceSettings },
@@ -52,6 +58,12 @@ export const MapContextMenu = ({ onShowOnTheMap, onShowMapSettings, onShowTracki
           command: onShowOnTheMap,
           visible: canTrackCharacters,
         },
+        {
+          label: 'Wormholes Ref.',
+          icon: 'pi pi-bullseye',
+          command: onShowWormholesReference,
+          visible: canTrackCharacters,
+        },
         { separator: true, visible: true },
         {
           label: 'Settings',

assets/js/hooks/Mapper/components/mapRootContent/components/RightBar/RightBar.tsx

@@ -14,6 +14,7 @@ interface RightBarProps {
   onShowOnTheMap?: () => void;
   onShowMapSettings?: () => void;
   onShowTrackingDialog?: () => void;
+  onShowWormholesReference?: () => void;
   additionalContent?: ReactNode;
 }
 
@@ -21,6 +22,7 @@ export const RightBar = ({
   onShowOnTheMap,
   onShowMapSettings,
   onShowTrackingDialog,
+  onShowWormholesReference,
   additionalContent,
 }: RightBarProps) => {
   const {
@@ -90,6 +92,16 @@ export const RightBar = ({
                   <i className="pi pi-hashtag"></i>
                 </button>
               </WdTooltipWrapper>
+
+              <WdTooltipWrapper content="Wormholes Reference" position={TooltipPosition.left}>
+                <button
+                  className="btn bg-transparent text-gray-400 hover:text-white border-transparent hover:bg-transparent py-2 h-auto min-h-auto"
+                  type="button"
+                  onClick={onShowWormholesReference}
+                >
+                  <i className="pi pi-bullseye"></i>
+                </button>
+              </WdTooltipWrapper>
             </div>
           </>
         )}

assets/js/hooks/Mapper/components/mapRootContent/components/SignatureSettings/components/SignatureK162TypeSelect/renderK162Type.tsx

@@ -13,6 +13,26 @@ export const renderK162Type = (option: K162Type) => {
     return renderNoValue();
   }
 
+  if (['c1_c2_c3', 'c4_c5'].includes(value)) {
+    const arr = whClassName.split('_');
+
+    return (
+      <div className="flex gap-1 items-center">
+        {arr.map(x => (
+          <WHClassView
+            key={x}
+            classNameWh="!text-[11px] !font-bold"
+            hideWhClassName
+            hideTooltip
+            whClassName={x}
+            noOffset
+            useShortTitle
+          />
+        ))}
+      </div>
+    );
+  }
+
   return (
     <WHClassView
       classNameWh="!text-[11px] !font-bold"

assets/js/hooks/Mapper/components/mapRootContent/components/TrackingDialog/TrackingProvider.tsx

@@ -1,8 +1,9 @@
-import { createContext, useCallback, useContext, useRef, useState } from 'react';
-import { OutCommand, TrackingCharacter } from '@/hooks/Mapper/types';
+import { createContext, useCallback, useContext, useRef, useState, useEffect } from 'react';
+import { Commands, OutCommand, TrackingCharacter } from '@/hooks/Mapper/types';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { IncomingEvent, WithChildren } from '@/hooks/Mapper/types/common.ts';
 import { CommandInCharactersTrackingInfo } from '@/hooks/Mapper/types/commandsIn.ts';
+import { useMapEventListener } from '@/hooks/Mapper/events';
 
 type DiffTrackingInfo = { characterId: string; tracked: boolean };
 
@@ -122,6 +123,14 @@ export const TrackingProvider = ({ children }: WithChildren) => {
     [outCommand],
   );
 
+  // Listen for refresh_tracking_data event (triggered when ACL members change)
+  useMapEventListener(event => {
+    if (event.name === Commands.refreshTrackingData) {
+      loadTracking();
+      return true;
+    }
+  });
+
   return (
     <TrackingContext.Provider
       value={{

assets/js/hooks/Mapper/components/mapRootContent/components/WormholeSignaturesDialog/WormholeSignaturesDialog.tsx

@@ -0,0 +1,170 @@
+import { useMemo, useState } from 'react';
+import { Dialog } from 'primereact/dialog';
+import { DataTable } from 'primereact/datatable';
+import { Column } from 'primereact/column';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { WormholeDataRaw } from '@/hooks/Mapper/types';
+import { RespawnTag, WHClassView } from '@/hooks/Mapper/components/ui-kit';
+import { kgToTons } from '@/hooks/Mapper/utils/kgToTons.ts';
+import { WORMHOLE_CLASS_STYLES, WORMHOLES_ADDITIONAL_INFO } from '@/hooks/Mapper/components/map/constants.ts';
+import clsx from 'clsx';
+import { InputText } from 'primereact/inputtext';
+import { IconField } from 'primereact/iconfield';
+import { InputIcon } from 'primereact/inputicon';
+
+const renderSpawns = (w: WormholeDataRaw) => (
+  <div className="flex gap-1 flex-wrap">
+    {w.src.map(s => {
+      const group = s.split('-')[0];
+      const info = WORMHOLES_ADDITIONAL_INFO[group];
+
+      if (!info) {
+        return (
+          <span
+            key={s}
+            className="px-[4px] py-[1px] rounded bg-stone-800 text-stone-300 text-xs border border-stone-700"
+          >
+            {s}
+          </span>
+        );
+      }
+
+      const cls = WORMHOLE_CLASS_STYLES[String(info.wormholeClassID)] || '';
+      const label = `${info.shortName}`;
+      return (
+        <span
+          key={s}
+          className={clsx(cls, 'px-[4px] py-[1px] rounded text-xs border border-stone-700 bg-stone-900/40')}
+        >
+          {label}
+        </span>
+      );
+    })}
+  </div>
+);
+
+const renderName = (w: WormholeDataRaw) => (
+  <div className="flex items-center gap-2">
+    <WHClassView
+      whClassName={w.name}
+      noOffset
+      useShortTitle
+      classNameWh="overflow-hidden text-ellipsis whitespace-nowrap"
+    />
+  </div>
+);
+
+const renderRespawn = (w: WormholeDataRaw) => (
+  <div className="flex gap-1 flex-wrap">
+    {w.respawn.map(r => (
+      <RespawnTag key={r} value={r} />
+    ))}
+  </div>
+);
+
+export interface WormholeSignaturesDialogProps {
+  visible: boolean;
+  onHide: () => void;
+}
+
+export const WormholeSignaturesDialog = ({ visible, onHide }: WormholeSignaturesDialogProps) => {
+  const {
+    data: { wormholes },
+  } = useMapRootState();
+
+  const [filter, setFilter] = useState('');
+
+  const filtered = useMemo(() => {
+    const q = filter.trim().toLowerCase();
+
+    if (!q) return wormholes;
+
+    return wormholes.filter(w => {
+      const destInfo = WORMHOLES_ADDITIONAL_INFO[w.dest];
+      const spawnsLabels = w.src
+        .map(s => {
+          const group = s.split('-')[0];
+          const info = WORMHOLES_ADDITIONAL_INFO[group];
+          if (!info) return s;
+          return `${info.title} ${info.shortName}`.trim();
+        })
+        .join(' ');
+
+      return [
+        w.name,
+        destInfo?.title,
+        destInfo?.shortName,
+        spawnsLabels,
+        String(w.total_mass),
+        String(w.max_mass_per_jump),
+        w.lifetime,
+        w.respawn.join(','),
+      ]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase()
+        .includes(q);
+    });
+  }, [wormholes, filter]);
+
+  return (
+    <Dialog
+      header="Wormholes Reference"
+      visible={visible}
+      draggable={false}
+      resizable={false}
+      className="w-[950px] h-[600px]"
+      onHide={onHide}
+      contentClassName="!p-0 flex flex-col h-full"
+    >
+      <div className="p-3 flex items-center justify-between gap-2 border-b border-stone-800">
+        <div className="font-semibold text-sm text-stone-200">Reference list of all wormhole types</div>
+        <IconField iconPosition="right">
+          <InputIcon
+            className={clsx('pi pi-times', {
+              ['cursor-pointer text-stone-400 hover:text-stone-200']: filter,
+              ['text-stone-700 opacity-50 cursor-default']: !filter,
+            })}
+            onClick={() => filter && setFilter('')}
+            role="button"
+            aria-label="Clear search"
+            aria-disabled={!filter}
+            title={filter ? 'Clear' : 'Nothing to clear'}
+          />
+          <InputText className="w-64" placeholder="Search" value={filter} onChange={e => setFilter(e.target.value)} />
+        </IconField>
+      </div>
+
+      <div className="flex-1 p-3 overflow-x-hidden">
+        <DataTable value={filtered} size="small" scrollable scrollHeight="flex" stripedRows>
+          <Column header="Type" body={renderName} className="w-[160px]" bodyClassName="whitespace-normal break-words" />
+          <Column header="Spawns In" body={renderSpawns} bodyClassName="whitespace-normal break-words text-[13px]" />
+          <Column
+            field="lifetime"
+            header="Lifetime"
+            className="w-[90px]"
+            bodyClassName="whitespace-normal break-words text-[13px]"
+          />
+          <Column
+            header="Total Mass"
+            className="w-[120px]"
+            body={(w: WormholeDataRaw) => kgToTons(w.total_mass)}
+            bodyClassName="whitespace-normal break-words text-[13px]"
+          />
+          <Column
+            header="Max/jump"
+            className="w-[120px]"
+            body={(w: WormholeDataRaw) => kgToTons(w.max_mass_per_jump)}
+            bodyClassName="whitespace-normal break-words text-[13px]"
+          />
+          <Column
+            header="Respawn"
+            className="w-[150px]"
+            body={renderRespawn}
+            bodyClassName="whitespace-normal break-words text-[13px]"
+          />
+        </DataTable>
+      </div>
+    </Dialog>
+  );
+};

assets/js/hooks/Mapper/components/mapRootContent/components/WormholeSignaturesDialog/index.ts

@@ -0,0 +1 @@
+export * from './WormholeSignaturesDialog';

assets/js/hooks/Mapper/components/ui-kit/RespawnTag.tsx

@@ -0,0 +1,20 @@
+import { Respawn } from '@/hooks/Mapper/types';
+import clsx from 'clsx';
+
+export const WORMHOLE_SPAWN_CLASSES_BG = {
+  [Respawn.static]: 'bg-lime-400/80 text-stone-950',
+  [Respawn.wandering]: 'bg-stone-800',
+  [Respawn.reverse]: 'bg-blue-400 text-stone-950',
+};
+
+type RespawnTagProps = { value: string };
+export const RespawnTag = ({ value }: RespawnTagProps) => (
+  <span
+    className={clsx(
+      'px-[6px] py-[0px] rounded text-stone-300 text-[12px] font-[500] border border-stone-700',
+      WORMHOLE_SPAWN_CLASSES_BG[value as Respawn],
+    )}
+  >
+    {value}
+  </span>
+);

assets/js/hooks/Mapper/components/ui-kit/index.ts

@@ -23,3 +23,4 @@ export * from './MenuItemWithInfo';
 export * from './MarkdownTextViewer.tsx';
 export * from './WdButton.tsx';
 export * from './constants.ts';
+export * from './RespawnTag';

assets/js/hooks/Mapper/constants.ts

@@ -88,6 +88,16 @@ export const K162_TYPES: K162Type[] = [
     value: 'ns',
     whClassName: 'C248',
   },
+  {
+    label: 'C1/C2/C3',
+    value: 'c1_c2_c3',
+    whClassName: 'E004_D382_L477',
+  },
+  {
+    label: 'C4/C5',
+    value: 'c4_c5',
+    whClassName: 'M001_L614',
+  },
   {
     label: 'C1',
     value: 'c1',

assets/js/hooks/Mapper/mapRootProvider/hooks/api/index.ts

@@ -10,3 +10,4 @@ export * from './useCommandComments';
 export * from './useGetCacheCharacter';
 export * from './useCommandsActivity';
 export * from './useCommandPings';
+export * from './useCommandPingBlocked';

assets/js/hooks/Mapper/mapRootProvider/hooks/api/useCommandPingBlocked.ts

@@ -0,0 +1,21 @@
+import { useToast } from '@/hooks/Mapper/ToastProvider';
+import { CommandPingBlocked } from '@/hooks/Mapper/types';
+import { useCallback } from 'react';
+
+export const useCommandPingBlocked = () => {
+  const { show } = useToast();
+
+  const pingBlocked = useCallback(
+    ({ message }: CommandPingBlocked) => {
+      show({
+        severity: 'warn',
+        summary: 'Cannot create ping',
+        detail: message,
+        life: 5000,
+      });
+    },
+    [show],
+  );
+
+  return { pingBlocked };
+};

assets/js/hooks/Mapper/mapRootProvider/hooks/api/useCommandPings.ts

@@ -14,8 +14,8 @@ export const useCommandPings = () => {
     ref.current.update({ pings });
   }, []);
 
-  const pingCancelled = useCallback(({ type, id }: CommandPingCancelled) => {
-    const newPings = ref.current.pings.filter(x => x.id !== id && x.type !== type);
+  const pingCancelled = useCallback(({ id }: CommandPingCancelled) => {
+    const newPings = ref.current.pings.filter(x => x.id !== id);
     ref.current.update({ pings: newPings });
   }, []);
 

assets/js/hooks/Mapper/mapRootProvider/hooks/useComments.ts

@@ -63,7 +63,6 @@ export const useComments = ({ outCommand }: UseCommentsProps): UseCommentsData =
 
   const removeComment = useCallback((systemId: number, commentId: string) => {
     const cSystem = commentBySystemsRef.current.get(systemId);
-    console.log('cSystem', cSystem);
     if (!cSystem) {
       return;
     }

assets/js/hooks/Mapper/mapRootProvider/hooks/useMapRootHandlers.ts

@@ -12,6 +12,7 @@ import {
   CommandLinkSignatureToSystem,
   CommandMapUpdated,
   CommandPingAdded,
+  CommandPingBlocked,
   CommandPingCancelled,
   CommandPresentCharacters,
   CommandRemoveConnections,
@@ -29,6 +30,7 @@ import { ForwardedRef, useImperativeHandle } from 'react';
 
 import {
   useCommandComments,
+  useCommandPingBlocked,
   useCommandPings,
   useCommandsCharacters,
   useCommandsConnections,
@@ -61,129 +63,128 @@ export const useMapRootHandlers = (ref: ForwardedRef<MapHandlers>) => {
   const mapUserRoutes = useUserRoutes();
   const { addComment, removeComment } = useCommandComments();
   const { pingAdded, pingCancelled } = useCommandPings();
+  const { pingBlocked } = useCommandPingBlocked();
   const { characterActivityData, trackingCharactersData, userSettingsUpdated } = useCommandsActivity();
 
-  useImperativeHandle(
-    ref,
-    () => {
-      return {
-        command(type, data) {
-          switch (type) {
-            case Commands.init: // USED
-              mapInit(data as CommandInit);
-              break;
-            case Commands.addSystems: // USED
-              addSystems(data as CommandAddSystems);
-              break;
-            case Commands.updateSystems: // USED
-              updateSystems(data as CommandUpdateSystems);
-              break;
-            case Commands.removeSystems: // USED
-              removeSystems(data as CommandRemoveSystems);
-              break;
-            case Commands.addConnections: // USED
-              addConnections(data as CommandAddConnections);
-              break;
-            case Commands.removeConnections: // USED
-              removeConnections(data as CommandRemoveConnections);
-              break;
-            case Commands.updateConnection: // USED
-              updateConnection(data as CommandUpdateConnection);
-              break;
-            case Commands.charactersUpdated: // USED
-              charactersUpdated(data as CommandCharactersUpdated);
-              break;
-            case Commands.characterAdded: // USED
-              characterAdded(data as CommandCharacterAdded);
-              break;
-            case Commands.characterRemoved: // USED
-              characterRemoved(data as CommandCharacterRemoved);
-              break;
-            case Commands.characterUpdated: // USED
-              characterUpdated(data as CommandCharacterUpdated);
-              break;
-            case Commands.presentCharacters: // USED
-              presentCharacters(data as CommandPresentCharacters);
-              break;
-            case Commands.mapUpdated: // USED
-              mapUpdated(data as CommandMapUpdated);
-              break;
-            case Commands.routes:
-              mapRoutes(data as CommandRoutes);
-              break;
-            case Commands.userRoutes:
-              mapUserRoutes(data as CommandRoutes);
-              break;
+  useImperativeHandle(ref, () => {
+    return {
+      command(type, data) {
+        switch (type) {
+          case Commands.init: // USED
+            mapInit(data as CommandInit);
+            break;
+          case Commands.addSystems: // USED
+            addSystems(data as CommandAddSystems);
+            break;
+          case Commands.updateSystems: // USED
+            updateSystems(data as CommandUpdateSystems);
+            break;
+          case Commands.removeSystems: // USED
+            removeSystems(data as CommandRemoveSystems);
+            break;
+          case Commands.addConnections: // USED
+            addConnections(data as CommandAddConnections);
+            break;
+          case Commands.removeConnections: // USED
+            removeConnections(data as CommandRemoveConnections);
+            break;
+          case Commands.updateConnection: // USED
+            updateConnection(data as CommandUpdateConnection);
+            break;
+          case Commands.charactersUpdated: // USED
+            charactersUpdated(data as CommandCharactersUpdated);
+            break;
+          case Commands.characterAdded: // USED
+            characterAdded(data as CommandCharacterAdded);
+            break;
+          case Commands.characterRemoved: // USED
+            characterRemoved(data as CommandCharacterRemoved);
+            break;
+          case Commands.characterUpdated: // USED
+            characterUpdated(data as CommandCharacterUpdated);
+            break;
+          case Commands.presentCharacters: // USED
+            presentCharacters(data as CommandPresentCharacters);
+            break;
+          case Commands.mapUpdated: // USED
+            mapUpdated(data as CommandMapUpdated);
+            break;
+          case Commands.routes:
+            mapRoutes(data as CommandRoutes);
+            break;
+          case Commands.userRoutes:
+            mapUserRoutes(data as CommandRoutes);
+            break;
 
-            case Commands.signaturesUpdated: // USED
-              updateSystemSignatures(data as CommandSignaturesUpdated);
-              break;
+          case Commands.signaturesUpdated: // USED
+            updateSystemSignatures(data as CommandSignaturesUpdated);
+            break;
 
-            case Commands.linkSignatureToSystem: // USED
-              setTimeout(() => {
-                updateLinkSignatureToSystem(data as CommandLinkSignatureToSystem);
-              }, 200);
-              break;
+          case Commands.linkSignatureToSystem: // USED
+            setTimeout(() => {
+              updateLinkSignatureToSystem(data as CommandLinkSignatureToSystem);
+            }, 200);
+            break;
 
-            case Commands.centerSystem: // USED
-              // do nothing here
-              break;
+          case Commands.centerSystem: // USED
+            // do nothing here
+            break;
 
-            case Commands.selectSystem: // USED
-              // do nothing here
-              break;
+          case Commands.selectSystem: // USED
+            // do nothing here
+            break;
 
-            case Commands.killsUpdated:
-              // do nothing here
-              break;
+          case Commands.killsUpdated:
+            // do nothing here
+            break;
 
-            case Commands.detailedKillsUpdated:
-              updateDetailedKills(data as Record<string, DetailedKill[]>);
-              break;
+          case Commands.detailedKillsUpdated:
+            updateDetailedKills(data as Record<string, DetailedKill[]>);
+            break;
 
-            case Commands.characterActivityData:
-              characterActivityData(data as CommandCharacterActivityData);
-              break;
+          case Commands.characterActivityData:
+            characterActivityData(data as CommandCharacterActivityData);
+            break;
 
-            case Commands.trackingCharactersData:
-              trackingCharactersData(data as CommandTrackingCharactersData);
-              break;
+          case Commands.trackingCharactersData:
+            trackingCharactersData(data as CommandTrackingCharactersData);
+            break;
 
-            case Commands.updateActivity:
-              break;
+          case Commands.updateActivity:
+            break;
 
-            case Commands.updateTracking:
-              break;
+          case Commands.updateTracking:
+            break;
 
-            case Commands.userSettingsUpdated:
-              userSettingsUpdated(data as CommandUserSettingsUpdated);
-              break;
+          case Commands.userSettingsUpdated:
+            userSettingsUpdated(data as CommandUserSettingsUpdated);
+            break;
 
-            case Commands.systemCommentAdded:
-              addComment(data as CommandCommentAdd);
-              break;
+          case Commands.systemCommentAdded:
+            addComment(data as CommandCommentAdd);
+            break;
 
-            case Commands.systemCommentRemoved:
-              removeComment(data as CommandCommentRemoved);
-              break;
+          case Commands.systemCommentRemoved:
+            removeComment(data as CommandCommentRemoved);
+            break;
 
-            case Commands.pingAdded:
-              pingAdded(data as CommandPingAdded);
-              break;
+          case Commands.pingAdded:
+            pingAdded(data as CommandPingAdded);
+            break;
 
-            case Commands.pingCancelled:
-              pingCancelled(data as CommandPingCancelled);
-              break;
+          case Commands.pingCancelled:
+            pingCancelled(data as CommandPingCancelled);
+            break;
+          case Commands.pingBlocked:
+            pingBlocked(data as CommandPingBlocked);
+            break;
+          default:
+            console.warn(`JOipP Interface handlers: Unknown command: ${type}`, data);
+            break;
+        }
 
-            default:
-              console.warn(`JOipP Interface handlers: Unknown command: ${type}`, data);
-              break;
-          }
-
-          emitMapEvent({ name: type, data });
-        },
-      };
-    },
-    [],
-  );
+        emitMapEvent({ name: type, data });
+      },
+    };
+  }, []);
 };

assets/js/hooks/Mapper/types/mapHandlers.ts

@@ -38,8 +38,10 @@ export enum Commands {
   updateTracking = 'update_tracking',
   userSettingsUpdated = 'user_settings_updated',
   showTracking = 'show_tracking',
+  refreshTrackingData = 'refresh_tracking_data',
   pingAdded = 'ping_added',
   pingCancelled = 'ping_cancelled',
+  pingBlocked = 'ping_blocked',
 }
 
 export type Command =
@@ -74,8 +76,10 @@ export type Command =
   | Commands.updateActivity
   | Commands.updateTracking
   | Commands.showTracking
+  | Commands.refreshTrackingData
   | Commands.pingAdded
-  | Commands.pingCancelled;
+  | Commands.pingCancelled
+  | Commands.pingBlocked;
 
 export type CommandInit = {
   systems: SolarSystemRawType[];
@@ -145,6 +149,7 @@ export type CommandUserSettingsUpdated = {
 };
 
 export type CommandShowTracking = null;
+export type CommandRefreshTrackingData = Record<string, never>;
 export type CommandUpdateActivity = {
   characterId: number;
   systemId: number;
@@ -158,6 +163,10 @@ export type CommandUpdateTracking = {
 };
 export type CommandPingAdded = PingData[];
 export type CommandPingCancelled = Pick<PingData, 'type' | 'id'>;
+export type CommandPingBlocked = {
+  reason: string;
+  message: string;
+};
 
 export interface UserSettings {
   primaryCharacterId?: string;
@@ -206,8 +215,10 @@ export interface CommandData {
   [Commands.systemCommentRemoved]: CommandCommentRemoved;
   [Commands.systemCommentsUpdated]: unknown;
   [Commands.showTracking]: CommandShowTracking;
+  [Commands.refreshTrackingData]: CommandRefreshTrackingData;
   [Commands.pingAdded]: CommandPingAdded;
   [Commands.pingCancelled]: CommandPingCancelled;
+  [Commands.pingBlocked]: CommandPingBlocked;
 }
 
 export interface MapHandlers {

assets/js/hooks/newVersionUpdate.ts

@@ -57,7 +57,7 @@ export default {
     };
 
     refreshZone.addEventListener('click', handleUpdate);
-    refreshZone.addEventListener('mouseover', handleUpdate);
+    // refreshZone.addEventListener('mouseover', handleUpdate);
 
     this.updated();
   },

config/runtime.exs

@@ -92,6 +92,31 @@ map_subscription_extra_hubs_10_price =
   config_dir
   |> get_int_from_path_or_env("WANDERER_MAP_SUBSCRIPTION_EXTRA_HUBS_10_PRICE", 10_000_000)
 
+# Parse promo codes from environment variable
+# Format: "CODE1:10,CODE2:20" where numbers are discount percentages
+promo_codes =
+  config_dir
+  |> get_var_from_path_or_env("WANDERER_PROMO_CODES", "")
+  |> case do
+    "" ->
+      %{}
+
+    codes_string ->
+      codes_string
+      |> String.split(",")
+      |> Enum.map(fn entry ->
+        case String.split(String.trim(entry), ":") do
+          [code, discount] ->
+            {String.upcase(String.trim(code)), String.to_integer(String.trim(discount))}
+
+          _ ->
+            nil
+        end
+      end)
+      |> Enum.reject(&is_nil/1)
+      |> Map.new()
+  end
+
 map_connection_auto_expire_hours =
   config_dir
   |> get_int_from_path_or_env("WANDERER_MAP_CONNECTION_AUTO_EXPIRE_HOURS", 24)
@@ -176,7 +201,8 @@ config :wanderer_app,
       }
     ],
     extra_characters_50: map_subscription_extra_characters_50_price,
-    extra_hubs_10: map_subscription_extra_hubs_10_price
+    extra_hubs_10: map_subscription_extra_hubs_10_price,
+    promo_codes: promo_codes
   },
   # Finch pool configuration - separate pools for different services
   # ESI Character Tracking pool - high capacity for bulk character operations
@@ -264,7 +290,7 @@ config :logger,
         case config_env() do
           :prod -> "info"
           :dev -> "info"
-          :test -> "debug"
+          :test -> "warning"
         end
       )
     )

lib/wanderer_app/api/access_list.ex

@@ -16,6 +16,11 @@ defmodule WandererApp.Api.AccessList do
 
     includes([:owner, :members])
 
+    default_fields([
+      :name,
+      :description
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -79,12 +84,15 @@ defmodule WandererApp.Api.AccessList do
 
     attribute :name, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :description, :string do
       allow_nil? true
+      public? true
     end
 
+    # Note: api_key intentionally not public for security
     attribute :api_key, :string do
       allow_nil? true
     end

lib/wanderer_app/api/access_list_member.ex

@@ -16,6 +16,14 @@ defmodule WandererApp.Api.AccessListMember do
 
     includes([:access_list])
 
+    default_fields([
+      :name,
+      :eve_character_id,
+      :eve_corporation_id,
+      :eve_alliance_id,
+      :role
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -89,22 +97,27 @@ defmodule WandererApp.Api.AccessListMember do
 
     attribute :name, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :eve_character_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :eve_corporation_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :eve_alliance_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :role, :atom do
       default "viewer"
+      public? true
 
       constraints(
         one_of: [

lib/wanderer_app/api/changes/inject_map_from_actor.ex

@@ -19,9 +19,10 @@ defmodule WandererApp.Api.Changes.InjectMapFromActor do
       _other ->
         # nil or unexpected return shape - check for direct map_id
         # Check params (input), arguments, and attributes (in that order)
-        map_id = Map.get(changeset.params, :map_id) ||
-                 Ash.Changeset.get_argument(changeset, :map_id) ||
-                 Ash.Changeset.get_attribute(changeset, :map_id)
+        map_id =
+          Map.get(changeset.params, :map_id) ||
+            Ash.Changeset.get_argument(changeset, :map_id) ||
+            Ash.Changeset.get_attribute(changeset, :map_id)
 
         case map_id do
           nil ->

lib/wanderer_app/api/map.ex

@@ -13,6 +13,8 @@ defmodule WandererApp.Api.Map do
   postgres do
     repo(WandererApp.Repo)
     table("maps_v1")
+
+    migration_defaults scopes: "'{wormholes}'"
   end
 
   json_api do
@@ -65,6 +67,8 @@ defmodule WandererApp.Api.Map do
     )
 
     define(:duplicate, action: :duplicate)
+    define(:admin_all, action: :admin_all)
+    define(:restore, action: :restore)
   end
 
   calculations do
@@ -105,12 +109,19 @@ defmodule WandererApp.Api.Map do
       prepare WandererApp.Api.Preparations.FilterMapsByRoles
     end
 
+    read :admin_all do
+      # Admin-only action that bypasses FilterMapsByRoles
+      # Returns ALL maps including soft-deleted ones with owner and ACLs loaded
+      prepare build(load: [:owner, :acls])
+    end
+
     create :new do
       accept [
         :name,
         :slug,
         :description,
         :scope,
+        :scopes,
         :only_tracked_characters,
         :owner_id,
         :sse_enabled
@@ -135,6 +146,7 @@ defmodule WandererApp.Api.Map do
         :slug,
         :description,
         :scope,
+        :scopes,
         :only_tracked_characters,
         :owner_id,
         :sse_enabled
@@ -190,6 +202,14 @@ defmodule WandererApp.Api.Map do
       change(set_attribute(:deleted, true))
     end
 
+    update :restore do
+      # Admin-only action to restore a soft-deleted map
+      accept([])
+      require_atomic? false
+
+      change(set_attribute(:deleted, false))
+    end
+
     update :update_api_key do
       accept [:public_api_key]
       require_atomic? false
@@ -209,7 +229,7 @@ defmodule WandererApp.Api.Map do
     end
 
     create :duplicate do
-      accept [:name, :description, :scope, :only_tracked_characters]
+      accept [:name, :description, :scope, :scopes, :only_tracked_characters]
       argument :source_map_id, :uuid, allow_nil?: false
       argument :copy_acls, :boolean, default: true
       argument :copy_user_settings, :boolean, default: true
@@ -225,9 +245,14 @@ defmodule WandererApp.Api.Map do
             description =
               Ash.Changeset.get_attribute(changeset, :description) || source_map.description
 
+            # Use provided scopes or fall back to source map scopes
+            scopes =
+              Ash.Changeset.get_attribute(changeset, :scopes) || source_map.scopes
+
             changeset
             |> Ash.Changeset.change_attribute(:description, description)
             |> Ash.Changeset.change_attribute(:scope, source_map.scope)
+            |> Ash.Changeset.change_attribute(:scopes, scopes)
             |> Ash.Changeset.change_attribute(
               :only_tracked_characters,
               source_map.only_tracked_characters
@@ -359,6 +384,24 @@ defmodule WandererApp.Api.Map do
       public?(true)
     end
 
+    attribute :scopes, {:array, :atom} do
+      default([:wormholes])
+      allow_nil?(true)
+      public?(true)
+
+      constraints(
+        items: [
+          one_of: [
+            :wormholes,
+            :hi,
+            :low,
+            :null,
+            :pochven
+          ]
+        ]
+      )
+    end
+
     create_timestamp(:inserted_at)
     update_timestamp(:updated_at)
   end

lib/wanderer_app/api/map_character_settings.ex

@@ -27,6 +27,11 @@ defmodule WandererApp.Api.MapCharacterSettings do
 
     includes([:map, :character])
 
+    default_fields([
+      :tracked,
+      :followed
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -219,14 +224,17 @@ defmodule WandererApp.Api.MapCharacterSettings do
 
     attribute :tracked, :boolean do
       default false
+      public? true
       allow_nil? true
     end
 
     attribute :followed, :boolean do
       default false
+      public? true
       allow_nil? true
     end
 
+    # Note: These attributes are encrypted (AshCloak) and intentionally not public
     attribute :solar_system_id, :integer
     attribute :structure_id, :integer
     attribute :station_id, :integer

lib/wanderer_app/api/map_connection.ex

@@ -22,6 +22,19 @@ defmodule WandererApp.Api.MapConnection do
 
     includes([:map])
 
+    default_fields([
+      :solar_system_source,
+      :solar_system_target,
+      :mass_status,
+      :time_status,
+      :ship_size_type,
+      :type,
+      :wormhole_type,
+      :count_of_passage,
+      :locked,
+      :custom_info
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -197,15 +210,20 @@ defmodule WandererApp.Api.MapConnection do
   attributes do
     uuid_primary_key :id
 
-    attribute :solar_system_source, :integer
-    attribute :solar_system_target, :integer
+    attribute :solar_system_source, :integer do
+      public? true
+    end
+
+    attribute :solar_system_target, :integer do
+      public? true
+    end
 
     # where 0 - greater than half
     # where 1 - less than half
     # where 2 - critical less than 10%
     attribute :mass_status, :integer do
       default(0)
-
+      public? true
       allow_nil?(true)
     end
 
@@ -218,7 +236,7 @@ defmodule WandererApp.Api.MapConnection do
     # 6 - EOL 48h
     attribute :time_status, :integer do
       default(0)
-
+      public? true
       allow_nil?(true)
     end
 
@@ -229,7 +247,7 @@ defmodule WandererApp.Api.MapConnection do
     # where 4 - Capital
     attribute :ship_size_type, :integer do
       default(2)
-
+      public? true
       allow_nil?(true)
     end
 
@@ -238,21 +256,26 @@ defmodule WandererApp.Api.MapConnection do
     # where 2 - Bridge
     attribute :type, :integer do
       default(0)
-
+      public? true
       allow_nil?(true)
     end
 
-    attribute :wormhole_type, :string
+    attribute :wormhole_type, :string do
+      public? true
+    end
 
     attribute :count_of_passage, :integer do
       default(0)
-
+      public? true
       allow_nil?(true)
     end
 
-    attribute :locked, :boolean
+    attribute :locked, :boolean do
+      public? true
+    end
 
     attribute :custom_info, :string do
+      public? true
       allow_nil? true
     end
 

lib/wanderer_app/api/map_default_settings.ex

@@ -23,6 +23,10 @@ defmodule WandererApp.Api.MapDefaultSettings do
       :updated_by
     ])
 
+    default_fields([
+      :settings
+    ])
+
     routes do
       base("/map_default_settings")
 
@@ -93,6 +97,7 @@ defmodule WandererApp.Api.MapDefaultSettings do
 
     attribute :settings, :string do
       allow_nil? false
+      public? true
       constraints min_length: 2
       description "JSON string containing the default map settings"
     end

lib/wanderer_app/api/map_ping.ex

@@ -80,6 +80,10 @@ defmodule WandererApp.Api.MapPing do
 
       filter(expr(inserted_at <= ^arg(:inserted_before)))
     end
+
+    # Admin action for cleanup - no actor filtering
+    read :all_pings do
+    end
   end
 
   attributes do

lib/wanderer_app/api/map_subscription.ex

@@ -18,6 +18,15 @@ defmodule WandererApp.Api.MapSubscription do
       :map
     ])
 
+    default_fields([
+      :plan,
+      :status,
+      :characters_limit,
+      :hubs_limit,
+      :active_till,
+      :auto_renew?
+    ])
+
     # Enable automatic filtering and sorting
     derive_filter?(true)
     derive_sort?(true)
@@ -135,6 +144,7 @@ defmodule WandererApp.Api.MapSubscription do
 
     attribute :plan, :atom do
       default "alpha"
+      public? true
 
       constraints(
         one_of: [
@@ -150,6 +160,7 @@ defmodule WandererApp.Api.MapSubscription do
 
     attribute :status, :atom do
       default "active"
+      public? true
 
       constraints(
         one_of: [
@@ -164,22 +175,24 @@ defmodule WandererApp.Api.MapSubscription do
 
     attribute :characters_limit, :integer do
       default(100)
-
+      public? true
       allow_nil?(true)
     end
 
     attribute :hubs_limit, :integer do
       default(10)
-
+      public? true
       allow_nil?(true)
     end
 
     attribute :active_till, :utc_datetime do
       allow_nil? true
+      public? true
     end
 
     attribute :auto_renew?, :boolean do
       allow_nil? false
+      public? true
     end
 
     create_timestamp(:inserted_at)

lib/wanderer_app/api/map_system_comment.ex

@@ -19,6 +19,10 @@ defmodule WandererApp.Api.MapSystemComment do
       :character
     ])
 
+    default_fields([
+      :text
+    ])
+
     routes do
       base("/map_system_comments")
 
@@ -73,6 +77,7 @@ defmodule WandererApp.Api.MapSystemComment do
 
     attribute :text, :string do
       allow_nil? false
+      public? true
     end
 
     create_timestamp(:inserted_at)

lib/wanderer_app/api/map_system_signature.ex

@@ -16,6 +16,20 @@ defmodule WandererApp.Api.MapSystemSignature do
 
     includes([:system])
 
+    default_fields([
+      :eve_id,
+      :character_eve_id,
+      :name,
+      :description,
+      :temporary_name,
+      :type,
+      :linked_system_id,
+      :kind,
+      :group,
+      :custom_info,
+      :deleted
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -109,7 +123,8 @@ defmodule WandererApp.Api.MapSystemSignature do
         :group,
         :type,
         :custom_info,
-        :deleted
+        :deleted,
+        :linked_system_id
       ]
     end
 
@@ -126,7 +141,8 @@ defmodule WandererApp.Api.MapSystemSignature do
         :type,
         :custom_info,
         :deleted,
-        :update_forced_at
+        :update_forced_at,
+        :linked_system_id
       ]
 
       primary? true
@@ -184,42 +200,56 @@ defmodule WandererApp.Api.MapSystemSignature do
 
     attribute :eve_id, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :character_eve_id, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :name, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :description, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :temporary_name, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :type, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :linked_system_id, :integer do
       allow_nil? true
+      public? true
     end
 
-    attribute :kind, :string
-    attribute :group, :string
+    attribute :kind, :string do
+      public? true
+    end
+
+    attribute :group, :string do
+      public? true
+    end
 
     attribute :custom_info, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :deleted, :boolean do
       allow_nil? false
       default false
+      public? true
     end
 
     attribute :update_forced_at, :utc_datetime do

lib/wanderer_app/api/map_system_structure.ex

@@ -41,6 +41,21 @@ defmodule WandererApp.Api.MapSystemStructure do
       :system
     ])
 
+    default_fields([
+      :structure_type_id,
+      :structure_type,
+      :character_eve_id,
+      :solar_system_name,
+      :solar_system_id,
+      :name,
+      :notes,
+      :owner_name,
+      :owner_ticker,
+      :owner_id,
+      :status,
+      :end_time
+    ])
+
     # Enable automatic filtering and sorting
     derive_filter?(true)
     derive_sort?(true)
@@ -151,50 +166,62 @@ defmodule WandererApp.Api.MapSystemStructure do
 
     attribute :structure_type_id, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :structure_type, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :character_eve_id, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :solar_system_name, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :solar_system_id, :integer do
       allow_nil? false
+      public? true
     end
 
     attribute :name, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :notes, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :owner_name, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :owner_ticker, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :owner_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :status, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :end_time, :utc_datetime_usec do
       allow_nil? true
+      public? true
     end
 
     create_timestamp :inserted_at

lib/wanderer_app/api/map_user_settings.ex

@@ -24,6 +24,13 @@ defmodule WandererApp.Api.MapUserSettings do
       :user
     ])
 
+    default_fields([
+      :settings,
+      :main_character_eve_id,
+      :following_character_eve_id,
+      :hubs
+    ])
+
     routes do
       base("/map_user_settings")
 
@@ -85,19 +92,22 @@ defmodule WandererApp.Api.MapUserSettings do
 
     attribute :settings, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :main_character_eve_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :following_character_eve_id, :string do
       allow_nil? true
+      public? true
     end
 
     attribute :hubs, {:array, :string} do
       allow_nil?(true)
-
+      public? true
       default([])
     end
   end

lib/wanderer_app/api/user_activity.ex

@@ -31,6 +31,13 @@ defmodule WandererApp.Api.UserActivity do
 
     includes([:character, :user])
 
+    default_fields([
+      :entity_id,
+      :entity_type,
+      :event_type,
+      :event_data
+    ])
+
     derive_filter?(true)
     derive_sort?(true)
 
@@ -86,10 +93,12 @@ defmodule WandererApp.Api.UserActivity do
 
     attribute :entity_id, :string do
       allow_nil? false
+      public? true
     end
 
     attribute :entity_type, :atom do
       default "map"
+      public? true
 
       constraints(
         one_of: [
@@ -104,6 +113,7 @@ defmodule WandererApp.Api.UserActivity do
 
     attribute :event_type, :atom do
       default "custom"
+      public? true
 
       constraints(
         one_of: [
@@ -153,7 +163,9 @@ defmodule WandererApp.Api.UserActivity do
       allow_nil?(false)
     end
 
-    attribute :event_data, :string
+    attribute :event_data, :string do
+      public? true
+    end
 
     create_timestamp(:inserted_at)
     update_timestamp(:updated_at)

lib/wanderer_app/cache.ex

@@ -45,7 +45,7 @@ defmodule WandererApp.Cache do
   def insert({id, key}, value, opts) when is_binary(id) and (is_binary(key) or is_atom(key)),
     do: insert("#{id}:#{key}", value, opts)
 
-  def insert(key, nil, opts) when is_binary(key) or is_atom(key), do: delete(key)
+  def insert(key, nil, _opts) when is_binary(key) or is_atom(key), do: delete(key)
   def insert(key, value, opts) when is_binary(key) or is_atom(key), do: put(key, value, opts)
 
   def insert_or_update(key, value, update_fn, opts \\ [])

lib/wanderer_app/character/tracker.ex

@@ -598,9 +598,6 @@ defmodule WandererApp.Character.Tracker do
 
                 {:error, :skipped}
             end
-
-          _ ->
-            {:error, :skipped}
         end
 
       _ ->
@@ -734,6 +731,14 @@ defmodule WandererApp.Character.Tracker do
       {:character_alliance, {character_id, character_update}}
     )
 
+    # Broadcast permission update to trigger LiveView refresh
+    # This ensures users are kicked off maps they no longer have access to
+    @pubsub_client.broadcast(
+      WandererApp.PubSub,
+      "character:#{character.eve_id}",
+      :update_permissions
+    )
+
     state
     |> Map.merge(%{alliance_id: nil})
   end
@@ -772,6 +777,14 @@ defmodule WandererApp.Character.Tracker do
               {:character_alliance, {character_id, character_update}}
             )
 
+            # Broadcast permission update to trigger LiveView refresh
+            # This ensures users are kicked off maps they no longer have access to
+            @pubsub_client.broadcast(
+              WandererApp.PubSub,
+              "character:#{character.eve_id}",
+              :update_permissions
+            )
+
             state
             |> Map.merge(%{alliance_id: alliance_id})
 
@@ -799,7 +812,7 @@ defmodule WandererApp.Character.Tracker do
         corporation_id
         |> WandererApp.Esi.get_corporation_info()
         |> case do
-          {:ok, %{"name" => corporation_name, "ticker" => corporation_ticker} = corporation_info} ->
+          {:ok, %{"name" => corporation_name, "ticker" => corporation_ticker}} ->
             {:ok, character} =
               WandererApp.Character.get_character(character_id)
 
@@ -826,6 +839,14 @@ defmodule WandererApp.Character.Tracker do
                 }}}
             )
 
+            # Broadcast permission update to trigger LiveView refresh
+            # This ensures users are kicked off maps they no longer have access to
+            @pubsub_client.broadcast(
+              WandererApp.PubSub,
+              "character:#{character.eve_id}",
+              :update_permissions
+            )
+
             state
             |> Map.merge(%{corporation_id: corporation_id})
 
@@ -1002,7 +1023,7 @@ defmodule WandererApp.Character.Tracker do
   defp maybe_update_active_maps(
          %{character_id: character_id, active_maps: active_maps} =
            state,
-         %{map_id: map_id, track: true} = track_settings
+         %{map_id: map_id, track: true}
        ) do
     if not Enum.member?(active_maps, map_id) do
       WandererApp.Cache.put(

lib/wanderer_app/character/tracker_manager_impl.ex

@@ -40,10 +40,12 @@ defmodule WandererApp.Character.TrackerManager.Impl do
     Process.send_after(self(), :garbage_collect, @garbage_collection_interval)
     Process.send_after(self(), :untrack_characters, @untrack_characters_interval)
 
-    Logger.debug("[TrackerManager] Initialized with intervals: " <>
-      "garbage_collection=#{div(@garbage_collection_interval, 60_000)}min, " <>
-      "untrack=#{div(@untrack_characters_interval, 60_000)}min, " <>
-      "inactive_timeout=#{div(@inactive_character_timeout, 60_000)}min")
+    Logger.debug(
+      "[TrackerManager] Initialized with intervals: " <>
+        "garbage_collection=#{div(@garbage_collection_interval, 60_000)}min, " <>
+        "untrack=#{div(@untrack_characters_interval, 60_000)}min, " <>
+        "inactive_timeout=#{div(@inactive_character_timeout, 60_000)}min"
+    )
 
     %{
       characters: [],
@@ -57,7 +59,9 @@ defmodule WandererApp.Character.TrackerManager.Impl do
     WandererApp.Cache.insert("tracked_characters", [])
 
     if length(tracked_characters) > 0 do
-      Logger.debug("[TrackerManager] Restoring #{length(tracked_characters)} tracked characters from cache")
+      Logger.debug(
+        "[TrackerManager] Restoring #{length(tracked_characters)} tracked characters from cache"
+      )
     end
 
     tracked_characters
@@ -151,10 +155,23 @@ defmodule WandererApp.Character.TrackerManager.Impl do
 
       remove_from_untrack_queue(map_id, character_id)
 
-      {:ok, character_state} =
-        WandererApp.Character.Tracker.update_settings(character_id, track_settings)
+      case WandererApp.Character.Tracker.update_settings(character_id, track_settings) do
+        {:ok, character_state} ->
+          WandererApp.Character.update_character_state(character_id, character_state)
 
-      WandererApp.Character.update_character_state(character_id, character_state)
+        {:error, :not_found} ->
+          # Tracker process not running yet - this is expected during initial tracking setup
+          # The tracking_start_time cache key was already set by TrackingUtils.track_character
+          Logger.debug(fn ->
+            "[TrackerManager] Tracker not yet running for character #{character_id} - " <>
+              "tracking will be active via cache key"
+          end)
+
+        {:error, reason} ->
+          Logger.warning(fn ->
+            "[TrackerManager] Failed to update settings for character #{character_id}: #{inspect(reason)}"
+          end)
+      end
     else
       Logger.debug(fn ->
         "[TrackerManager] Queuing character #{character_id} for untracking from map #{map_id} - " <>
@@ -184,6 +201,7 @@ defmodule WandererApp.Character.TrackerManager.Impl do
       [],
       fn untrack_queue ->
         original_length = length(untrack_queue)
+
         filtered =
           untrack_queue
           |> Enum.reject(fn {m_id, c_id} -> m_id == map_id and c_id == character_id end)

lib/wanderer_app/character/tracker_pool_dynamic_supervisor.ex

@@ -88,15 +88,4 @@ defmodule WandererApp.Character.TrackerPoolDynamicSupervisor do
         {:ok, pid}
     end
   end
-
-  defp stop_child(uuid) do
-    case Registry.lookup(@registry, uuid) do
-      [{pid, _}] ->
-        GenServer.cast(pid, :stop)
-
-      _ ->
-        Logger.warn("Unable to locate pool assigned to #{inspect(uuid)}")
-        :ok
-    end
-  end
 end

lib/wanderer_app/character/tracking_config_utils.ex

@@ -38,7 +38,7 @@ defmodule WandererApp.Character.TrackingConfigUtils do
       %{id: "default", title: "Default", value: default_count}
     ]
 
-    {:ok, pools_count} =
+    {:ok, _pools_count} =
       Cachex.get(
         :esi_auth_cache,
         "configs_total_count"

lib/wanderer_app/character/tracking_utils.ex

@@ -53,24 +53,27 @@ defmodule WandererApp.Character.TrackingUtils do
 
   @doc """
   Builds tracking data for all characters with access to a map.
+  Only includes characters that have actual tracking permission.
   """
   def build_tracking_data(map_id, current_user_id) do
-    with {:ok, map} <-
-           WandererApp.MapRepo.get(map_id,
-             acls: [
-               :owner_id,
-               members: [:role, :eve_character_id, :eve_corporation_id, :eve_alliance_id]
-             ]
-           ),
+    with {:ok, map} <- WandererApp.MapRepo.get(map_id),
          {:ok, user_settings} <- WandererApp.MapUserSettingsRepo.get(map_id, current_user_id),
          {:ok, %{characters: characters_with_access}} <-
            WandererApp.Maps.load_characters(map, current_user_id) do
+      # Filter to only characters with actual tracking permission
+      characters_with_tracking_permission =
+        filter_characters_with_tracking_permission(characters_with_access, map)
+
       # Map characters to tracking data
       {:ok, characters_data} =
-        build_character_tracking_data(characters_with_access)
+        build_character_tracking_data(characters_with_tracking_permission)
 
       {:ok, main_character} =
-        get_main_character(user_settings, characters_with_access, characters_with_access)
+        get_main_character(
+          user_settings,
+          characters_with_tracking_permission,
+          characters_with_tracking_permission
+        )
 
       following_character_eve_id =
         case user_settings do
@@ -112,6 +115,70 @@ defmodule WandererApp.Character.TrackingUtils do
      end)}
   end
 
+  # Filter characters to only include those with actual tracking permission
+  # This prevents showing characters in the tracking dialog that will fail when toggled
+  defp filter_characters_with_tracking_permission(characters, %{id: map_id, owner_id: owner_id}) do
+    # Load ACLs with members properly (same approach as get_map_characters)
+    acls = load_map_acls_with_members(map_id)
+
+    Enum.filter(characters, fn character ->
+      has_tracking_permission?(character, owner_id, acls)
+    end)
+  end
+
+  # Load ACLs with members in the correct format for permission checking
+  defp load_map_acls_with_members(map_id) do
+    case WandererApp.Api.MapAccessList.read_by_map(%{map_id: map_id},
+           load: [access_list: [:owner, :members]]
+         ) do
+      {:ok, map_access_lists} ->
+        map_access_lists
+        |> Enum.map(fn mal -> mal.access_list end)
+        |> Enum.reject(&is_nil/1)
+
+      _ ->
+        []
+    end
+  end
+
+  # Check if a character has tracking permission on a map
+  # Returns true if the character can be tracked, false otherwise
+  defp has_tracking_permission?(character, owner_id, acls) do
+    cond do
+      # Map owner always has tracking permission
+      character.id == owner_id ->
+        true
+
+      # Character belongs to same user as map owner
+      # Note: character data from load_characters may not have user_id, so we need to load it
+      check_same_user_as_owner_by_id(character.id, owner_id) ->
+        true
+
+      # Check ACL-based permissions
+      true ->
+        case WandererApp.Permissions.check_characters_access([character], acls) do
+          [character_permissions] ->
+            map_permissions = WandererApp.Permissions.get_permissions(character_permissions)
+            map_permissions.track_character and map_permissions.view_system
+
+          _ ->
+            false
+        end
+    end
+  end
+
+  # Check if character belongs to the same user as the map owner (by character IDs)
+  defp check_same_user_as_owner_by_id(_character_id, nil), do: false
+
+  defp check_same_user_as_owner_by_id(character_id, owner_id) do
+    with {:ok, character} <- WandererApp.Character.get_character(character_id),
+         {:ok, owner_character} <- WandererApp.Character.get_character(owner_id) do
+      character.user_id != nil and character.user_id == owner_character.user_id
+    else
+      _ -> false
+    end
+  end
+
   # Private implementation of update character tracking
   defp do_update_character_tracking(character, map_id, track, caller_pid) do
     # First check current tracking state to avoid unnecessary permission checks
@@ -126,7 +193,13 @@ defmodule WandererApp.Character.TrackingUtils do
       {true, settings_result} ->
         case check_character_tracking_permission(character, map_id) do
           {:ok, :allowed} ->
-            do_update_character_tracking_impl(character, map_id, track, caller_pid, settings_result)
+            do_update_character_tracking_impl(
+              character,
+              map_id,
+              track,
+              caller_pid,
+              settings_result
+            )
 
           {:error, reason} ->
             Logger.warning(
@@ -212,6 +285,9 @@ defmodule WandererApp.Character.TrackingUtils do
       {:ok, %{tracked: false} = existing_settings} ->
         if track do
           {:ok, updated_settings} = WandererApp.MapCharacterSettingsRepo.track(existing_settings)
+          # Ensure character is in map state (fixes race condition where character
+          # might not be synced yet from presence updates)
+          :ok = WandererApp.Map.add_character(map_id, character)
           :ok = track([character], map_id, true, caller_pid)
           {:ok, updated_settings}
         else
@@ -228,6 +304,9 @@ defmodule WandererApp.Character.TrackingUtils do
               tracked: true
             })
 
+          # Add character to map state immediately (fixes race condition where
+          # character wouldn't appear on map until next update_presence cycle)
+          :ok = WandererApp.Map.add_character(map_id, character)
           :ok = track([character], map_id, true, caller_pid)
           {:ok, settings}
         else
@@ -290,6 +369,31 @@ defmodule WandererApp.Character.TrackingUtils do
 
     if is_track_allowed do
       :ok = WandererApp.Character.TrackerManager.start_tracking(character_id)
+
+      # Immediately set tracking_start_time cache key to enable map tracking
+      # This ensures the character is tracked for updates even before the
+      # Tracker process is fully started (avoids race condition)
+      tracking_start_key = "character:#{character_id}:map:#{map_id}:tracking_start_time"
+
+      case WandererApp.Cache.lookup(tracking_start_key) do
+        {:ok, nil} ->
+          WandererApp.Cache.put(tracking_start_key, DateTime.utc_now())
+
+          # Clear stale location caches for fresh tracking
+          WandererApp.Cache.delete("map:#{map_id}:character:#{character_id}:solar_system_id")
+          WandererApp.Cache.delete("map:#{map_id}:character:#{character_id}:station_id")
+          WandererApp.Cache.delete("map:#{map_id}:character:#{character_id}:structure_id")
+
+        _ ->
+          # Already tracking, no need to update
+          :ok
+      end
+
+      # Also call update_track_settings to update character state when tracker is ready
+      WandererApp.Character.TrackerManager.update_track_settings(character_id, %{
+        map_id: map_id,
+        track: true
+      })
     end
 
     :ok

lib/wanderer_app/env.ex

@@ -42,6 +42,35 @@ defmodule WandererApp.Env do
   def corp_eve_id(), do: get_key(:corp_id, -1)
   def subscription_settings(), do: get_key(:subscription_settings)
 
+  @doc """
+  Returns the promo code configuration map.
+  Keys are uppercase code strings, values are discount percentages.
+  """
+  def promo_codes() do
+    case subscription_settings() do
+      %{promo_codes: codes} when is_map(codes) -> codes
+      _ -> %{}
+    end
+  end
+
+  @doc """
+  Validates a promo code and returns the discount percentage.
+  Returns {:ok, discount_percent} if valid, {:error, :invalid_code} otherwise.
+  Codes are case-insensitive.
+  """
+  def validate_promo_code(nil), do: {:error, :invalid_code}
+  def validate_promo_code(""), do: {:error, :invalid_code}
+
+  def validate_promo_code(code) when is_binary(code) do
+    normalized = String.upcase(String.trim(code))
+
+    case Map.get(promo_codes(), normalized) do
+      nil -> {:error, :invalid_code}
+      discount when is_integer(discount) and discount > 0 and discount <= 100 -> {:ok, discount}
+      _ -> {:error, :invalid_code}
+    end
+  end
+
   @decorate cacheable(
               cache: WandererApp.Cache,
               key: "restrict_maps_creation"

lib/wanderer_app/esi/api_client.ex

@@ -8,7 +8,6 @@ defmodule WandererApp.Esi.ApiClient do
   @ttl :timer.hours(1)
 
   @wanderrer_user_agent "(wanderer-industries@proton.me; +https://github.com/wanderer-industries/wanderer)"
-  @req_esi_options [base_url: "https://esi.evetech.net", finch: WandererApp.Finch]
 
   @cache_opts [cache: true]
   @retry_opts [retry: false, retry_log_level: :warning]
@@ -74,7 +73,7 @@ defmodule WandererApp.Esi.ApiClient do
         |> Keyword.merge(@timeout_opts)
       )
 
-  def get_routes_eve(hubs, origin, params, opts),
+  def get_routes_eve(hubs, origin, _params, _opts),
     do:
       {:ok,
        hubs
@@ -101,33 +100,6 @@ defmodule WandererApp.Esi.ApiClient do
          end
        end)}
 
-  defp do_get_routes_eve(origin, destination, params, opts) do
-    esi_params =
-      Map.merge(params, %{
-        connections: params.connections |> Enum.join(","),
-        avoid: params.avoid |> Enum.join(",")
-      })
-
-    do_get(
-      "/route/#{origin}/#{destination}/?#{esi_params |> Plug.Conn.Query.encode()}",
-      opts,
-      @cache_opts
-    )
-    |> case do
-      {:ok, result} ->
-        %{
-          "origin" => origin,
-          "destination" => destination,
-          "systems" => result,
-          "success" => true
-        }
-
-      error ->
-        Logger.warning("Error getting routes: #{inspect(error)}")
-        %{"origin" => origin, "destination" => destination, "systems" => [], "success" => false}
-    end
-  end
-
   @decorate cacheable(
               cache: Cache,
               key: "group-info-#{group_id}",
@@ -273,6 +245,8 @@ defmodule WandererApp.Esi.ApiClient do
               opts: [ttl: @ttl]
             )
   defp get_search(character_eve_id, search_val, categories_val, merged_opts) do
+    # Note: search_val and categories_val are used by the @decorate cacheable annotation above
+    _unused = {search_val, categories_val}
     get_character_auth_data(character_eve_id, "search", merged_opts)
   end
 
@@ -348,7 +322,7 @@ defmodule WandererApp.Esi.ApiClient do
   defp with_cache_opts(opts),
     do: opts |> Keyword.merge(@cache_opts) |> Keyword.merge(cache_dir: System.tmp_dir!())
 
-  defp do_get(path, api_opts \\ [], opts \\ [], pool \\ @general_pool) do
+  defp do_get(path, api_opts, opts, pool \\ @general_pool) do
     case Cachex.get(:api_cache, path) do
       {:ok, cached_data} when not is_nil(cached_data) ->
         {:ok, cached_data}
@@ -358,7 +332,7 @@ defmodule WandererApp.Esi.ApiClient do
     end
   end
 
-  defp do_get_request(path, api_opts \\ [], opts \\ [], pool \\ @general_pool) do
+  defp do_get_request(path, api_opts, opts, pool) do
     try do
       req_options_for_pool(pool)
       |> Req.new()
@@ -448,7 +422,7 @@ defmodule WandererApp.Esi.ApiClient do
         {:ok, %{status: status} = _error} when status in [401, 403] ->
           do_get_retry(path, api_opts, opts)
 
-        {:ok, %{status: status, headers: headers}} ->
+        {:ok, %{status: status}} ->
           {:error, "Unexpected status: #{status}"}
 
         {:error, %Mint.TransportError{reason: :timeout}} ->
@@ -832,10 +806,10 @@ defmodule WandererApp.Esi.ApiClient do
 
   defp handle_refresh_token_result(
          {:error, %OAuth2.Error{reason: :econnrefused} = error},
-         character,
+         _character,
          character_id,
          expires_at,
-         scopes
+         _scopes
        ) do
     expires_at_datetime = DateTime.from_unix!(expires_at)
     time_since_expiry = DateTime.diff(DateTime.utc_now(), expires_at_datetime, :second)

lib/wanderer_app/eve_data_service.ex

@@ -7,7 +7,8 @@ defmodule WandererApp.EveDataService do
 
   alias WandererApp.Utils.JSONUtil
 
-  @eve_db_dump_url "https://www.fuzzwork.co.uk/dump/latest"
+  # @eve_db_dump_url "https://www.fuzzwork.co.uk/dump/latest"
+  @eve_db_dump_url "https://wanderer-industries.github.io/wanderer-assets/sde-files"
 
   @dump_file_names [
     "invGroups.csv",
@@ -393,9 +394,6 @@ defmodule WandererApp.EveDataService do
     end
   end
 
-  defp get_solar_system_name(solar_system_name, wormhole_class) do
-  end
-
   defp get_triglavian_data(default_data, triglavian_systems, solar_system_id) do
     case Enum.find(triglavian_systems, fn system -> system.solar_system_id == solar_system_id end) do
       nil ->
@@ -413,8 +411,12 @@ defmodule WandererApp.EveDataService do
 
   defp get_security(security) do
     case security do
-      nil -> {:ok, ""}
-      _ -> {:ok, String.to_float(security) |> get_true_security() |> Float.to_string(decimals: 1)}
+      nil ->
+        {:ok, ""}
+
+      _ ->
+        {:ok,
+         String.to_float(security) |> get_true_security() |> :erlang.float_to_binary(decimals: 1)}
     end
   end
 
@@ -496,23 +498,23 @@ defmodule WandererApp.EveDataService do
     do: {:ok, 10_100}
 
   defp get_wormhole_class_id(systems, region_id, constellation_id, solar_system_id) do
-    with region <-
-           Enum.find(systems, fn system ->
-             system.location_id |> Integer.parse() |> elem(0) == region_id
-           end),
-         constellation <-
-           Enum.find(systems, fn system ->
-             system.location_id |> Integer.parse() |> elem(0) == constellation_id
-           end),
-         solar_system <-
-           Enum.find(systems, fn system ->
-             system.location_id |> Integer.parse() |> elem(0) == solar_system_id
-           end),
-         wormhole_class_id <- get_wormhole_class_id(region, constellation, solar_system) do
-      {:ok, wormhole_class_id}
-    else
-      _ -> {:ok, -1}
-    end
+    region =
+      Enum.find(systems, fn system ->
+        system.location_id |> Integer.parse() |> elem(0) == region_id
+      end)
+
+    constellation =
+      Enum.find(systems, fn system ->
+        system.location_id |> Integer.parse() |> elem(0) == constellation_id
+      end)
+
+    solar_system =
+      Enum.find(systems, fn system ->
+        system.location_id |> Integer.parse() |> elem(0) == solar_system_id
+      end)
+
+    wormhole_class_id = get_wormhole_class_id(region, constellation, solar_system)
+    {:ok, wormhole_class_id}
   end
 
   defp get_wormhole_class_id(_region, _constellation, solar_system)

lib/wanderer_app/external_events/event.ex

@@ -178,6 +178,10 @@ defmodule WandererApp.ExternalEvents.Event do
     end
   end
 
+  defp serialize_payload(payload, visited) when is_map(payload) do
+    Map.new(payload, fn {k, v} -> {to_string(k), serialize_value(v, visited)} end)
+  end
+
   # Get allowed fields based on struct type
   defp get_allowed_fields(module) do
     module_name = module |> Module.split() |> List.last()
@@ -192,10 +196,6 @@ defmodule WandererApp.ExternalEvents.Event do
     end
   end
 
-  defp serialize_payload(payload, visited) when is_map(payload) do
-    Map.new(payload, fn {k, v} -> {to_string(k), serialize_value(v, visited)} end)
-  end
-
   defp serialize_fields(fields, visited) do
     Enum.reduce(fields, %{}, fn {k, v}, acc ->
       if is_nil(v) do

lib/wanderer_app/external_events/json_api_formatter.ex

@@ -98,8 +98,8 @@ defmodule WandererApp.ExternalEvents.JsonApiFormatter do
       "id" => payload["system_id"] || payload[:system_id],
       "attributes" => %{
         "locked" => payload["locked"] || payload[:locked],
-        "x" => payload["x"] || payload[:x],
-        "y" => payload["y"] || payload[:y],
+        "position_x" => payload["position_x"] || payload[:position_x],
+        "position_y" => payload["position_y"] || payload[:position_y],
         "updated_at" => event.timestamp
       },
       "relationships" => %{

lib/wanderer_app/kills/client.ex

@@ -182,7 +182,7 @@ defmodule WandererApp.Kills.Client do
   end
 
   # Guard against duplicate disconnection events
-  def handle_info({:disconnected, reason}, %{connected: false, connecting: false} = state) do
+  def handle_info({:disconnected, _reason}, %{connected: false, connecting: false} = state) do
     {:noreply, state}
   end
 
@@ -566,7 +566,7 @@ defmodule WandererApp.Kills.Client do
     end
   end
 
-  defp check_health(%{socket_pid: pid} = state) do
+  defp check_health(%{socket_pid: pid}) do
     if socket_alive?(pid) do
       :healthy
     else
@@ -590,22 +590,6 @@ defmodule WandererApp.Kills.Client do
     Process.send_after(self(), :health_check, @health_check_interval)
   end
 
-  defp handle_connection_lost(%{connected: false} = _state) do
-    Logger.debug("[Client] Connection already lost, skipping cleanup")
-  end
-
-  defp handle_connection_lost(state) do
-    Logger.warning("[Client] Connection lost, cleaning up and reconnecting")
-
-    # Clean up existing socket
-    if state.socket_pid do
-      disconnect_socket(state.socket_pid)
-    end
-
-    # Reset state and trigger reconnection
-    send(self(), {:disconnected, :connection_lost})
-  end
-
   # Handler module for WebSocket events
   defmodule Handler do
     @moduledoc """
@@ -640,7 +624,7 @@ defmodule WandererApp.Kills.Client do
       }
 
       case GenSocketClient.join(transport, "killmails:lobby", join_params) do
-        {:ok, response} ->
+        {:ok, _response} ->
           send(state.parent, {:connected, self()})
           # Reset disconnected flag on successful connection
           {:ok, %{state | disconnected: false}}

lib/wanderer_app/kills/map_event_listener.ex

@@ -46,7 +46,7 @@ defmodule WandererApp.Kills.MapEventListener do
   end
 
   @impl true
-  def handle_info(%{event: :map_server_started, payload: map_info}, state) do
+  def handle_info(%{event: :map_server_started, payload: _map_info}, state) do
     {:noreply, schedule_subscription_update(state)}
   end
 
@@ -191,7 +191,7 @@ defmodule WandererApp.Kills.MapEventListener do
             # Client is not connected, retry with backoff
             schedule_retry_update(state)
 
-          error ->
+          _error ->
             schedule_retry_update(state)
         end
       rescue

lib/wanderer_app/map.ex

@@ -12,6 +12,7 @@ defmodule WandererApp.Map do
   defstruct map_id: nil,
             name: nil,
             scope: :none,
+            scopes: nil,
             owner_id: nil,
             characters: [],
             systems: Map.new(),
@@ -22,11 +23,18 @@ defmodule WandererApp.Map do
             characters_limit: nil,
             hubs_limit: nil
 
-  def new(%{id: map_id, name: name, scope: scope, owner_id: owner_id, acls: acls, hubs: hubs}) do
+  def new(
+        %{id: map_id, name: name, scope: scope, owner_id: owner_id, acls: acls, hubs: hubs} =
+          input
+      ) do
+    # Extract the new scopes array field if present (nil if not set)
+    scopes = Map.get(input, :scopes)
+
     map =
       struct!(__MODULE__,
         map_id: map_id,
         scope: scope,
+        scopes: scopes,
         owner_id: owner_id,
         name: name,
         acls: acls,
@@ -177,7 +185,7 @@ defmodule WandererApp.Map do
   end
 
   def list_hubs(map_id, hubs) do
-    {:ok, map} = map_id |> get_map()
+    {:ok, _map} = map_id |> get_map()
 
     {:ok, hubs}
   end
@@ -315,7 +323,7 @@ defmodule WandererApp.Map do
     end
   end
 
-  def update_subscription_settings!(%{map_id: map_id} = map, %{
+  def update_subscription_settings!(%{map_id: map_id} = _map, %{
         characters_limit: characters_limit,
         hubs_limit: hubs_limit
       }) do
@@ -326,7 +334,7 @@ defmodule WandererApp.Map do
     |> get_map!()
   end
 
-  def update_options!(%{map_id: map_id} = map, options) do
+  def update_options!(%{map_id: map_id} = _map, options) do
     map_id
     |> update_map(%{options: options})
 

lib/wanderer_app/map/map_manager.ex

@@ -16,7 +16,7 @@ defmodule WandererApp.Map.Manager do
   @maps_queue :maps_queue
   @check_maps_queue_interval :timer.seconds(1)
 
-  @pings_cleanup_interval :timer.minutes(10)
+  @pings_cleanup_interval :timer.minutes(5)
   @pings_expire_minutes 60
 
   # Test-aware async task runner
@@ -99,6 +99,7 @@ defmodule WandererApp.Map.Manager do
   def handle_info(:cleanup_pings, state) do
     try do
       cleanup_expired_pings()
+      cleanup_orphaned_pings()
       {:noreply, state}
     rescue
       e ->
@@ -141,6 +142,55 @@ defmodule WandererApp.Map.Manager do
     end
   end
 
+  defp cleanup_orphaned_pings() do
+    case WandererApp.MapPingsRepo.get_orphaned_pings() do
+      {:ok, []} ->
+        :ok
+
+      {:ok, orphaned_pings} ->
+        Logger.info(
+          "[cleanup_orphaned_pings] Found #{length(orphaned_pings)} orphaned pings, cleaning up..."
+        )
+
+        Enum.each(orphaned_pings, fn %{id: ping_id, map_id: map_id, type: type, system: system} =
+                                       ping ->
+          reason =
+            cond do
+              is_nil(ping.system) -> "system deleted"
+              is_nil(ping.character) -> "character deleted"
+              is_nil(ping.map) -> "map deleted"
+              not is_nil(system) and system.visible == false -> "system hidden (visible=false)"
+              true -> "unknown"
+            end
+
+          Logger.warning(
+            "[cleanup_orphaned_pings] Destroying orphaned ping #{ping_id} (map_id: #{map_id}, reason: #{reason})"
+          )
+
+          # Broadcast cancellation if map_id is still valid
+          if map_id do
+            Server.Impl.broadcast!(map_id, :ping_cancelled, %{
+              id: ping_id,
+              solar_system_id: nil,
+              type: type
+            })
+          end
+
+          Ash.destroy!(ping)
+        end)
+
+        Logger.info(
+          "[cleanup_orphaned_pings] Cleaned up #{length(orphaned_pings)} orphaned pings"
+        )
+
+        :ok
+
+      {:error, error} ->
+        Logger.error("Failed to fetch orphaned pings: #{inspect(error)}")
+        {:error, error}
+    end
+  end
+
   defp start_maps() do
     chunks =
       @maps_queue

lib/wanderer_app/map/map_operations.ex

@@ -76,11 +76,6 @@ defmodule WandererApp.Map.Operations do
           {:ok, map()} | {:skip, :exists} | {:error, String.t()}
   defdelegate create_connection(map_id, attrs, char_id), to: Connections
 
-  @doc "Create a connection from a Plug.Conn"
-  @spec create_connection(Plug.Conn.t(), map()) ::
-          {:ok, :created} | {:skip, :exists} | {:error, atom()}
-  defdelegate create_connection(conn, attrs), to: Connections
-
   @doc "Update a connection"
   @spec update_connection(String.t(), String.t(), map()) ::
           {:ok, map()} | {:error, String.t()}
@@ -131,4 +126,12 @@ defmodule WandererApp.Map.Operations do
   @doc "Delete a signature in a map"
   @spec delete_signature(String.t(), String.t()) :: :ok | {:error, String.t()}
   defdelegate delete_signature(map_id, sig_id), to: Signatures
+
+  @doc "Link a signature to a target system"
+  @spec link_signature(Plug.Conn.t(), String.t(), map()) :: {:ok, map()} | {:error, atom()}
+  defdelegate link_signature(conn, sig_id, params), to: Signatures
+
+  @doc "Unlink a signature from its target system"
+  @spec unlink_signature(Plug.Conn.t(), String.t()) :: {:ok, map()} | {:error, atom()}
+  defdelegate unlink_signature(conn, sig_id), to: Signatures
 end

lib/wanderer_app/map/map_pool.ex

@@ -329,6 +329,9 @@ defmodule WandererApp.Map.MapPool do
     end
   end
 
+  @impl true
+  def handle_call(:error, _, state), do: {:stop, :error, :ok, state}
+
   defp do_start_map(map_id, %{map_ids: map_ids, uuid: uuid} = state) do
     if map_id in map_ids do
       # Map already started
@@ -344,8 +347,6 @@ defmodule WandererApp.Map.MapPool do
             [map_id | r_map_ids]
           end)
 
-        completed_operations = [:registry | completed_operations]
-
         case registry_result do
           {new_value, _old_value} when is_list(new_value) ->
             :ok
@@ -363,13 +364,9 @@ defmodule WandererApp.Map.MapPool do
             raise "Failed to add to cache: #{inspect(reason)}"
         end
 
-        completed_operations = [:cache | completed_operations]
-
         # Step 3: Start the map server using extracted helper
         do_initialize_map_server(map_id)
 
-        completed_operations = [:map_server | completed_operations]
-
         # Step 4: Update GenServer state (last, as this is in-memory and fast)
         new_state = %{state | map_ids: [map_id | map_ids]}
 
@@ -445,8 +442,6 @@ defmodule WandererApp.Map.MapPool do
           r_map_ids |> Enum.reject(fn id -> id == map_id end)
         end)
 
-      completed_operations = [:registry | completed_operations]
-
       case registry_result do
         {new_value, _old_value} when is_list(new_value) ->
           :ok
@@ -464,14 +459,10 @@ defmodule WandererApp.Map.MapPool do
           raise "Failed to delete from cache: #{inspect(reason)}"
       end
 
-      completed_operations = [:cache | completed_operations]
-
       # Step 3: Stop the map server (clean up all map resources)
       map_id
       |> Server.Impl.stop_map()
 
-      completed_operations = [:map_server | completed_operations]
-
       # Step 4: Update GenServer state (last, as this is in-memory and fast)
       new_state = %{state | map_ids: map_ids |> Enum.reject(fn id -> id == map_id end)}
 
@@ -560,9 +551,6 @@ defmodule WandererApp.Map.MapPool do
     # and the cleanup operations are safe to leave in a "stopped" state
   end
 
-  @impl true
-  def handle_call(:error, _, state), do: {:stop, :error, :ok, state}
-
   @impl true
   def handle_info(:backup_state, %{map_ids: map_ids, uuid: uuid} = state) do
     Process.send_after(self(), :backup_state, @backup_state_timeout)

lib/wanderer_app/map/map_pool_dynamic_supervisor.ex

@@ -179,15 +179,4 @@ defmodule WandererApp.Map.MapPoolDynamicSupervisor do
         {:ok, pid}
     end
   end
-
-  defp stop_child(uuid) do
-    case Registry.lookup(@registry, uuid) do
-      [{pid, _}] ->
-        GenServer.cast(pid, :stop)
-
-      _ ->
-        Logger.warn("Unable to locate pool assigned to #{inspect(uuid)}")
-        :ok
-    end
-  end
 end

lib/wanderer_app/map/map_routes.ex

@@ -77,7 +77,7 @@ defmodule WandererApp.Map.Routes do
     end
   end
 
-  def find(_map_id, hubs, origin, routes_settings, true) do
+  def find(_map_id, hubs, origin, _routes_settings, true) do
     origin = origin |> String.to_integer()
     hubs = hubs |> Enum.map(&(&1 |> String.to_integer()))
 

lib/wanderer_app/map/map_subscription_manager.ex

@@ -72,28 +72,36 @@ defmodule WandererApp.Map.SubscriptionManager do
     :ok
   end
 
+  def estimate_price(params, renew?, promo_code \\ nil)
+
   def estimate_price(
         %{
           "period" => period,
           "characters_limit" => characters_limit,
           "hubs_limit" => hubs_limit
-        },
-        renew?
+        } = params,
+        renew?,
+        promo_code
       )
-      when is_binary(characters_limit),
-      do:
-        estimate_price(
-          %{
-            period: period |> String.to_integer(),
-            characters_limit: characters_limit |> String.to_integer(),
-            hubs_limit: hubs_limit |> String.to_integer()
-          },
-          renew?
-        )
+      when is_binary(characters_limit) do
+    # Extract promo_code from params if passed there (from form)
+    promo_code = promo_code || Map.get(params, "promo_code")
+
+    estimate_price(
+      %{
+        period: period |> String.to_integer(),
+        characters_limit: characters_limit |> String.to_integer(),
+        hubs_limit: hubs_limit |> String.to_integer()
+      },
+      renew?,
+      promo_code
+    )
+  end
 
   def estimate_price(
         %{characters_limit: characters_limit, hubs_limit: hubs_limit} = params,
-        renew?
+        renew?,
+        promo_code
       ) do
     %{
       plans: plans,
@@ -136,7 +144,7 @@ defmodule WandererApp.Map.SubscriptionManager do
 
     total_price = estimated_price * period
 
-    {:ok, discount} =
+    {:ok, period_discount} =
       calc_discount(
         period,
         total_price,
@@ -144,13 +152,27 @@ defmodule WandererApp.Map.SubscriptionManager do
         renew?
       )
 
-    {:ok, total_price, discount}
+    # Calculate promo discount on price after period discount
+    price_after_period_discount = total_price - period_discount
+
+    {:ok, promo_discount, promo_valid?} =
+      calc_promo_discount(promo_code, price_after_period_discount)
+
+    total_discount = period_discount + promo_discount
+
+    {:ok, total_price, total_discount, promo_valid?}
   end
 
+  def calc_additional_price(params, selected_subscription, promo_code \\ nil)
+
   def calc_additional_price(
-        %{"characters_limit" => characters_limit, "hubs_limit" => hubs_limit},
-        selected_subscription
+        %{"characters_limit" => characters_limit, "hubs_limit" => hubs_limit} = params,
+        selected_subscription,
+        promo_code
       ) do
+    # Extract promo_code from params if passed there (from form)
+    promo_code = promo_code || Map.get(params, "promo_code")
+
     %{
       plans: plans,
       extra_characters_50: extra_characters_50,
@@ -189,7 +211,7 @@ defmodule WandererApp.Map.SubscriptionManager do
 
     total_price = additional_price * period
 
-    {:ok, discount} =
+    {:ok, period_discount} =
       calc_discount(
         period,
         total_price,
@@ -197,7 +219,15 @@ defmodule WandererApp.Map.SubscriptionManager do
         false
       )
 
-    {:ok, total_price, discount}
+    # Calculate promo discount on price after period discount
+    price_after_period_discount = total_price - period_discount
+
+    {:ok, promo_discount, promo_valid?} =
+      calc_promo_discount(promo_code, price_after_period_discount)
+
+    total_discount = period_discount + promo_discount
+
+    {:ok, total_price, total_discount, promo_valid?}
   end
 
   defp get_active_months(subscription) do
@@ -255,6 +285,22 @@ defmodule WandererApp.Map.SubscriptionManager do
        when period >= 3,
        do: {:ok, round(total_price * month_3_discount)}
 
+  # Calculates the promo code discount amount.
+  # Returns {:ok, discount_amount, is_valid?}
+  defp calc_promo_discount(nil, _price), do: {:ok, 0, false}
+  defp calc_promo_discount("", _price), do: {:ok, 0, false}
+
+  defp calc_promo_discount(promo_code, price) when is_binary(promo_code) do
+    case WandererApp.Env.validate_promo_code(promo_code) do
+      {:ok, discount_percent} ->
+        discount_amount = round(price * discount_percent / 100)
+        {:ok, discount_amount, true}
+
+      {:error, :invalid_code} ->
+        {:ok, 0, false}
+    end
+  end
+
   def get_balance(map) do
     map
     |> WandererApp.MapRepo.load_relationships([
@@ -302,7 +348,8 @@ defmodule WandererApp.Map.SubscriptionManager do
 
   defp renew_subscription(%{auto_renew?: true, map: map} = subscription)
        when is_map(subscription) do
-    with {:ok, estimated_price, discount} <- estimate_price(subscription, true),
+    # No promo code for auto-renewals, ignore the promo_valid? return value
+    with {:ok, estimated_price, discount, _promo_valid?} <- estimate_price(subscription, true),
          {:ok, map_balance} <- get_balance(map) do
       case map_balance >= estimated_price do
         true ->

lib/wanderer_app/map/operations/connections.ex

@@ -63,13 +63,31 @@ defmodule WandererApp.Map.Operations.Connections do
     if is_nil(src_info) or is_nil(tgt_info) do
       {:error, :invalid_system_info}
     else
+      # Get wormhole_type for ship size inference
+      wormhole_type = attrs["wormhole_type"]
+
+      # Build extra_info map with optional connection attributes
+      extra_info =
+        %{}
+        |> maybe_add_extra("time_status", attrs["time_status"])
+        |> maybe_add_extra("mass_status", attrs["mass_status"])
+        |> maybe_add_extra("locked", attrs["locked"])
+        |> maybe_add_extra("wormhole_type", wormhole_type)
+
       info = %{
         solar_system_source_id: src_info.solar_system_id,
         solar_system_target_id: tgt_info.solar_system_id,
         character_id: char_id,
         type: parse_type(attrs["type"]),
         ship_size_type:
-          resolve_ship_size(attrs["type"], attrs["ship_size_type"], src_info, tgt_info)
+          resolve_ship_size(
+            attrs["type"],
+            attrs["ship_size_type"],
+            wormhole_type,
+            src_info,
+            tgt_info
+          ),
+        extra_info: if(extra_info == %{}, do: nil, else: extra_info)
       }
 
       case Server.add_connection(map_id, info) do
@@ -93,14 +111,13 @@ defmodule WandererApp.Map.Operations.Connections do
     end
   end
 
-  @doc """
-  Determines the ship size for a connection, applying wormhole‑specific rules
-  for C1, C13, and C4⇄NS links, falling back to the caller’s provided size or Large.
-  """
-  defp resolve_ship_size(type_val, ship_size_val, src_info, tgt_info) do
+  # Determines the ship size for a connection, applying wormhole-specific rules
+  # for C1, C13, and C4⇄NS links, falling back to the caller's provided size or Large.
+  # If wormhole_type is provided (e.g., "H296"), infer ship size from it.
+  defp resolve_ship_size(type_val, ship_size_val, wormhole_type, src_info, tgt_info) do
     case parse_type(type_val) do
       @connection_type_wormhole ->
-        wormhole_ship_size(ship_size_val, src_info, tgt_info)
+        wormhole_ship_size(ship_size_val, wormhole_type, src_info, tgt_info)
 
       _other ->
         # Stargates and others just use the parsed or default size
@@ -110,15 +127,45 @@ defmodule WandererApp.Map.Operations.Connections do
 
   # -- Wormhole‑specific sizing rules ----------------------------------------
 
-  defp wormhole_ship_size(ship_size_val, src, tgt) do
+  defp wormhole_ship_size(ship_size_val, wormhole_type, src, tgt) do
+    # First, try to infer from wormhole_type (e.g., "H296", "C5", etc.)
+    inferred_size = infer_ship_size_from_wormhole_type(wormhole_type)
+    # Parse ship_size_val early to handle string values correctly
+    parsed_ship_size = parse_ship_size(ship_size_val, nil)
+
     cond do
-      c1_system?(src, tgt) -> @medium_ship_size
-      c13_system?(src, tgt) -> @small_ship_size
-      c4_to_ns?(src, tgt) -> @small_ship_size
-      true -> parse_ship_size(ship_size_val, @large_ship_size)
+      # If user explicitly provided a ship_size_val, use it
+      not is_nil(parsed_ship_size) ->
+        parsed_ship_size
+
+      # If we could infer from wormhole_type, use that
+      not is_nil(inferred_size) ->
+        inferred_size
+
+      # Otherwise fall back to system class rules
+      c1_system?(src, tgt) ->
+        @medium_ship_size
+
+      c13_system?(src, tgt) ->
+        @small_ship_size
+
+      c4_to_ns?(src, tgt) ->
+        @small_ship_size
+
+      true ->
+        @large_ship_size
     end
   end
 
+  # Infer ship size from wormhole type name using EVE static data
+  defp infer_ship_size_from_wormhole_type(nil), do: nil
+  defp infer_ship_size_from_wormhole_type(""), do: nil
+  defp infer_ship_size_from_wormhole_type("K162"), do: nil
+
+  defp infer_ship_size_from_wormhole_type(wormhole_type) do
+    WandererApp.Utils.EVEUtil.get_wh_size(wormhole_type)
+  end
+
   defp c1_system?(%{system_class: @c1_system_class}, _), do: true
   defp c1_system?(_, %{system_class: @c1_system_class}), do: true
   defp c1_system?(_, _), do: false
@@ -164,6 +211,9 @@ defmodule WandererApp.Map.Operations.Connections do
 
   defp parse_type(_), do: @connection_type_wormhole
 
+  defp maybe_add_extra(map, _key, nil), do: map
+  defp maybe_add_extra(map, key, value), do: Map.put(map, key, value)
+
   defp parse_int(nil, field), do: {:error, {:missing_field, field}}
   defp parse_int(val, _) when is_integer(val), do: {:ok, val}
 

lib/wanderer_app/map/operations/duplication.ex

@@ -12,7 +12,6 @@ defmodule WandererApp.Map.Operations.Duplication do
   """
 
   require Logger
-  import Ash.Query, only: [filter: 2]
 
   alias WandererApp.Api
   alias WandererApp.Api.{MapSystem, MapConnection, MapSystemSignature, MapCharacterSettings}

lib/wanderer_app/map/operations/signatures.ex

@@ -5,8 +5,10 @@ defmodule WandererApp.Map.Operations.Signatures do
 
   require Logger
   alias WandererApp.Map.Operations
+  alias WandererApp.Map.Operations.Connections
   alias WandererApp.Api.{Character, MapSystem, MapSystemSignature}
   alias WandererApp.Map.Server
+  alias WandererApp.Utils.EVEUtil
 
   @spec validate_character_eve_id(map() | nil, String.t()) ::
           {:ok, String.t()} | {:error, :invalid_character} | {:error, :unexpected_error}
@@ -78,7 +80,7 @@ defmodule WandererApp.Map.Operations.Signatures do
       )
       when is_integer(solar_system_id) do
     with {:ok, validated_char_uuid} <- validate_character_eve_id(params, char_id),
-         {:ok, system} <- MapSystem.by_map_id_and_solar_system_id(map_id, solar_system_id) do
+         {:ok, system} <- ensure_system_on_map(map_id, solar_system_id, user_id, char_id) do
       attrs =
         params
         |> Map.put("system_id", system.id)
@@ -94,6 +96,21 @@ defmodule WandererApp.Map.Operations.Signatures do
              delete_connection_with_sigs: false
            }) do
         :ok ->
+          # Handle linked_system_id if provided - auto-add system and create/update connection
+          linked_system_id = Map.get(params, "linked_system_id")
+          wormhole_type = Map.get(params, "type")
+
+          if is_integer(linked_system_id) and linked_system_id != solar_system_id do
+            handle_linked_system(
+              map_id,
+              solar_system_id,
+              linked_system_id,
+              wormhole_type,
+              user_id,
+              char_id
+            )
+          end
+
           # Try to fetch the created signature to return with proper fields
           with {:ok, sigs} <-
                  MapSystemSignature.by_system_id_and_eve_ids(system.id, [attrs["eve_id"]]),
@@ -129,6 +146,13 @@ defmodule WandererApp.Map.Operations.Signatures do
         Logger.error("[create_signature] Unexpected error during character validation")
         {:error, :unexpected_error}
 
+      {:error, :invalid_solar_system} ->
+        Logger.error(
+          "[create_signature] Invalid solar_system_id: #{solar_system_id} (not a valid EVE system)"
+        )
+
+        {:error, :invalid_solar_system}
+
       _ ->
         Logger.error(
           "[create_signature] System not found for solar_system_id: #{solar_system_id}"
@@ -147,6 +171,203 @@ defmodule WandererApp.Map.Operations.Signatures do
 
   def create_signature(_conn, _params), do: {:error, :missing_params}
 
+  # Check cache (not DB) to ensure system is actually visible on the map.
+  @spec ensure_system_on_map(String.t(), integer(), String.t(), String.t()) ::
+          {:ok, map()} | {:error, atom()}
+  defp ensure_system_on_map(map_id, solar_system_id, user_id, char_id) do
+    case WandererApp.Map.find_system_by_location(map_id, %{solar_system_id: solar_system_id}) do
+      nil -> add_system_to_map(map_id, solar_system_id, user_id, char_id)
+      system -> {:ok, system}
+    end
+  end
+
+  @spec add_system_to_map(String.t(), integer(), String.t(), String.t()) ::
+          {:ok, map()} | {:error, atom()}
+  defp add_system_to_map(map_id, solar_system_id, user_id, char_id) do
+    with {:ok, static_info} when not is_nil(static_info) <-
+           WandererApp.CachedInfo.get_system_static_info(solar_system_id),
+         :ok <-
+           Server.add_system(
+             map_id,
+             %{solar_system_id: solar_system_id, coordinates: nil},
+             user_id,
+             char_id
+           ),
+         system when not is_nil(system) <- fetch_system_after_add(map_id, solar_system_id) do
+      Logger.info("[create_signature] Auto-added system #{solar_system_id} to map #{map_id}")
+      {:ok, system}
+    else
+      {:ok, nil} ->
+        {:error, :invalid_solar_system}
+
+      {:error, _} ->
+        {:error, :invalid_solar_system}
+
+      nil ->
+        Logger.error("[add_system_to_map] Failed to fetch system after add")
+        {:error, :system_add_failed}
+
+      error ->
+        Logger.error("[add_system_to_map] Failed to add system: #{inspect(error)}")
+        {:error, :system_add_failed}
+    end
+  end
+
+  defp fetch_system_after_add(map_id, solar_system_id) do
+    case WandererApp.Map.find_system_by_location(map_id, %{solar_system_id: solar_system_id}) do
+      nil ->
+        case MapSystem.read_by_map_and_solar_system(%{
+               map_id: map_id,
+               solar_system_id: solar_system_id
+             }) do
+          {:ok, system} -> system
+          _ -> nil
+        end
+
+      system ->
+        system
+    end
+  end
+
+  # Handles the linked_system_id logic: auto-adds the linked system and creates/updates connection
+  @spec handle_linked_system(
+          String.t(),
+          integer(),
+          integer(),
+          String.t() | nil,
+          String.t(),
+          String.t()
+        ) :: :ok | {:error, atom()}
+  defp handle_linked_system(
+         map_id,
+         source_system_id,
+         linked_system_id,
+         wormhole_type,
+         user_id,
+         char_id
+       ) do
+    # Ensure the linked system is on the map
+    case ensure_system_on_map(map_id, linked_system_id, user_id, char_id) do
+      {:ok, _linked_system} ->
+        # Check if connection exists between the systems
+        case Connections.get_connection_by_systems(map_id, source_system_id, linked_system_id) do
+          {:ok, nil} ->
+            # No connection exists, create one
+            create_connection_with_wormhole_type(
+              map_id,
+              source_system_id,
+              linked_system_id,
+              wormhole_type,
+              char_id
+            )
+
+          {:ok, _existing_conn} ->
+            # Connection exists, update wormhole type if provided
+            update_connection_wormhole_type(
+              map_id,
+              source_system_id,
+              linked_system_id,
+              wormhole_type
+            )
+
+          {:error, reason} ->
+            Logger.warning(
+              "[handle_linked_system] Failed to check connection: #{inspect(reason)}"
+            )
+
+            {:error, :connection_check_failed}
+        end
+
+      {:error, :invalid_solar_system} ->
+        Logger.warning(
+          "[handle_linked_system] Invalid linked_system_id: #{linked_system_id} (not a valid EVE system)"
+        )
+
+        {:error, :invalid_linked_system}
+
+      {:error, reason} ->
+        Logger.warning("[handle_linked_system] Failed to add linked system: #{inspect(reason)}")
+        {:error, :linked_system_add_failed}
+    end
+  end
+
+  # Creates a connection between two systems with the specified wormhole type
+  @spec create_connection_with_wormhole_type(
+          String.t(),
+          integer(),
+          integer(),
+          String.t() | nil,
+          String.t()
+        ) :: :ok | {:error, atom()}
+  defp create_connection_with_wormhole_type(
+         map_id,
+         source_system_id,
+         target_system_id,
+         wormhole_type,
+         char_id
+       ) do
+    conn_attrs = %{
+      "solar_system_source" => source_system_id,
+      "solar_system_target" => target_system_id,
+      "type" => 0,
+      "wormhole_type" => wormhole_type
+    }
+
+    case Connections.create(conn_attrs, map_id, char_id) do
+      {:ok, :created} ->
+        Logger.info(
+          "[create_signature] Auto-created connection #{source_system_id} <-> #{target_system_id} (type: #{wormhole_type || "unknown"})"
+        )
+
+        :ok
+
+      {:skip, :exists} ->
+        # Connection already exists (race condition), update it instead
+        update_connection_wormhole_type(map_id, source_system_id, target_system_id, wormhole_type)
+
+      error ->
+        Logger.warning(
+          "[create_connection_with_wormhole_type] Failed to create connection: #{inspect(error)}"
+        )
+
+        {:error, :connection_create_failed}
+    end
+  end
+
+  # Updates the wormhole type and ship size for an existing connection
+  @spec update_connection_wormhole_type(String.t(), integer(), integer(), String.t() | nil) ::
+          :ok | {:error, atom()}
+  defp update_connection_wormhole_type(_map_id, _source, _target, nil), do: :ok
+
+  defp update_connection_wormhole_type(map_id, source_system_id, target_system_id, wormhole_type) do
+    # Get ship size from wormhole type
+    ship_size_type = EVEUtil.get_wh_size(wormhole_type)
+
+    if not is_nil(ship_size_type) do
+      case Server.update_connection_ship_size_type(map_id, %{
+             solar_system_source_id: source_system_id,
+             solar_system_target_id: target_system_id,
+             ship_size_type: ship_size_type
+           }) do
+        :ok ->
+          Logger.info(
+            "[create_signature] Updated connection #{source_system_id} <-> #{target_system_id} ship_size_type to #{ship_size_type} (wormhole: #{wormhole_type})"
+          )
+
+          :ok
+
+        error ->
+          Logger.warning(
+            "[update_connection_wormhole_type] Failed to update ship size: #{inspect(error)}"
+          )
+
+          {:error, :ship_size_update_failed}
+      end
+    else
+      :ok
+    end
+  end
+
   @spec update_signature(Plug.Conn.t(), String.t(), map()) :: {:ok, map()} | {:error, atom()}
   def update_signature(
         %{assigns: %{map_id: map_id, owner_character_id: char_id, owner_user_id: user_id}} =
@@ -248,4 +469,161 @@ defmodule WandererApp.Map.Operations.Signatures do
   end
 
   def delete_signature(_conn, _sig_id), do: {:error, :missing_params}
+
+  @doc """
+  Links a signature to a target system, creating the association between
+  the signature and the wormhole connection to that system.
+
+  This also:
+  - Updates the signature's group to "Wormhole"
+  - Sets the target system's linked_sig_eve_id
+  - Copies temporary_name from signature to target system
+  - Updates connection time_status and ship_size_type from signature data
+  """
+  @spec link_signature(Plug.Conn.t(), String.t(), map()) :: {:ok, map()} | {:error, atom()}
+  def link_signature(
+        %{assigns: %{map_id: map_id}} = _conn,
+        sig_id,
+        %{"solar_system_target" => solar_system_target}
+      )
+      when is_integer(solar_system_target) do
+    with {:ok, signature} <- MapSystemSignature.by_id(sig_id),
+         {:ok, source_system} <- MapSystem.by_id(signature.system_id),
+         true <- source_system.map_id == map_id,
+         target_system when not is_nil(target_system) <-
+           WandererApp.Map.find_system_by_location(map_id, %{solar_system_id: solar_system_target}) do
+      # Update signature group to Wormhole and set linked_system_id
+      {:ok, updated_signature} =
+        signature
+        |> MapSystemSignature.update_group!(%{group: "Wormhole"})
+        |> MapSystemSignature.update_linked_system(%{linked_system_id: solar_system_target})
+
+      # Only update target system if it doesn't already have a linked signature
+      if is_nil(target_system.linked_sig_eve_id) do
+        # Set the target system's linked_sig_eve_id
+        Server.update_system_linked_sig_eve_id(map_id, %{
+          solar_system_id: solar_system_target,
+          linked_sig_eve_id: signature.eve_id
+        })
+
+        # Copy temporary_name if present
+        if not is_nil(signature.temporary_name) do
+          Server.update_system_temporary_name(map_id, %{
+            solar_system_id: solar_system_target,
+            temporary_name: signature.temporary_name
+          })
+        end
+
+        # Update connection time_status from signature custom_info
+        signature_time_status =
+          if not is_nil(signature.custom_info) do
+            case Jason.decode(signature.custom_info) do
+              {:ok, map} -> Map.get(map, "time_status")
+              {:error, _} -> nil
+            end
+          else
+            nil
+          end
+
+        if not is_nil(signature_time_status) do
+          Server.update_connection_time_status(map_id, %{
+            solar_system_source_id: source_system.solar_system_id,
+            solar_system_target_id: solar_system_target,
+            time_status: signature_time_status
+          })
+        end
+
+        # Update connection ship_size_type from signature wormhole type
+        signature_ship_size_type = EVEUtil.get_wh_size(signature.type)
+
+        if not is_nil(signature_ship_size_type) do
+          Server.update_connection_ship_size_type(map_id, %{
+            solar_system_source_id: source_system.solar_system_id,
+            solar_system_target_id: solar_system_target,
+            ship_size_type: signature_ship_size_type
+          })
+        end
+      end
+
+      # Broadcast update
+      Server.Impl.broadcast!(map_id, :signatures_updated, source_system.solar_system_id)
+
+      # Return the updated signature
+      result =
+        updated_signature
+        |> Map.from_struct()
+        |> Map.put(:solar_system_id, source_system.solar_system_id)
+        |> Map.drop([:system_id, :__meta__, :system, :aggregates, :calculations])
+
+      {:ok, result}
+    else
+      false ->
+        {:error, :not_found}
+
+      nil ->
+        {:error, :target_system_not_found}
+
+      {:error, %Ash.Error.Query.NotFound{}} ->
+        {:error, :not_found}
+
+      err ->
+        Logger.error("[link_signature] Unexpected error: #{inspect(err)}")
+        {:error, :unexpected_error}
+    end
+  end
+
+  def link_signature(_conn, _sig_id, %{"solar_system_target" => _}),
+    do: {:error, :invalid_solar_system_target}
+
+  def link_signature(_conn, _sig_id, _params), do: {:error, :missing_params}
+
+  @doc """
+  Unlinks a signature from its target system.
+  """
+  @spec unlink_signature(Plug.Conn.t(), String.t()) :: {:ok, map()} | {:error, atom()}
+  def unlink_signature(%{assigns: %{map_id: map_id}} = _conn, sig_id) do
+    with {:ok, signature} <- MapSystemSignature.by_id(sig_id),
+         {:ok, source_system} <- MapSystem.by_id(signature.system_id),
+         :ok <- if(source_system.map_id == map_id, do: :ok, else: {:error, :not_found}),
+         :ok <- if(not is_nil(signature.linked_system_id), do: :ok, else: {:error, :not_linked}) do
+      # Clear the target system's linked_sig_eve_id
+      Server.update_system_linked_sig_eve_id(map_id, %{
+        solar_system_id: signature.linked_system_id,
+        linked_sig_eve_id: nil
+      })
+
+      # Clear the signature's linked_system_id using the wrapper for logging
+      {:ok, updated_signature} =
+        Server.SignaturesImpl.update_signature_linked_system(signature, %{
+          linked_system_id: nil
+        })
+
+      # Broadcast update
+      Server.Impl.broadcast!(map_id, :signatures_updated, source_system.solar_system_id)
+
+      # Return the updated signature
+      result =
+        updated_signature
+        |> Map.from_struct()
+        |> Map.put(:solar_system_id, source_system.solar_system_id)
+        |> Map.drop([:system_id, :__meta__, :system, :aggregates, :calculations])
+
+      {:ok, result}
+    else
+      {:error, :not_found} ->
+        {:error, :not_found}
+
+      {:error, :not_linked} ->
+        {:error, :not_linked}
+
+      {:error, %Ash.Error.Query.NotFound{}} ->
+        {:error, :not_found}
+
+      err ->
+        Logger.error("[unlink_signature] Unexpected error: #{inspect(err)}")
+        {:error, :unexpected_error}
+    end
+  end
+
+  def unlink_signature(_conn, _sig_id), do: {:error, :missing_params}
 end

lib/wanderer_app/map/operations/systems.ex

@@ -36,7 +36,8 @@ defmodule WandererApp.Map.Operations.Systems do
   # Private helper for batch upsert
   defp create_system_batch(%{map_id: map_id, user_id: user_id, char_id: char_id}, params) do
     with {:ok, solar_system_id} <- fetch_system_id(params) do
-      update_existing = fetch_update_existing(params, false)
+      # Default to true so re-submitting with new position updates the system
+      update_existing = fetch_update_existing(params, true)
 
       map_id
       |> WandererApp.Map.check_location(%{solar_system_id: solar_system_id})
@@ -46,9 +47,13 @@ defmodule WandererApp.Map.Operations.Systems do
 
         {:error, :already_exists} ->
           if update_existing do
-            do_update_system(map_id, user_id, char_id, solar_system_id, params)
+            # Mark as skip so it counts as "updated" not "created"
+            case do_update_system(map_id, user_id, char_id, solar_system_id, params) do
+              {:ok, _} -> {:skip, :updated}
+              error -> error
+            end
           else
-            :ok
+            {:skip, :already_exists}
           end
       end
     end
@@ -200,16 +205,22 @@ defmodule WandererApp.Map.Operations.Systems do
 
   defp normalize_coordinates(%{"coordinates" => %{"x" => x, "y" => y}})
        when is_number(x) and is_number(y),
-       do: %{x: x, y: y}
+       do: %{"x" => x, "y" => y}
 
   defp normalize_coordinates(%{coordinates: %{x: x, y: y}}) when is_number(x) and is_number(y),
-    do: %{x: x, y: y}
+    do: %{"x" => x, "y" => y}
 
   defp normalize_coordinates(params) do
-    %{
-      x: params |> Map.get("position_x", Map.get(params, :position_x, 0)),
-      y: params |> Map.get("position_y", Map.get(params, :position_y, 0))
-    }
+    x = params |> Map.get("position_x", Map.get(params, :position_x))
+    y = params |> Map.get("position_y", Map.get(params, :position_y))
+
+    # Only return coordinates if both x and y are provided
+    # Otherwise return nil to let the server use auto-positioning
+    if is_number(x) and is_number(y) do
+      %{"x" => x, "y" => y}
+    else
+      nil
+    end
   end
 
   defp apply_system_updates(map_id, system_id, attrs, %{x: x, y: y}) do

lib/wanderer_app/map/server/map_server_acls_impl.ex

@@ -56,7 +56,7 @@ defmodule WandererApp.Map.Server.AclsImpl do
         end
       )
 
-    map_update = %{acls: map.acls, scope: map.scope}
+    map_update = %{acls: map.acls, scope: map.scope, scopes: map.scopes}
 
     WandererApp.Map.update_map(map_id, map_update)
     WandererApp.Cache.delete("map_characters-#{map_id}")
@@ -68,6 +68,9 @@ defmodule WandererApp.Map.Server.AclsImpl do
     WandererApp.Map.update_map_state(map_id, %{
       map: Map.merge(old_map, map_update)
     })
+
+    # Broadcast to map channel so all viewers can refresh their available characters
+    WandererApp.Map.Server.Impl.broadcast!(map_id, :acl_members_changed, %{})
   end
 
   def handle_acl_updated(map_id, acl_id) do
@@ -87,6 +90,10 @@ defmodule WandererApp.Map.Server.AclsImpl do
         acl_id
         |> update_acl()
         |> broadcast_acl_updates(map_id)
+
+      # Broadcast to map channel so all viewers can refresh their available characters
+      # This fixes the issue where users don't see newly added ACL members as available for tracking
+      WandererApp.Map.Server.Impl.broadcast!(map_id, :acl_members_changed, %{acl_id: acl_id})
     end
   end
 
@@ -108,6 +115,9 @@ defmodule WandererApp.Map.Server.AclsImpl do
       |> Map.get(:characters, [])
 
     WandererApp.Cache.insert("map_#{map_id}:invalidate_character_ids", character_ids)
+
+    # Broadcast to map channel so all viewers can refresh their available characters
+    WandererApp.Map.Server.Impl.broadcast!(map_id, :acl_members_changed, %{})
   end
 
   def track_acls([]), do: :ok

lib/wanderer_app/map/server/map_server_characters_impl.ex

@@ -569,6 +569,9 @@ defmodule WandererApp.Map.Server.CharactersImpl do
               end
             )
 
+            # Broadcast permission update to trigger LiveView refresh
+            broadcast_permission_update(character_id)
+
             :has_update
 
           {:character_corporation, _info} ->
@@ -580,6 +583,9 @@ defmodule WandererApp.Map.Server.CharactersImpl do
               end
             )
 
+            # Broadcast permission update to trigger LiveView refresh
+            broadcast_permission_update(character_id)
+
             :has_update
 
           _ ->
@@ -814,21 +820,33 @@ defmodule WandererApp.Map.Server.CharactersImpl do
        do: :ok
 
   defp update_location(
-         %{map: %{scope: scope}, map_id: map_id, map_opts: map_opts} =
+         %{map: map, map_id: map_id, map_opts: map_opts} =
            _state,
          character_id,
          location,
          old_location
        ) do
-    ConnectionsImpl.is_connection_valid(
-      scope,
-      old_location.solar_system_id,
-      location.solar_system_id
+    scopes = get_effective_scopes(map)
+
+    is_valid =
+      ConnectionsImpl.is_connection_valid(
+        scopes,
+        old_location.solar_system_id,
+        location.solar_system_id
+      )
+
+    Logger.debug(
+      "[CharacterTracking] update_location: map=#{map_id}, " <>
+        "from=#{old_location.solar_system_id}, to=#{location.solar_system_id}, " <>
+        "scopes=#{inspect(scopes)}, map.scopes=#{inspect(map[:scopes])}, " <>
+        "map.scope=#{inspect(map[:scope])}, is_valid=#{is_valid}"
     )
-    |> case do
+
+    case is_valid do
       true ->
-        # Add new location system
-        case SystemsImpl.maybe_add_system(map_id, location, old_location, map_opts) do
+        # Connection is valid (at least one system matches scopes)
+        # Add systems that match the map's scopes - individual system filtering by maybe_add_system
+        case SystemsImpl.maybe_add_system(map_id, location, old_location, map_opts, scopes) do
           :ok ->
             :ok
 
@@ -838,8 +856,8 @@ defmodule WandererApp.Map.Server.CharactersImpl do
             )
         end
 
-        # Add old location system (in case it wasn't on map)
-        case SystemsImpl.maybe_add_system(map_id, old_location, location, map_opts) do
+        # Add old location system (in case it wasn't on map) - only if it matches scopes
+        case SystemsImpl.maybe_add_system(map_id, old_location, location, map_opts, scopes) do
           :ok ->
             :ok
 
@@ -879,6 +897,24 @@ defmodule WandererApp.Map.Server.CharactersImpl do
   defp is_character_in_space?(%{station_id: station_id, structure_id: structure_id} = _location),
     do: is_nil(structure_id) && is_nil(station_id)
 
+  @doc """
+  Get effective scopes from map, with fallback to legacy scope.
+  Returns the scopes array that should be used for filtering.
+  """
+  def get_effective_scopes(%{scopes: scopes}) when is_list(scopes) and scopes != [], do: scopes
+
+  def get_effective_scopes(%{scope: scope}) when is_atom(scope),
+    do: legacy_scope_to_scopes(scope)
+
+  def get_effective_scopes(_), do: [:wormholes]
+
+  # Legacy scope to new scopes array conversion
+  defp legacy_scope_to_scopes(:wormholes), do: [:wormholes]
+  defp legacy_scope_to_scopes(:stargates), do: [:hi, :low, :null, :pochven]
+  defp legacy_scope_to_scopes(:all), do: [:wormholes, :hi, :low, :null, :pochven]
+  defp legacy_scope_to_scopes(:none), do: []
+  defp legacy_scope_to_scopes(_), do: [:wormholes]
+
   defp add_character(
          map_id,
          %{id: character_id} = map_character,
@@ -923,4 +959,21 @@ defmodule WandererApp.Map.Server.CharactersImpl do
       track: true
     })
   end
+
+  # Broadcasts permission update to trigger LiveView refresh for the character's user.
+  # This is called when a character's corporation or alliance changes, ensuring
+  # users are kicked off maps they no longer have access to.
+  defp broadcast_permission_update(character_id) do
+    case WandererApp.Character.get_character(character_id) do
+      {:ok, %{eve_id: eve_id}} when not is_nil(eve_id) ->
+        Phoenix.PubSub.broadcast(
+          WandererApp.PubSub,
+          "character:#{eve_id}",
+          :update_permissions
+        )
+
+      _ ->
+        :ok
+    end
+  end
 end

lib/wanderer_app/map/server/map_server_connections_impl.ex

@@ -5,6 +5,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
 
   alias WandererApp.Map.Server.Impl
   alias WandererApp.Map.Server.SignaturesImpl
+  alias WandererApp.Map.Server.SystemsImpl
 
   # @ccp1 -1
   @c1 1
@@ -57,6 +58,12 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
 
   @known_space [@hs, @ls, @ns, @pochven]
 
+  # Individual space type lists for granular scope matching
+  @hi_space [@hs]
+  @low_space [@ls]
+  @null_space [@ns]
+  @pochven_space [@pochven]
+
   @prohibited_systems [@jita]
   @prohibited_system_classes [
     @a1,
@@ -100,7 +107,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
 
   @connection_type_wormhole 0
   @connection_type_stargate 1
-  @connection_type_bridge 2
+  # @connection_type_bridge 2 # reserved for future use
   @medium_ship_size 1
 
   def get_connection_auto_expire_hours(), do: WandererApp.Env.map_connection_auto_expire_hours()
@@ -290,6 +297,30 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
       do: update_connection(map_id, :update_custom_info, [:custom_info], connection_update)
 
   def cleanup_connections(map_id) do
+    # Defensive check: Skip cleanup if cache appears invalid
+    # This prevents incorrectly deleting connections when cache is empty due to
+    # race conditions during map restart or cache corruption
+    case WandererApp.Map.get_map(map_id) do
+      {:error, :not_found} ->
+        Logger.warning(
+          "[cleanup_connections] Skipping map #{map_id} - cache miss detected, " <>
+            "map data not found in cache"
+        )
+
+        :telemetry.execute(
+          [:wanderer_app, :map, :cleanup_connections, :cache_miss],
+          %{system_time: System.system_time()},
+          %{map_id: map_id}
+        )
+
+        :ok
+
+      {:ok, _map} ->
+        do_cleanup_connections(map_id)
+    end
+  end
+
+  defp do_cleanup_connections(map_id) do
     connection_auto_expire_hours = get_connection_auto_expire_hours()
     connection_auto_eol_hours = get_connection_auto_eol_hours()
     connection_eol_expire_timeout_hours = get_eol_expire_timeout_mins() / 60
@@ -343,6 +374,27 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
                       solar_system_source: solar_system_source_id,
                       solar_system_target: solar_system_target_id
                     } ->
+      # Emit telemetry for connection auto-deletion
+      :telemetry.execute(
+        [:wanderer_app, :map, :connection_cleanup, :delete],
+        %{system_time: System.system_time()},
+        %{
+          map_id: map_id,
+          solar_system_source_id: solar_system_source_id,
+          solar_system_target_id: solar_system_target_id,
+          reason: :auto_cleanup
+        }
+      )
+
+      # Log auto-deletion for audit trail (no user/character context for auto-cleanup)
+      WandererApp.User.ActivityTracker.track_map_event(:map_connection_removed, %{
+        character_id: nil,
+        user_id: nil,
+        map_id: map_id,
+        solar_system_source_id: solar_system_source_id,
+        solar_system_target_id: solar_system_target_id
+      })
+
       delete_connection(map_id, %{
         solar_system_source_id: solar_system_source_id,
         solar_system_target_id: solar_system_target_id
@@ -403,7 +455,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
            time_status: time_status,
            solar_system_source: solar_system_source,
            solar_system_target: solar_system_target
-         } = updated_connection
+         } = _updated_connection
        ) do
     with source_system when not is_nil(source_system) <-
            WandererApp.Map.find_system_by_location(
@@ -543,6 +595,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
         time_status = get_extra_info(extra_info, "time_status", time_status)
         mass_status = get_extra_info(extra_info, "mass_status", 0)
         locked = get_extra_info(extra_info, "locked", false)
+        wormhole_type = get_extra_info(extra_info, "wormhole_type", nil)
 
         {:ok, connection} =
           WandererApp.MapConnectionRepo.create(%{
@@ -553,7 +606,8 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
             ship_size_type: ship_size_type,
             time_status: time_status,
             mass_status: mass_status,
-            locked: locked
+            locked: locked,
+            wormhole_type: wormhole_type
           })
 
         if connection_type == @connection_type_wormhole do
@@ -644,31 +698,49 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
         start_time
       )
 
-  def can_add_location(_scope, nil), do: false
+  def can_add_location(_scopes, nil), do: false
 
-  def can_add_location(:none, _solar_system_id), do: false
+  def can_add_location([], _solar_system_id), do: false
 
-  def can_add_location(scope, solar_system_id) do
+  def can_add_location(scopes, solar_system_id) when is_list(scopes) do
     {:ok, system_static_info} = get_system_static_info(solar_system_id)
 
-    case scope do
-      :wormholes ->
-        not is_prohibited_system_class?(system_static_info.system_class) and
-          not (@prohibited_systems |> Enum.member?(solar_system_id)) and
-          @wh_space |> Enum.member?(system_static_info.system_class)
-
-      :stargates ->
-        not is_prohibited_system_class?(system_static_info.system_class) and
-          @known_space |> Enum.member?(system_static_info.system_class)
-
-      :all ->
-        not is_prohibited_system_class?(system_static_info.system_class)
-
-      _ ->
-        false
-    end
+    not is_prohibited_system_class?(system_static_info.system_class) and
+      not (@prohibited_systems |> Enum.member?(solar_system_id)) and
+      system_matches_any_scope?(system_static_info.system_class, scopes)
   end
 
+  # Legacy support for single scope atom
+  def can_add_location(:none, _solar_system_id), do: false
+
+  def can_add_location(scope, solar_system_id) when is_atom(scope) do
+    can_add_location(legacy_scope_to_scopes(scope), solar_system_id)
+  end
+
+  # Helper function to check if a system class matches any of the selected scopes
+  defp system_matches_any_scope?(_system_class, []), do: false
+
+  defp system_matches_any_scope?(system_class, scopes) do
+    Enum.any?(scopes, fn scope ->
+      system_matches_scope?(system_class, scope)
+    end)
+  end
+
+  # Individual scope matching functions
+  defp system_matches_scope?(system_class, :wormholes), do: system_class in @wh_space
+  defp system_matches_scope?(system_class, :hi), do: system_class in @hi_space
+  defp system_matches_scope?(system_class, :low), do: system_class in @low_space
+  defp system_matches_scope?(system_class, :null), do: system_class in @null_space
+  defp system_matches_scope?(system_class, :pochven), do: system_class in @pochven_space
+  defp system_matches_scope?(_system_class, _), do: false
+
+  # Legacy scope to new scopes array conversion
+  defp legacy_scope_to_scopes(:wormholes), do: [:wormholes]
+  defp legacy_scope_to_scopes(:stargates), do: [:hi, :low, :null, :pochven]
+  defp legacy_scope_to_scopes(:all), do: [:wormholes, :hi, :low, :null, :pochven]
+  defp legacy_scope_to_scopes(:none), do: []
+  defp legacy_scope_to_scopes(_), do: [:wormholes]
+
   def is_prohibited_system_class?(system_class) do
     @prohibited_system_classes |> Enum.member?(system_class)
   end
@@ -688,17 +760,81 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
           )
         )
 
-  def is_connection_valid(_scope, from_solar_system_id, to_solar_system_id)
+  def is_connection_valid(_scopes, from_solar_system_id, to_solar_system_id)
       when is_nil(from_solar_system_id) or is_nil(to_solar_system_id),
       do: false
 
+  def is_connection_valid([], _from_solar_system_id, _to_solar_system_id), do: false
+
+  # New array-based scopes support
+  def is_connection_valid(scopes, from_solar_system_id, to_solar_system_id)
+      when is_list(scopes) and from_solar_system_id != to_solar_system_id do
+    with {:ok, from_system_static_info} <- get_system_static_info(from_solar_system_id),
+         {:ok, to_system_static_info} <- get_system_static_info(to_solar_system_id) do
+      # First check: neither system is prohibited
+      not_prohibited =
+        not is_prohibited_system_class?(from_system_static_info.system_class) and
+          not is_prohibited_system_class?(to_system_static_info.system_class) and
+          not (@prohibited_systems |> Enum.member?(from_solar_system_id)) and
+          not (@prohibited_systems |> Enum.member?(to_solar_system_id))
+
+      if not_prohibited do
+        from_is_wormhole = from_system_static_info.system_class in @wh_space
+        to_is_wormhole = to_system_static_info.system_class in @wh_space
+        wormholes_enabled = :wormholes in scopes
+
+        cond do
+          # Case 1: Wormhole border behavior - at least one system is a wormhole
+          # and :wormholes is enabled, allow the connection (adds border k-space systems)
+          wormholes_enabled and (from_is_wormhole or to_is_wormhole) ->
+            # At least one system matches (wormhole matches :wormholes, or other matches its scope)
+            system_matches_any_scope?(from_system_static_info.system_class, scopes) or
+              system_matches_any_scope?(to_system_static_info.system_class, scopes)
+
+          # Case 2: K-space to K-space with :wormholes enabled - check if it's a wormhole connection
+          # If neither system is a wormhole AND there's no stargate between them, it's a wormhole connection
+          wormholes_enabled and not from_is_wormhole and not to_is_wormhole ->
+            # Check if there's a known stargate connection
+            case find_solar_system_jump(from_solar_system_id, to_solar_system_id) do
+              {:ok, known_jumps} when known_jumps == [] ->
+                # No stargate exists - this is a wormhole connection through k-space
+                true
+
+              {:ok, _known_jumps} ->
+                # Stargate exists - this is NOT a wormhole, check normal scope matching
+                system_matches_any_scope?(from_system_static_info.system_class, scopes) and
+                  system_matches_any_scope?(to_system_static_info.system_class, scopes)
+
+              _ ->
+                # Error fetching jumps - fall back to scope matching
+                system_matches_any_scope?(from_system_static_info.system_class, scopes) and
+                  system_matches_any_scope?(to_system_static_info.system_class, scopes)
+            end
+
+          # Case 3: Non-wormhole movement without :wormholes scope
+          # Both systems must match the configured scopes
+          true ->
+            system_matches_any_scope?(from_system_static_info.system_class, scopes) and
+              system_matches_any_scope?(to_system_static_info.system_class, scopes)
+        end
+      else
+        false
+      end
+    else
+      _ -> false
+    end
+  end
+
+  # Legacy support: :all scope
   def is_connection_valid(:all, from_solar_system_id, to_solar_system_id),
     do: from_solar_system_id != to_solar_system_id
 
+  # Legacy support: :none scope
   def is_connection_valid(:none, _from_solar_system_id, _to_solar_system_id), do: false
 
+  # Legacy support: single atom scope (including :stargates which is used for connection type detection)
   def is_connection_valid(scope, from_solar_system_id, to_solar_system_id)
-      when from_solar_system_id != to_solar_system_id do
+      when is_atom(scope) and from_solar_system_id != to_solar_system_id do
     with {:ok, known_jumps} <- find_solar_system_jump(from_solar_system_id, to_solar_system_id),
          {:ok, from_system_static_info} <- get_system_static_info(from_solar_system_id),
          {:ok, to_system_static_info} <- get_system_static_info(to_solar_system_id) do
@@ -712,7 +848,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
 
         :stargates ->
           # For stargates, we need to check:
-          # 1. Both systems are in known space (HS, LS, NS)
+          # 1. Both systems are in known space (HS, LS, NS, Pochven)
           # 2. There is a known jump between them
           # 3. Neither system is prohibited
           from_system_static_info.system_class in @known_space and
@@ -720,13 +856,21 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
             not is_prohibited_system_class?(from_system_static_info.system_class) and
             not is_prohibited_system_class?(to_system_static_info.system_class) and
             not (known_jumps |> Enum.empty?())
+
+        _ ->
+          # For other legacy scopes, convert to array and use new logic
+          is_connection_valid(
+            legacy_scope_to_scopes(scope),
+            from_solar_system_id,
+            to_solar_system_id
+          )
       end
     else
       _ -> false
     end
   end
 
-  def is_connection_valid(_scope, _from_solar_system_id, _to_solar_system_id), do: false
+  def is_connection_valid(_scopes, _from_solar_system_id, _to_solar_system_id), do: false
 
   def get_connection_mark_eol_time(map_id, connection_id, default \\ DateTime.utc_now()) do
     WandererApp.Cache.get("map_#{map_id}:conn_#{connection_id}:mark_eol_time")
@@ -746,6 +890,46 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
     end
   end
 
+  @doc """
+  Check if a connection between two k-space systems is a wormhole connection.
+  Returns true if:
+  1. Both systems are k-space (not wormhole space)
+  2. There is no known stargate between them
+
+  This is used to detect wormhole connections through k-space, like when
+  a player jumps from low-sec to low-sec through a wormhole.
+  """
+  def is_kspace_wormhole_connection?(from_solar_system_id, to_solar_system_id)
+      when is_nil(from_solar_system_id) or is_nil(to_solar_system_id),
+      do: false
+
+  def is_kspace_wormhole_connection?(from_solar_system_id, to_solar_system_id)
+      when from_solar_system_id == to_solar_system_id,
+      do: false
+
+  def is_kspace_wormhole_connection?(from_solar_system_id, to_solar_system_id) do
+    with {:ok, from_info} <- get_system_static_info(from_solar_system_id),
+         {:ok, to_info} <- get_system_static_info(to_solar_system_id) do
+      from_is_wormhole = from_info.system_class in @wh_space
+      to_is_wormhole = to_info.system_class in @wh_space
+
+      # Both must be k-space (not wormhole space)
+      if not from_is_wormhole and not to_is_wormhole do
+        # Check if there's a known stargate
+        case find_solar_system_jump(from_solar_system_id, to_solar_system_id) do
+          # No stargate = wormhole connection
+          {:ok, []} -> true
+          # Stargate exists or error
+          _ -> false
+        end
+      else
+        false
+      end
+    else
+      _ -> false
+    end
+  end
+
   defp get_system_static_info(solar_system_id) do
     case WandererApp.CachedInfo.get_system_static_info(solar_system_id) do
       {:ok, system_static_info} when not is_nil(system_static_info) ->
@@ -779,6 +963,13 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
 
         WandererApp.Cache.delete("map_#{map_id}:conn_#{connection.id}:start_time")
 
+        # Clear linked_sig_eve_id on target system when connection is deleted
+        # This ensures old signatures become orphaned and won't affect future connections
+        SystemsImpl.update_system_linked_sig_eve_id(map_id, %{
+          solar_system_id: location.solar_system_id,
+          linked_sig_eve_id: nil
+        })
+
       _error ->
         :ok
     end
@@ -859,14 +1050,6 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
       source_system_info.system_class == @c13 or target_system_info.system_class == @c13 ->
         @frigate_ship_size
 
-      # C4 to null gets frigate (unless C4 is shattered)
-      (source_system_info.system_class == @c4 and target_system_info.system_class == @ns and
-         not source_system_info.is_shattered) or
-          (target_system_info.system_class == @c4 and
-             source_system_info.system_class == @ns and
-             not target_system_info.is_shattered) ->
-        @frigate_ship_size
-
       true ->
         # Default to large for other wormhole connections
         @large_ship_size
@@ -909,9 +1092,6 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
     end
   end
 
-  defp get_time_status(_source_solar_system_id, _target_solar_system_id, _ship_size_type),
-    do: @connection_time_status_default
-
   defp get_new_time_status(_start_time, @connection_time_status_default),
     do: @connection_time_status_eol_24
 

lib/wanderer_app/map/server/map_server_impl.ex

@@ -156,7 +156,7 @@ defmodule WandererApp.Map.Server.Impl do
         Logger.error("Cannot start map #{map_id}: map not loaded")
         {:error, :map_not_loaded}
 
-      map ->
+      _map ->
         with :ok <- AclsImpl.track_acls(acls |> Enum.map(& &1.access_list_id)) do
           @pubsub_client.subscribe(
             WandererApp.PubSub,

lib/wanderer_app/map/server/map_server_pings_impl.ex

@@ -5,7 +5,7 @@ defmodule WandererApp.Map.Server.PingsImpl do
 
   alias WandererApp.Map.Server.Impl
 
-  @ping_auto_expire_timeout :timer.minutes(15)
+  # @ping_auto_expire_timeout :timer.minutes(15) # reserved for future use
 
   def add_ping(
         map_id,
@@ -72,17 +72,23 @@ defmodule WandererApp.Map.Server.PingsImpl do
           type: type
         } = _ping_info
       ) do
-    case WandererApp.MapPingsRepo.get_by_id(ping_id) do
+    result = WandererApp.MapPingsRepo.get_by_id(ping_id)
+
+    case result do
       {:ok,
        %{system: %{id: system_id, name: system_name, solar_system_id: solar_system_id}} = ping} ->
         with {:ok, character} <- WandererApp.Character.get_character(character_id),
              :ok <- WandererApp.MapPingsRepo.destroy(ping) do
+          Logger.debug("Ping #{ping_id} destroyed successfully, broadcasting :ping_cancelled")
+
           Impl.broadcast!(map_id, :ping_cancelled, %{
             id: ping_id,
             solar_system_id: solar_system_id,
             type: type
           })
 
+          Logger.debug("Broadcast :ping_cancelled sent for ping #{ping_id}")
+
           # Broadcast rally point removal events to external clients (webhooks/SSE)
           if type == 1 do
             WandererApp.ExternalEvents.broadcast(map_id, :rally_point_removed, %{
@@ -107,18 +113,45 @@ defmodule WandererApp.Map.Server.PingsImpl do
             Logger.error("Failed to destroy ping: #{inspect(error, pretty: true)}")
         end
 
+      # Handle case where ping exists but system was deleted (nil)
+      {:ok, %{system: nil} = ping} ->
+        case WandererApp.MapPingsRepo.destroy(ping) do
+          :ok ->
+            Impl.broadcast!(map_id, :ping_cancelled, %{
+              id: ping_id,
+              solar_system_id: nil,
+              type: type
+            })
+
+          error ->
+            Logger.error("Failed to destroy orphaned ping: #{inspect(error, pretty: true)}")
+        end
+
       {:error, %Ash.Error.Query.NotFound{}} ->
         # Ping already deleted (possibly by cascade deletion from map/system/character removal,
-        # auto-expiry, or concurrent cancellation). This is not an error - the desired state
-        # (ping is gone) is already achieved. Just broadcast the cancellation event.
-        Logger.debug(
-          "Ping #{ping_id} not found during cancellation - already deleted, skipping broadcast"
-        )
+        # auto-expiry, or concurrent cancellation). Broadcast cancellation so frontend updates.
+        Impl.broadcast!(map_id, :ping_cancelled, %{
+          id: ping_id,
+          solar_system_id: nil,
+          type: type
+        })
 
         :ok
 
-      error ->
-        Logger.error("Failed to fetch ping for cancellation: #{inspect(error, pretty: true)}")
+      {:error, %Ash.Error.Invalid{errors: [%Ash.Error.Query.NotFound{} | _]}} ->
+        # Same as above, but Ash wraps NotFound inside Invalid in some cases
+        Impl.broadcast!(map_id, :ping_cancelled, %{
+          id: ping_id,
+          solar_system_id: nil,
+          type: type
+        })
+
+        :ok
+
+      other ->
+        Logger.error(
+          "Failed to cancel ping #{ping_id}: unexpected result from get_by_id: #{inspect(other, pretty: true)}"
+        )
     end
   end
 end

lib/wanderer_app/map/server/map_server_signatures_impl.ex

@@ -109,8 +109,10 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
         nil ->
           MapSystemSignature.create!(sig)
 
-        _ ->
-          :noop
+        existing ->
+          # If signature already exists, update it instead of ignoring
+          # This handles the case where frontend sends existing sigs as "added"
+          apply_update_signature(map_id, existing, sig)
       end
     end)
 
@@ -167,19 +169,26 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
       updated_count: length(updated_ids),
       removed_count: length(removed_ids)
     })
+
+    # Always return :ok - external event failures should not affect the main operation
+    :ok
   end
 
   defp remove_signature(map_id, sig, system, delete_conn?) do
-    # optionally remove the linked connection
-    if delete_conn? && sig.linked_system_id do
+    # Check if this signature is the active one for the target system
+    # This prevents deleting connections when old/orphan signatures are removed
+    is_active = sig.linked_system_id && is_active_signature_for_target?(map_id, sig)
+
+    # Only delete connection if this signature is the active one
+    if delete_conn? && is_active do
       ConnectionsImpl.delete_connection(map_id, %{
         solar_system_source_id: system.solar_system_id,
         solar_system_target_id: sig.linked_system_id
       })
     end
 
-    # clear any linked_sig_eve_id on the target system
-    if sig.linked_system_id do
+    # Only clear linked_sig_eve_id if this signature is the active one
+    if is_active do
       SystemsImpl.update_system_linked_sig_eve_id(map_id, %{
         solar_system_id: sig.linked_system_id,
         linked_sig_eve_id: nil
@@ -190,6 +199,16 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
     |> MapSystemSignature.destroy!()
   end
 
+  defp is_active_signature_for_target?(map_id, sig) do
+    case MapSystem.read_by_map_and_solar_system(%{
+           map_id: map_id,
+           solar_system_id: sig.linked_system_id
+         }) do
+      {:ok, target_system} -> target_system.linked_sig_eve_id == sig.eve_id
+      _ -> false
+    end
+  end
+
   def apply_update_signature(
         map_id,
         %MapSystemSignature{} = existing,
@@ -256,6 +275,37 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
 
   defp maybe_update_connection_mass_status(_map_id, _old_sig, _updated_sig), do: :ok
 
+  @doc """
+  Wrapper for updating a signature's linked_system_id with logging.
+  Logs all unlink operations (when linked_system_id is set to nil) with context
+  to help diagnose unexpected unlinking issues.
+  """
+  def update_signature_linked_system(signature, %{linked_system_id: nil} = params) do
+    # Log all unlink operations with context for debugging
+    Logger.warning(
+      "[Signature Unlink] eve_id=#{signature.eve_id} " <>
+        "system_id=#{signature.system_id} " <>
+        "old_linked_system_id=#{signature.linked_system_id} " <>
+        "stacktrace=#{format_stacktrace()}"
+    )
+
+    MapSystemSignature.update_linked_system(signature, params)
+  end
+
+  def update_signature_linked_system(signature, params) do
+    MapSystemSignature.update_linked_system(signature, params)
+  end
+
+  defp format_stacktrace do
+    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
+
+    stacktrace
+    |> Enum.take(10)
+    |> Enum.map_join(" <- ", fn {mod, fun, arity, _} ->
+      "#{inspect(mod)}.#{fun}/#{arity}"
+    end)
+  end
+
   defp track_activity(event, map_id, solar_system_id, user_id, character_id, signatures) do
     ActivityTracker.track_map_event(event, %{
       map_id: map_id,
@@ -279,6 +329,7 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
         group: sig["group"],
         type: Map.get(sig, "type"),
         custom_info: Map.get(sig, "custom_info"),
+        linked_system_id: Map.get(sig, "linked_system_id"),
         # Use character_eve_id from sig if provided, otherwise use the default
         character_eve_id: Map.get(sig, "character_eve_id", character_eve_id),
         deleted: false

lib/wanderer_app/map/server/map_server_systems_impl.ex

@@ -4,6 +4,7 @@ defmodule WandererApp.Map.Server.SystemsImpl do
   require Logger
 
   alias WandererApp.Map.Server.Impl
+  alias WandererApp.Map.Server.SignaturesImpl
 
   @ddrt Application.compile_env(:wanderer_app, :ddrt)
   @system_auto_expire_minutes 15
@@ -129,8 +130,8 @@ defmodule WandererApp.Map.Server.SystemsImpl do
   def remove_system_comment(
         map_id,
         comment_id,
-        user_id,
-        character_id
+        _user_id,
+        _character_id
       ) do
     {:ok, %{system_id: system_id} = comment} =
       WandererApp.MapSystemCommentRepo.get_by_id(comment_id)
@@ -146,6 +147,30 @@ defmodule WandererApp.Map.Server.SystemsImpl do
   end
 
   def cleanup_systems(map_id) do
+    # Defensive check: Skip cleanup if cache appears invalid
+    # This prevents incorrectly deleting systems when cache is empty due to
+    # race conditions during map restart or cache corruption
+    case WandererApp.Map.get_map(map_id) do
+      {:error, :not_found} ->
+        Logger.warning(
+          "[cleanup_systems] Skipping map #{map_id} - cache miss detected, " <>
+            "map data not found in cache"
+        )
+
+        :telemetry.execute(
+          [:wanderer_app, :map, :cleanup_systems, :cache_miss],
+          %{system_time: System.system_time()},
+          %{map_id: map_id}
+        )
+
+        :ok
+
+      {:ok, _map} ->
+        do_cleanup_systems(map_id)
+    end
+  end
+
+  defp do_cleanup_systems(map_id) do
     expired_systems =
       map_id
       |> WandererApp.Map.list_systems!()
@@ -309,7 +334,7 @@ defmodule WandererApp.Map.Server.SystemsImpl do
       map_id
       |> WandererApp.MapSystemRepo.remove_from_map(solar_system_id)
       |> case do
-        {:ok, result} ->
+        {:ok, _result} ->
           :ok = WandererApp.Map.remove_system(map_id, solar_system_id)
           @ddrt.delete([solar_system_id], "rtree_#{map_id}")
           Impl.broadcast!(map_id, :systems_removed, [solar_system_id])
@@ -383,6 +408,16 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     |> Enum.each(fn connection ->
       try do
         Logger.debug(fn -> "Removing connection from map: #{inspect(connection)}" end)
+
+        # Audit logging for cascade deletion (no user/character context)
+        WandererApp.User.ActivityTracker.track_map_event(:map_connection_removed, %{
+          character_id: nil,
+          user_id: nil,
+          map_id: map_id,
+          solar_system_source_id: connection.solar_system_source,
+          solar_system_target_id: connection.solar_system_target
+        })
+
         :ok = WandererApp.MapConnectionRepo.destroy(map_id, connection)
         :ok = WandererApp.Map.remove_connection(map_id, connection)
         Impl.broadcast!(map_id, :remove_connections, [connection])
@@ -393,35 +428,77 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     end)
   end
 
+  # When destination systems are deleted, unlink signatures instead of destroying them.
+  # This preserves the user's scan data while removing the stale link.
   defp cleanup_linked_signatures(map_id, removed_solar_system_ids) do
-    removed_solar_system_ids
-    |> Enum.map(fn solar_system_id ->
-      WandererApp.Api.MapSystemSignature.by_linked_system_id!(solar_system_id)
-    end)
-    |> List.flatten()
-    |> Enum.uniq_by(& &1.system_id)
-    |> Enum.each(fn s ->
-      try do
-        {:ok, %{eve_id: eve_id, system: system}} = s |> Ash.load([:system])
-        :ok = Ash.destroy!(s)
+    # Group signatures by their source system for efficient broadcasting
+    signatures_by_system =
+      removed_solar_system_ids
+      |> Enum.flat_map(fn solar_system_id ->
+        WandererApp.Api.MapSystemSignature.by_linked_system_id!(solar_system_id)
+      end)
+      |> Enum.uniq_by(& &1.id)
+      |> Enum.group_by(fn sig -> sig.system_id end)
 
-        # Handle case where parent system was already deleted
-        case system do
-          nil ->
-            Logger.warning(
-              "[cleanup_linked_signatures] signature #{eve_id} destroyed (parent system already deleted)"
-            )
+    signatures_by_system
+    |> Enum.each(fn {_system_id, signatures} ->
+      signatures
+      |> Enum.each(fn sig ->
+        try do
+          {:ok, %{eve_id: eve_id, system: system}} = sig |> Ash.load([:system])
 
-          %{solar_system_id: solar_system_id} ->
-            Logger.warning(
-              "[cleanup_linked_signatures] for system #{solar_system_id}: #{inspect(eve_id)}"
-            )
+          # Clear the linked_system_id instead of destroying the signature
+          # Use the wrapper to log unlink operations
+          case SignaturesImpl.update_signature_linked_system(sig, %{
+                 linked_system_id: nil
+               }) do
+            {:ok, _updated_sig} ->
+              case system do
+                nil ->
+                  Logger.debug(fn ->
+                    "[cleanup_linked_signatures] signature #{eve_id} unlinked (parent system already deleted)"
+                  end)
 
-            Impl.broadcast!(map_id, :signatures_updated, solar_system_id)
+                %{solar_system_id: solar_system_id} ->
+                  Logger.debug(fn ->
+                    "[cleanup_linked_signatures] unlinked signature #{eve_id} in system #{solar_system_id}"
+                  end)
+
+                  # Audit logging for cascade unlink (no user/character context)
+                  WandererApp.User.ActivityTracker.track_map_event(:signatures_unlinked, %{
+                    character_id: nil,
+                    user_id: nil,
+                    map_id: map_id,
+                    solar_system_id: solar_system_id,
+                    signatures: [eve_id]
+                  })
+              end
+
+            {:error, error} ->
+              Logger.error(
+                "[cleanup_linked_signatures] Failed to unlink signature #{sig.eve_id}: #{inspect(error)}"
+              )
+          end
+        rescue
+          e ->
+            Logger.error("Failed to cleanup linked signature: #{inspect(e)}")
         end
-      rescue
-        e ->
-          Logger.error("Failed to cleanup linked signature: #{inspect(e)}")
+      end)
+
+      # Broadcast once per source system after all its signatures are processed
+      case List.first(signatures) do
+        %{system: %{solar_system_id: solar_system_id}} ->
+          Impl.broadcast!(map_id, :signatures_updated, solar_system_id)
+
+        _ ->
+          # Try to get the system info if not preloaded
+          case List.first(signatures) |> Ash.load([:system]) do
+            {:ok, %{system: %{solar_system_id: solar_system_id}}} ->
+              Impl.broadcast!(map_id, :signatures_updated, solar_system_id)
+
+            _ ->
+              :ok
+          end
       end
     end)
   end
@@ -446,8 +523,62 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     end)
   end
 
-  def maybe_add_system(map_id, location, old_location, map_opts)
+  def maybe_add_system(map_id, location, old_location, map_opts, scopes \\ nil)
+
+  def maybe_add_system(map_id, location, old_location, map_opts, scopes)
       when not is_nil(location) do
+    alias WandererApp.Map.Server.ConnectionsImpl
+
+    # Check if the system matches the map's configured scopes before adding
+    should_add =
+      case scopes do
+        nil ->
+          true
+
+        [] ->
+          true
+
+        scopes when is_list(scopes) ->
+          # First check: does the location directly match scopes?
+          if ConnectionsImpl.can_add_location(scopes, location.solar_system_id) do
+            true
+          else
+            # Second check: wormhole border behavior
+            # If :wormholes scope is enabled AND old_location is a wormhole,
+            # allow this system to be added as a border system (so you can see
+            # where your wormhole exits to)
+            wormhole_border_from_wh_space =
+              :wormholes in scopes and
+                not is_nil(old_location) and
+                ConnectionsImpl.can_add_location([:wormholes], old_location.solar_system_id)
+
+            # Third check: k-space wormhole connection
+            # If :wormholes scope is enabled AND there's no stargate between the systems,
+            # this is a wormhole connection through k-space - add both systems
+            kspace_wormhole_connection =
+              :wormholes in scopes and
+                not is_nil(old_location) and
+                not is_nil(old_location.solar_system_id) and
+                ConnectionsImpl.is_kspace_wormhole_connection?(
+                  old_location.solar_system_id,
+                  location.solar_system_id
+                )
+
+            wormhole_border_from_wh_space or kspace_wormhole_connection
+          end
+      end
+
+    if should_add do
+      do_add_system_from_location(map_id, location, old_location, map_opts)
+    else
+      # System filtered out by scope settings - this is expected behavior
+      :ok
+    end
+  end
+
+  def maybe_add_system(_map_id, _location, _old_location, _map_opts, _scopes), do: :ok
+
+  defp do_add_system_from_location(map_id, location, old_location, map_opts) do
     :telemetry.execute(
       [:wanderer_app, :map, :system_addition, :start],
       %{system_time: System.system_time()},
@@ -526,12 +657,14 @@ defmodule WandererApp.Map.Server.SystemsImpl do
             |> case do
               {:ok, solar_system_info} ->
                 # Use upsert instead of create - handles race conditions gracefully
+                # visible: true ensures previously-deleted systems become visible again
                 WandererApp.MapSystemRepo.upsert(%{
                   map_id: map_id,
                   solar_system_id: location.solar_system_id,
                   name: solar_system_info.solar_system_name,
                   position_x: position.x,
-                  position_y: position.y
+                  position_y: position.y,
+                  visible: true
                 })
                 |> case do
                   {:ok, system} ->
@@ -653,8 +786,6 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     end
   end
 
-  def maybe_add_system(_map_id, _location, _old_location, _map_opts), do: :ok
-
   defp do_add_system(
          map_id,
          %{
@@ -679,7 +810,11 @@ defmodule WandererApp.Map.Server.SystemsImpl do
 
           _ ->
             %{x: x, y: y} =
-              WandererApp.Map.PositionCalculator.get_new_system_position(nil, rtree_name, map_opts)
+              WandererApp.Map.PositionCalculator.get_new_system_position(
+                nil,
+                rtree_name,
+                map_opts
+              )
 
             %{"x" => x, "y" => y}
         end
@@ -742,7 +877,10 @@ defmodule WandererApp.Map.Server.SystemsImpl do
                 })
 
               {:error, reason} ->
-                Logger.error("Failed to get system static info for #{solar_system_id}: #{inspect(reason)}")
+                Logger.error(
+                  "Failed to get system static info for #{solar_system_id}: #{inspect(reason)}"
+                )
+
                 {:error, :system_info_not_found}
             end
         end
@@ -775,7 +913,10 @@ defmodule WandererApp.Map.Server.SystemsImpl do
           :ok
 
         {:error, reason} = error ->
-          Logger.error("Failed to add system #{solar_system_id} to map #{map_id}: #{inspect(reason)}")
+          Logger.error(
+            "Failed to add system #{solar_system_id} to map #{map_id}: #{inspect(reason)}"
+          )
+
           error
       end
     else
@@ -863,10 +1004,8 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     updated_system
   end
 
-  defp maybe_update_labels(system, _labels), do: system
-
   defp maybe_update_labels(
-         %{name: old_labels} = system,
+         %{labels: old_labels} = system,
          labels
        )
        when not is_nil(labels) and old_labels != labels do
@@ -980,12 +1119,16 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     # ADDITIVE: Also broadcast to external event system (webhooks/WebSocket)
     # This may fail if the relay is not available (e.g., in tests), which is fine
     WandererApp.ExternalEvents.broadcast(map_id, :system_metadata_changed, %{
+      system_id: updated_system.id,
       solar_system_id: updated_system.solar_system_id,
       name: updated_system.name,
       temporary_name: updated_system.temporary_name,
       labels: updated_system.labels,
       description: updated_system.description,
-      status: updated_system.status
+      status: updated_system.status,
+      locked: updated_system.locked,
+      position_x: updated_system.position_x,
+      position_y: updated_system.position_y
     })
 
     :ok

lib/wanderer_app/maps.ex

@@ -128,7 +128,7 @@ defmodule WandererApp.Maps do
         tracked: tracked
       }
 
-  defp get_map_characters(%{id: map_id} = map) do
+  defp get_map_characters(%{id: map_id} = _map) do
     WandererApp.Cache.lookup!("map_characters-#{map_id}")
     |> case do
       nil ->
@@ -174,9 +174,11 @@ defmodule WandererApp.Maps do
             map_member_alliance_ids: map_member_alliance_ids
           }
 
+        # Cache with 5 minute TTL so ACL changes are picked up even when map server isn't running
         WandererApp.Cache.insert(
           "map_characters-#{map_id}",
-          map_characters
+          map_characters,
+          ttl: :timer.minutes(5)
         )
 
         {:ok, map_characters}

lib/wanderer_app/repositories/map_connection_repo.ex

@@ -99,7 +99,7 @@ defmodule WandererApp.MapConnectionRepo do
   def get_by_id(map_id, id) do
     # Use read_by_map action which doesn't have the FilterConnectionsByActorMap preparation
     # that was causing "filter being false" errors in tests
-    import Ash.Query
+    require Ash.Query
 
     WandererApp.Api.MapConnection
     |> Ash.Query.for_read(:read_by_map, %{map_id: map_id})

lib/wanderer_app/repositories/map_pings_repo.ex

@@ -29,6 +29,34 @@ defmodule WandererApp.MapPingsRepo do
   def get_by_inserted_before(inserted_before_date),
     do: WandererApp.Api.MapPing.by_inserted_before(inserted_before_date)
 
+  @doc """
+  Returns all pings that have orphaned relationships (nil system, character, or map)
+  or where the system has been soft-deleted (visible = false).
+  These pings should be cleaned up as they can no longer be properly displayed or cancelled.
+  """
+  def get_orphaned_pings() do
+    # Use :all_pings action which has no actor filtering (unlike primary :read)
+    case WandererApp.Api.MapPing |> Ash.Query.for_read(:all_pings) |> Ash.read() do
+      {:ok, pings} ->
+        # Load relationships and filter for orphaned ones
+        orphaned =
+          pings
+          |> Enum.map(fn ping ->
+            {:ok, loaded} = ping |> Ash.load([:system, :character, :map], authorize?: false)
+            loaded
+          end)
+          |> Enum.filter(fn ping ->
+            is_nil(ping.system) or is_nil(ping.character) or is_nil(ping.map) or
+              (not is_nil(ping.system) and ping.system.visible == false)
+          end)
+
+        {:ok, orphaned}
+
+      error ->
+        error
+    end
+  end
+
   def create(ping), do: ping |> WandererApp.Api.MapPing.new()
   def create!(ping), do: ping |> WandererApp.Api.MapPing.new!()
 
@@ -39,5 +67,23 @@ defmodule WandererApp.MapPingsRepo do
     :ok
   end
 
-  def destroy(_ping_id), do: :ok
+  @doc """
+  Deletes all pings for a given map. Use with caution - for cleanup purposes.
+  """
+  def delete_all_for_map(map_id) do
+    case get_by_map(map_id) do
+      {:ok, pings} ->
+        Logger.info("[MapPingsRepo] Deleting #{length(pings)} pings for map #{map_id}")
+
+        Enum.each(pings, fn ping ->
+          Logger.info("[MapPingsRepo] Deleting ping #{ping.id} (type: #{ping.type})")
+          Ash.destroy!(ping)
+        end)
+
+        {:ok, length(pings)}
+
+      error ->
+        error
+    end
+  end
 end

lib/wanderer_app/repositories/map_repo.ex

@@ -84,7 +84,7 @@ defmodule WandererApp.MapRepo do
             end
         end
 
-      error in Ash.Error.Query.NotFound ->
+      _error in Ash.Error.Query.NotFound ->
         Logger.debug("Map not found with slug: #{slug}")
         {:error, :not_found}
 

lib/wanderer_app/security_audit.ex

@@ -487,15 +487,6 @@ defmodule WandererApp.SecurityAudit do
 
   # Private functions
 
-  defp store_audit_entry(_audit_entry) do
-    # Handle async processing if enabled
-    # if async_enabled?() do
-    #   WandererApp.SecurityAudit.AsyncProcessor.log_event(audit_entry)
-    # else
-    #   do_store_audit_entry(audit_entry)
-    # end
-  end
-
   @doc false
   def do_store_audit_entry(audit_entry) do
     # Ensure event_type is properly formatted
@@ -631,11 +622,6 @@ defmodule WandererApp.SecurityAudit do
     end
   end
 
-  defp async_enabled? do
-    Application.get_env(:wanderer_app, __MODULE__, [])
-    |> Keyword.get(:async, false)
-  end
-
   defp emit_telemetry_event(audit_entry) do
     :telemetry.execute(
       [:wanderer_app, :security_audit],

lib/wanderer_app/test/logger.ex

@@ -5,7 +5,11 @@ defmodule WandererApp.Test.Logger do
   """
 
   @callback info(message :: iodata() | (-> iodata())) :: :ok
+  @callback info(message :: iodata() | (-> iodata()), metadata :: keyword()) :: :ok
   @callback error(message :: iodata() | (-> iodata())) :: :ok
+  @callback error(message :: iodata() | (-> iodata()), metadata :: keyword()) :: :ok
   @callback warning(message :: iodata() | (-> iodata())) :: :ok
+  @callback warning(message :: iodata() | (-> iodata()), metadata :: keyword()) :: :ok
   @callback debug(message :: iodata() | (-> iodata())) :: :ok
+  @callback debug(message :: iodata() | (-> iodata()), metadata :: keyword()) :: :ok
 end

lib/wanderer_app/test/logger_stub.ex

@@ -9,12 +9,24 @@ defmodule WandererApp.Test.LoggerStub do
   @impl true
   def info(_message), do: :ok
 
+  @impl true
+  def info(_message, _metadata), do: :ok
+
   @impl true
   def error(_message), do: :ok
 
+  @impl true
+  def error(_message, _metadata), do: :ok
+
   @impl true
   def warning(_message), do: :ok
 
+  @impl true
+  def warning(_message, _metadata), do: :ok
+
   @impl true
   def debug(_message), do: :ok
+
+  @impl true
+  def debug(_message, _metadata), do: :ok
 end

lib/wanderer_app/vault.ex

@@ -124,7 +124,7 @@ defmodule WandererApp.Vault do
     end)
   end
 
-  defp find_fallback_module_to_decrypt(config, ciphertext) do
+  defp find_fallback_module_to_decrypt(config, _ciphertext) do
     Enum.find(config[:ciphers], fn {label, _} ->
       label == :fallback
     end)

lib/wanderer_app_web/api_router.ex

@@ -12,7 +12,6 @@ defmodule WandererAppWeb.ApiRouter do
   """
 
   use Phoenix.Router
-  import WandererAppWeb.ApiRouterHelpers
   alias WandererAppWeb.{ApiRoutes, ApiRouter.RouteSpec}
   require Logger
 
@@ -171,7 +170,7 @@ defmodule WandererAppWeb.ApiRouter do
     |> halt()
   end
 
-  defp find_similar_routes(path_info, version) do
+  defp find_similar_routes(path_info, _version) do
     # Find routes with similar paths in current or other versions
     all_routes = ApiRoutes.table()
 

lib/wanderer_app_web/api_spec.ex

@@ -1,7 +1,7 @@
 defmodule WandererAppWeb.ApiSpec do
   @behaviour OpenApiSpex.OpenApi
 
-  alias OpenApiSpex.{OpenApi, Info, Paths, Components, SecurityScheme, Server, Schema}
+  alias OpenApiSpex.{OpenApi, Info, Paths, Components, SecurityScheme, Server}
   alias WandererAppWeb.{Endpoint, Router}
   alias WandererAppWeb.Schemas.ApiSchemas
 

lib/wanderer_app_web/components/core_components.ex

@@ -284,6 +284,7 @@ defmodule WandererAppWeb.CoreComponents do
   """
   attr(:type, :string, default: nil)
   attr(:class, :string, default: nil)
+  attr(:data, :any, default: nil)
   attr(:rest, :global, include: ~w(disabled form name value))
 
   slot(:inner_block, required: true)
@@ -296,6 +297,7 @@ defmodule WandererAppWeb.CoreComponents do
         "phx-submit-loading:opacity-75 p-button p-component p-button-outlined p-button-sm",
         @class
       ]}
+      data={@data}
       {@rest}
     >
       {render_slot(@inner_block)}
@@ -614,7 +616,7 @@ defmodule WandererAppWeb.CoreComponents do
   attr(:empty_label, :string, default: nil)
   attr(:rows, :list, required: true)
   attr(:row_id, :any, default: nil, doc: "the function for generating the row id")
-  attr(:row_selected, :boolean, default: false, doc: "the function for generating the row id")
+  attr(:row_selected, :any, default: false, doc: "the function for generating the row id")
   attr(:row_click, :any, default: nil, doc: "the function for handling phx-click on each row")
 
   attr(:row_item, :any,
@@ -703,13 +705,21 @@ defmodule WandererAppWeb.CoreComponents do
     """
   end
 
+  attr(:field, :any, required: true)
   attr(:placeholder, :string, default: nil)
   attr(:label, :string, default: nil)
   attr(:label_class, :string, default: nil)
   attr(:input_class, :string, default: nil)
   attr(:dropdown_extra_class, :string, default: nil)
   attr(:option_extra_class, :string, default: nil)
+  attr(:mode, :atom, default: :single)
+  attr(:options, :list, default: [])
+  attr(:debounce, :integer, default: nil)
+  attr(:update_min_len, :integer, default: nil)
+  attr(:available_option_class, :string, default: nil)
+  attr(:value_mapper, :any, default: nil)
   slot(:inner_block)
+  slot(:option)
 
   def live_select(%{field: %Phoenix.HTML.FormField{} = field} = assigns) do
     assigns =

lib/wanderer_app_web/components/layouts.ex

@@ -23,6 +23,7 @@ defmodule WandererAppWeb.Layouts do
 
   attr :app_version, :string
   attr :enabled, :boolean
+  attr :latest_post, :any, default: nil
 
   def new_version_banner(assigns) do
     ~H"""
@@ -36,27 +37,89 @@ defmodule WandererAppWeb.Layouts do
     >
       <div class="hs-overlay-backdrop transition duration absolute left-0 top-0 w-full h-full bg-gray-900 bg-opacity-50 dark:bg-opacity-80 dark:bg-neutral-900">
       </div>
-      <div class="absolute top-[50%] left-[50%] translate-x-[-50%] translate-y-[-50%] flex items-center">
-        <div class="rounded w-9 h-9 w-[80px] h-[66px] flex items-center justify-center relative z-20">
-          <.icon name="hero-chevron-double-right" class="w-9 h-9 mr-[-40px]" />
-        </div>
-        <div id="refresh-area">
-          <.live_component module={WandererAppWeb.MapRefresh} id="map-refresh" />
+      <div class="absolute top-[50%] left-[50%] translate-x-[-50%] translate-y-[-50%] flex flex-col items-center gap-6">
+        <div class="flex items-center">
+          <div class="rounded w-9 h-9 w-[80px] h-[66px] flex items-center justify-center relative z-20">
+            <.icon name="hero-chevron-double-right" class="w-9 h-9 mr-[-40px]" />
+          </div>
+          <div id="refresh-area">
+            <.live_component module={WandererAppWeb.MapRefresh} id="map-refresh" />
+          </div>
+
+          <div class="rounded h-[66px] flex items-center justify-center relative z-20">
+            <div class=" flex items-center w-[200px] h-full">
+              <.icon name="hero-chevron-double-left" class="w-9 h-9 mr-[20px]" />
+              <div class=" flex flex-col items-center justify-center h-full">
+                <div class="text-white text-nowrap text-sm [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]">
+                  Update Required
+                </div>
+                <a
+                  href="/changelog"
+                  target="_blank"
+                  class="text-sm link-secondary [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]"
+                >
+                  What's new?
+                </a>
+              </div>
+            </div>
+          </div>
         </div>
 
-        <div class="rounded h-[66px] flex items-center justify-center relative z-20">
-          <div class=" flex items-center w-[200px] h-full">
-            <.icon name="hero-chevron-double-left" class="w-9 h-9 mr-[20px]" />
-            <div class=" flex flex-col items-center justify-center h-full">
-              <div class="text-white text-nowrap text-sm [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]">
-                Update Required
+        <div class="flex flex-row gap-6 z-20">
+          <div
+            :if={@latest_post}
+            class="bg-gray-800/80 rounded-lg overflow-hidden min-w-[300px] backdrop-blur-sm border border-gray-700"
+          >
+            <a href={"/news/#{@latest_post.id}"} target="_blank" class="block group/post">
+              <div class="relative">
+                <img
+                  src={@latest_post.cover_image_uri}
+                  class="w-[300px] h-[140px] object-cover opacity-80 group-hover/post:opacity-100 transition-opacity"
+                />
+                <div class="absolute top-0 left-0 w-full h-full bg-gradient-to-b from-transparent to-black/70">
+                </div>
+                <div class="absolute top-2 left-2 flex items-center gap-1 bg-orange-500/90 px-2 py-0.5 rounded text-xs font-semibold">
+                  <.icon name="hero-newspaper-solid" class="w-3 h-3" />
+                  <span>Latest News</span>
+                </div>
+                <div class="absolute bottom-0 left-0 w-full p-3">
+                  <% [first_part | rest] = String.split(@latest_post.title, ":", parts: 2) %>
+                  <h3 class="text-white text-sm font-bold ccp-font [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]">
+                    {first_part}
+                  </h3>
+                  <p
+                    :if={rest != []}
+                    class="text-gray-200 text-xs ccp-font text-ellipsis overflow-hidden whitespace-nowrap [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]"
+                  >
+                    {List.first(rest)}
+                  </p>
+                </div>
               </div>
+            </a>
+          </div>
+
+          <div class="bg-gray-800/80 rounded-lg p-4 min-w-[280px] backdrop-blur-sm border border-gray-700">
+            <div class="flex items-center gap-2 mb-3">
+              <.icon name="hero-gift-solid" class="w-5 h-5 text-green-400" />
+              <span class="text-white font-semibold text-sm [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]">
+                Support Wanderer
+              </span>
+            </div>
+            <div class="text-gray-300 text-xs mb-3 [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]">
+              Buy PLEX from the official EVE Online store using our promocode to support the development.
+            </div>
+            <div class="flex items-center gap-3">
+              <code class="bg-gray-900/60 px-2 py-1 rounded text-green-400 text-sm font-mono border border-gray-600">
+                WANDERER
+              </code>
               <a
-                href="/changelog"
+                href="https://www.eveonline.com/plex"
                 target="_blank"
-                class="text-sm link-secondary [text-shadow:_0_1px_0_rgb(0_0_0_/_40%)]"
+                rel="noopener noreferrer"
+                class="inline-flex items-center gap-1 text-sm text-green-400 hover:text-green-300 transition-colors"
               >
-                What's new?
+                <span>Get PLEX</span>
+                <.icon name="hero-arrow-top-right-on-square-mini" class="w-4 h-4" />
               </a>
             </div>
           </div>

lib/wanderer_app_web/components/layouts/live.html.heex

@@ -31,7 +31,7 @@
     </div>
   </aside>
 
-  <.new_version_banner app_version={@app_version} enabled={@map_subscriptions_enabled?} />
+  <.new_version_banner app_version={@app_version} enabled={true} latest_post={@latest_post} />
 </div>
 
 <.live_component module={WandererAppWeb.Alerts} id="notifications" view_flash={@flash} />

lib/wanderer_app_web/controllers/access_list_member_api_controller.ex

@@ -433,6 +433,10 @@ defmodule WandererAppWeb.AccessListMemberAPIController do
   # ---------------------------------------------------------------------------
 
   defp broadcast_acl_updated(acl_id) do
+    # Invalidate map_characters cache for all maps using this ACL
+    # This ensures the tracking page shows updated members even when map server isn't running
+    invalidate_map_characters_cache(acl_id)
+
     Phoenix.PubSub.broadcast(
       WandererApp.PubSub,
       "acls:#{acl_id}",
@@ -440,6 +444,23 @@ defmodule WandererAppWeb.AccessListMemberAPIController do
     )
   end
 
+  defp invalidate_map_characters_cache(acl_id) do
+    case Ash.read(
+           WandererApp.Api.MapAccessList
+           |> Ash.Query.for_read(:read_by_acl, %{acl_id: acl_id})
+         ) do
+      {:ok, map_acls} ->
+        Enum.each(map_acls, fn %{map_id: map_id} ->
+          WandererApp.Cache.delete("map_characters-#{map_id}")
+        end)
+
+      {:error, error} ->
+        Logger.warning(
+          "Failed to invalidate map_characters cache for ACL #{acl_id}: #{inspect(error)}"
+        )
+    end
+  end
+
   @doc false
   defp member_to_json(member) do
     base = %{

lib/wanderer_app_web/controllers/auth_controller.ex

@@ -42,12 +42,18 @@ defmodule WandererAppWeb.AuthController do
 
           WandererApp.Character.update_character(character.id, character_update)
 
+          # Update corporation/alliance data from ESI to ensure access control is current
+          update_character_affiliation(character)
+
           {:ok, character}
 
         {:error, _error} ->
           {:ok, character} = WandererApp.Api.Character.create(character_data)
           :telemetry.execute([:wanderer_app, :user, :character, :registered], %{count: 1})
 
+          # Fetch initial corporation/alliance data for new characters
+          update_character_affiliation(character)
+
           {:ok, character}
       end
 
@@ -113,4 +119,102 @@ defmodule WandererAppWeb.AuthController do
   end
 
   def maybe_update_character_user_id(_character, _user_id), do: :ok
+
+  # Updates character's corporation and alliance data from ESI.
+  # This ensures ACL-based access control uses current corporation membership,
+  # even for characters not actively being tracked on any map.
+  defp update_character_affiliation(%{id: character_id, eve_id: eve_id} = character) do
+    # Run async to not block the SSO callback
+    Task.start(fn ->
+      character_eve_id = eve_id |> String.to_integer()
+
+      case WandererApp.Esi.post_characters_affiliation([character_eve_id]) do
+        {:ok, [affiliation_info]} when is_map(affiliation_info) ->
+          new_corporation_id = Map.get(affiliation_info, "corporation_id")
+          new_alliance_id = Map.get(affiliation_info, "alliance_id")
+
+          # Check if corporation changed
+          corporation_changed = character.corporation_id != new_corporation_id
+          alliance_changed = character.alliance_id != new_alliance_id
+
+          if corporation_changed or alliance_changed do
+            update_affiliation_data(character_id, character, new_corporation_id, new_alliance_id)
+          end
+
+        {:error, error} ->
+          Logger.warning(
+            "[AuthController] Failed to fetch affiliation for character #{character_id}: #{inspect(error)}"
+          )
+
+        _ ->
+          :ok
+      end
+    end)
+  end
+
+  defp update_character_affiliation(_character), do: :ok
+
+  defp update_affiliation_data(character_id, character, corporation_id, alliance_id) do
+    # Fetch corporation info
+    corporation_update =
+      case WandererApp.Esi.get_corporation_info(corporation_id) do
+        {:ok, %{"name" => corp_name, "ticker" => corp_ticker}} ->
+          %{
+            corporation_id: corporation_id,
+            corporation_name: corp_name,
+            corporation_ticker: corp_ticker
+          }
+
+        _ ->
+          %{corporation_id: corporation_id}
+      end
+
+    # Fetch alliance info if present
+    alliance_update =
+      case alliance_id do
+        nil ->
+          %{alliance_id: nil, alliance_name: nil, alliance_ticker: nil}
+
+        _ ->
+          case WandererApp.Esi.get_alliance_info(alliance_id) do
+            {:ok, %{"name" => alliance_name, "ticker" => alliance_ticker}} ->
+              %{
+                alliance_id: alliance_id,
+                alliance_name: alliance_name,
+                alliance_ticker: alliance_ticker
+              }
+
+            _ ->
+              %{alliance_id: alliance_id}
+          end
+      end
+
+    full_update = Map.merge(corporation_update, alliance_update)
+
+    # Update database
+    case character.corporation_id != corporation_id do
+      true ->
+        {:ok, _} = WandererApp.Api.Character.update_corporation(character, corporation_update)
+
+      false ->
+        :ok
+    end
+
+    case character.alliance_id != alliance_id do
+      true ->
+        {:ok, _} = WandererApp.Api.Character.update_alliance(character, alliance_update)
+
+      false ->
+        :ok
+    end
+
+    # Update cache
+    WandererApp.Character.update_character(character_id, full_update)
+
+    Logger.info(
+      "[AuthController] Updated affiliation for character #{character_id}: " <>
+        "corp #{character.corporation_id} -> #{corporation_id}, " <>
+        "alliance #{character.alliance_id} -> #{alliance_id}"
+    )
+  end
 end

lib/wanderer_app_web/controllers/blog_html/index.html.heex

@@ -41,12 +41,19 @@
               <div class="absolute rounded-m top-0 left-0 w-full h-full bg-gradient-to-b from-transparent to-black opacity-75 group-hover:opacity-25 transition-opacity duration-300">
               </div>
               <div class="absolute w-full bottom-2 p-4">
-                <% [first_part, second_part] = String.split(post.title, ":", parts: 2) %>
+                <% {first_part, second_part} =
+                  case String.split(post.title, ":", parts: 2) do
+                    [first, second] -> {first, second}
+                    [first] -> {first, nil}
+                  end %>
                 <h3 class="!m-0 !text-s font-bold break-normal ccp-font whitespace-nowrap text-white">
                   {first_part}
                 </h3>
-                <p class="!m-0 !text-s text-white text-ellipsis overflow-hidden whitespace-nowrap ccp-font">
-                  {second_part || ""}
+                <p
+                  :if={second_part}
+                  class="!m-0 !text-s text-white text-ellipsis overflow-hidden whitespace-nowrap ccp-font"
+                >
+                  {second_part}
                 </p>
               </div>
             </div>

lib/wanderer_app_web/controllers/blog_html/show.html.heex

@@ -115,7 +115,9 @@
         {@post.description}
       </h4>
       <!--Post Content-->
-      {raw(@post.body)}
+      <div class="post-content">
+        {raw(@post.body)}
+      </div>
     </div>
   </div>
   <!--/container-->

lib/wanderer_app_web/controllers/license_api_controller.ex

@@ -123,12 +123,6 @@ defmodule WandererAppWeb.LicenseApiController do
     end
   end
 
-  def update_validity(conn, %{"id" => _license_id}) do
-    conn
-    |> put_status(:bad_request)
-    |> json(%{error: "Missing required parameter: is_valid"})
-  end
-
   @doc """
   Updates a license's expiration date.
 

lib/wanderer_app_web/controllers/map_api_controller.ex

@@ -2,12 +2,10 @@ defmodule WandererAppWeb.MapAPIController do
   use WandererAppWeb, :controller
   use OpenApiSpex.ControllerSpecs
 
-  import Ash.Query, only: [filter: 2]
+  require Ash.Query
   require Logger
 
-  alias WandererApp.Api.Character
   alias WandererApp.MapSystemRepo
-  alias WandererApp.MapCharacterSettingsRepo
   alias WandererApp.MapConnectionRepo
   alias WandererAppWeb.Helpers.APIUtils
   alias WandererAppWeb.Schemas.{ApiSchemas, ResponseSchemas}
@@ -16,7 +14,7 @@ defmodule WandererAppWeb.MapAPIController do
   # V1 API Actions (for compatibility with versioned API router)
   # -----------------------------------------------------------------
 
-  def index_v1(conn, params) do
+  def index_v1(conn, _params) do
     # Delegate to the existing list implementation or create a basic one
     json(conn, %{
       data: [],
@@ -43,7 +41,7 @@ defmodule WandererAppWeb.MapAPIController do
     })
   end
 
-  def create_v1(conn, params) do
+  def create_v1(conn, _params) do
     # Basic create implementation for testing
     json(conn, %{
       data: %{
@@ -59,7 +57,7 @@ defmodule WandererAppWeb.MapAPIController do
     })
   end
 
-  def update_v1(conn, %{"id" => id} = params) do
+  def update_v1(conn, %{"id" => id} = _params) do
     # Basic update implementation for testing
     json(conn, %{
       data: %{
@@ -82,7 +80,7 @@ defmodule WandererAppWeb.MapAPIController do
     |> text("")
   end
 
-  def duplicate_v1(conn, %{"id" => id} = params) do
+  def duplicate_v1(conn, %{"id" => id} = _params) do
     # Basic duplicate implementation for testing
     json(conn, %{
       data: %{
@@ -99,7 +97,7 @@ defmodule WandererAppWeb.MapAPIController do
     })
   end
 
-  def bulk_create_v1(conn, params) do
+  def bulk_create_v1(conn, _params) do
     # Basic bulk create implementation for testing
     json(conn, %{
       data: [
@@ -121,7 +119,7 @@ defmodule WandererAppWeb.MapAPIController do
     })
   end
 
-  def bulk_update_v1(conn, params) do
+  def bulk_update_v1(conn, _params) do
     # Basic bulk update implementation for testing
     json(conn, %{
       data: [
@@ -325,13 +323,6 @@ defmodule WandererAppWeb.MapAPIController do
   # Helper functions for the API controller
   # -----------------------------------------------------------------
 
-  defp get_map_id_by_slug(slug) do
-    case WandererApp.Api.Map.get_map_by_slug(slug) do
-      {:ok, map} -> {:ok, map.id}
-      {:error, error} -> {:error, "Map not found for slug: #{slug}, error: #{inspect(error)}"}
-    end
-  end
-
   defp normalize_map_identifier(params) do
     case Map.get(params, "map_identifier") do
       nil ->

lib/wanderer_app_web/controllers/map_audit_api_controller.ex

@@ -4,8 +4,7 @@ defmodule WandererAppWeb.MapAuditAPIController do
 
   require Logger
 
-  alias WandererApp.Api
-
+  alias WandererAppWeb.UserActivityItem
   alias WandererAppWeb.Helpers.APIUtils
 
   # -----------------------------------------------------------------
@@ -155,10 +154,10 @@ defmodule WandererAppWeb.MapAuditAPIController do
 
     result
     |> Map.put(:character, WandererAppWeb.MapEventHandler.map_ui_character_stat(character))
-    |> Map.put(:event_name, WandererAppWeb.UserActivity.get_event_name(event_type))
+    |> Map.put(:event_name, WandererAppWeb.UserActivityItem.get_event_name(event_type))
     |> Map.put(
       :event_data,
-      WandererAppWeb.UserActivity.get_event_data(
+      WandererAppWeb.UserActivityItem.get_event_data(
         event_type,
         Jason.decode!(event_data) |> Map.drop(["character_id"])
       )

lib/wanderer_app_web/controllers/map_events_api_controller.ex

@@ -65,24 +65,6 @@ defmodule WandererAppWeb.MapEventsAPIController do
                             items: @event_schema
                           })
 
-  @events_list_params %OpenApiSpex.Schema{
-    type: :object,
-    properties: %{
-      since: %OpenApiSpex.Schema{
-        type: :string,
-        format: :date_time,
-        description: "Return events after this timestamp (ISO8601)"
-      },
-      limit: %OpenApiSpex.Schema{
-        type: :integer,
-        minimum: 1,
-        maximum: 100,
-        default: 100,
-        description: "Maximum number of events to return"
-      }
-    }
-  }
-
   # -----------------------------------------------------------------
   # OpenApiSpex Operations
   # -----------------------------------------------------------------
@@ -173,7 +155,7 @@ defmodule WandererAppWeb.MapEventsAPIController do
         |> put_status(:bad_request)
         |> json(%{error: "Invalid 'limit' parameter. Must be between 1 and 100."})
 
-      {:error, reason} ->
+      {:error, _reason} ->
         conn
         |> put_status(:internal_server_error)
         |> json(%{error: "Internal server error"})
@@ -184,7 +166,7 @@ defmodule WandererAppWeb.MapEventsAPIController do
   # Private Functions
   # -----------------------------------------------------------------
 
-  defp get_map(conn, map_identifier) do
+  defp get_map(conn, _map_identifier) do
     # The map should already be loaded by the CheckMapApiKey plug
     case conn.assigns[:map] do
       nil -> {:error, :map_not_found}

lib/wanderer_app_web/controllers/map_system_api_controller.ex

@@ -487,10 +487,17 @@ defmodule WandererAppWeb.MapSystemAPIController do
   )
 
   def create(conn, params) do
-    # Support both batch format {"systems": [...], "connections": [...]}
-    # and single system format {"solar_system_id": ..., ...}
+    # Support multiple formats:
+    # 1. Batch format: {"systems": [...], "connections": [...]}
+    # 2. Wrapped batch format: {"data": {"systems": [...], "connections": [...]}}
+    # 3. Single system format: {"solar_system_id": ..., ...}
     {systems, connections} =
       cond do
+        Map.has_key?(params, "data") and is_map(params["data"]) ->
+          # Wrapped batch format - extract from data wrapper
+          data = params["data"]
+          {Map.get(data, "systems", []), Map.get(data, "connections", [])}
+
         Map.has_key?(params, "systems") ->
           # Batch format
           {Map.get(params, "systems", []), Map.get(params, "connections", [])}

lib/wanderer_app_web/controllers/map_system_signature_api_controller.ex

@@ -190,9 +190,37 @@ defmodule WandererAppWeb.MapSystemSignatureAPIController do
   The `character_eve_id` field is optional. If provided, it must be a valid character
   that exists in the database, otherwise a 422 error will be returned. If not provided,
   the signature will be associated with the map owner's character.
+
+  ## Auto-add System Behavior
+
+  If the `solar_system_id` is not already on the map, it will be automatically added.
+  The system must be a valid EVE Online solar system ID.
+
+  ## Linked System and Connection Behavior
+
+  If `linked_system_id` is provided (for wormhole signatures):
+  - The linked system will be automatically added to the map if not present
+  - A connection will be created between the source and linked systems if one doesn't exist
+  - If a connection already exists, its ship size will be updated based on the wormhole `type`
+  - The wormhole `type` (e.g., "H296", "C2", "K162") is used to determine connection ship size:
+    - H296 → XL/Freighter size (1B kg max mass)
+    - N770, D845 → Large size (375M kg max mass)
+    - etc.
   """
   operation(:create,
     summary: "Create a new signature",
+    description: """
+    Creates a new cosmic signature in the specified solar system.
+
+    **Auto-add behavior**: If the solar_system_id is not already on the map, it will be
+    automatically added. The system must be a valid EVE Online solar system ID.
+
+    **Linked system behavior**: If linked_system_id is provided:
+    - The linked system is auto-added to the map if not present
+    - A wormhole connection is auto-created between the systems
+    - The connection's ship_size_type is inferred from the wormhole type (e.g., H296 → XL)
+    - If the connection already exists, its ship size is updated based on the wormhole type
+    """,
     parameters: [
       map_identifier: [
         in: :path,
@@ -218,7 +246,7 @@ defmodule WandererAppWeb.MapSystemSignatureAPIController do
              error: %OpenApiSpex.Schema{
                type: :string,
                description:
-                 "Error type (e.g., 'invalid_character', 'system_not_found', 'missing_params')"
+                 "Error type (e.g., 'invalid_character', 'invalid_solar_system', 'missing_params')"
              }
            },
            example: %{error: "invalid_character"}
@@ -311,4 +339,117 @@ defmodule WandererAppWeb.MapSystemSignatureAPIController do
       {:error, error} -> conn |> put_status(:unprocessable_entity) |> json(%{error: error})
     end
   end
+
+  @doc """
+  Link a signature to a target system.
+
+  This creates the association between a wormhole signature and the system it leads to.
+  It also updates the connection's time_status and ship_size_type based on the signature data.
+  """
+  operation(:link,
+    summary: "Link a signature to a target system",
+    description: """
+    Links a wormhole signature to its destination system. This operation:
+    - Sets the signature's linked_system_id to the target system
+    - Updates the signature's group to "Wormhole"
+    - Sets the target system's linked_sig_eve_id (if not already set)
+    - Copies temporary_name from signature to target system
+    - Updates the connection's time_status and ship_size_type from signature data
+    """,
+    parameters: [
+      map_identifier: [
+        in: :path,
+        description: "Map identifier (UUID or slug)",
+        type: :string,
+        required: true
+      ],
+      id: [in: :path, description: "Signature UUID", type: :string, required: true]
+    ],
+    request_body:
+      {"Link request", "application/json",
+       %OpenApiSpex.Schema{
+         type: :object,
+         properties: %{
+           solar_system_target: %OpenApiSpex.Schema{
+             type: :integer,
+             description: "Target solar system ID to link to"
+           }
+         },
+         required: [:solar_system_target],
+         example: %{solar_system_target: 31_001_922}
+       }},
+    responses: [
+      ok:
+        {"Linked signature", "application/json",
+         %OpenApiSpex.Schema{
+           type: :object,
+           properties: %{data: @signature_schema},
+           example: %{data: @signature_schema.example}
+         }},
+      unprocessable_entity:
+        {"Error", "application/json",
+         %OpenApiSpex.Schema{
+           type: :object,
+           properties: %{
+             error: %OpenApiSpex.Schema{
+               type: :string,
+               description: "Error type"
+             }
+           },
+           example: %{error: "target_system_not_found"}
+         }}
+    ]
+  )
+
+  def link(conn, %{"id" => id} = params) do
+    case MapOperations.link_signature(conn, id, params) do
+      {:ok, sig} -> json(conn, %{data: sig})
+      {:error, error} -> conn |> put_status(:unprocessable_entity) |> json(%{error: error})
+    end
+  end
+
+  @doc """
+  Unlink a signature from its target system.
+  """
+  operation(:unlink,
+    summary: "Unlink a signature from its target system",
+    description: "Removes the link between a signature and its destination system.",
+    parameters: [
+      map_identifier: [
+        in: :path,
+        description: "Map identifier (UUID or slug)",
+        type: :string,
+        required: true
+      ],
+      id: [in: :path, description: "Signature UUID", type: :string, required: true]
+    ],
+    responses: [
+      ok:
+        {"Unlinked signature", "application/json",
+         %OpenApiSpex.Schema{
+           type: :object,
+           properties: %{data: @signature_schema},
+           example: %{data: Map.put(@signature_schema.example, :linked_system_id, nil)}
+         }},
+      unprocessable_entity:
+        {"Error", "application/json",
+         %OpenApiSpex.Schema{
+           type: :object,
+           properties: %{
+             error: %OpenApiSpex.Schema{
+               type: :string,
+               description: "Error type"
+             }
+           },
+           example: %{error: "not_linked"}
+         }}
+    ]
+  )
+
+  def unlink(conn, %{"id" => id}) do
+    case MapOperations.unlink_signature(conn, id) do
+      {:ok, sig} -> json(conn, %{data: sig})
+      {:error, error} -> conn |> put_status(:unprocessable_entity) |> json(%{error: error})
+    end
+  end
 end

lib/wanderer_app_web/controllers/plugs/json_api_performance_monitor.ex

@@ -36,7 +36,7 @@ defmodule WandererAppWeb.Plugs.JsonApiPerformanceMonitor do
       conn
       |> register_before_send(fn conn ->
         end_time = System.monotonic_time(:millisecond)
-        duration = end_time - start_time
+        _duration = end_time - start_time
 
         # Extract response metadata
         response_metadata = extract_response_metadata(conn, request_metadata)

lib/wanderer_app_web/controllers/plugs/license_auth.ex

@@ -12,7 +12,6 @@ defmodule WandererAppWeb.Plugs.LicenseAuth do
   require Logger
 
   alias WandererApp.License.LicenseManager
-  alias WandererApp.Helpers.Config
 
   @doc """
   Authenticates requests using the LM_AUTH_KEY.
@@ -21,7 +20,7 @@ defmodule WandererAppWeb.Plugs.LicenseAuth do
   """
   def authenticate_lm(conn, _opts) do
     auth_header = get_req_header(conn, "authorization")
-    lm_auth_key = Config.get_env(:wanderer_app, :lm_auth_key)
+    lm_auth_key = Application.get_env(:wanderer_app, :lm_auth_key)
 
     case auth_header do
       ["Bearer " <> token] ->

lib/wanderer_app_web/controllers/user_auth.ex

@@ -37,7 +37,7 @@ defmodule WandererAppWeb.UserAuth do
           nil ->
             {:halt, redirect_require_login(socket)}
 
-          %User{characters: characters} ->
+          %User{characters: _characters} ->
             {:cont, new_socket}
         end
 
@@ -112,13 +112,6 @@ defmodule WandererAppWeb.UserAuth do
     |> LiveView.redirect(to: ~p"/")
   end
 
-  defp track_characters([]), do: :ok
-
-  defp track_characters([%{id: character_id} | characters]) do
-    :ok = WandererApp.Character.TrackerManager.start_tracking(character_id)
-    track_characters(characters)
-  end
-
   defp maybe_store_return_to(%{method: "GET"} = conn) do
     %{request_path: request_path, query_string: query_string} = conn
     return_to = if query_string == "", do: request_path, else: request_path <> "?" <> query_string

lib/wanderer_app_web/live/access_lists/access_lists_live.ex

@@ -2,8 +2,11 @@ defmodule WandererAppWeb.AccessListsLive do
   use WandererAppWeb, :live_view
 
   alias WandererApp.ExternalEvents.AclEventBroadcaster
+  require Ash.Query
   require Logger
 
+  @members_per_page 50
+
   @impl true
   def mount(_params, %{"user_id" => user_id} = _session, socket) when not is_nil(user_id) do
     {:ok, characters} = WandererApp.Api.Character.active_by_user(%{user_id: user_id})
@@ -24,7 +27,9 @@ defmodule WandererAppWeb.AccessListsLive do
        user_id: user_id,
        access_lists: access_lists |> Enum.map(fn acl -> map_ui_acl(acl, nil) end),
        characters: characters,
-       members: []
+       members: [],
+       members_page: 1,
+       members_per_page: @members_per_page
      )}
   end
 
@@ -38,7 +43,9 @@ defmodule WandererAppWeb.AccessListsLive do
        allow_acl_creation: false,
        access_lists: [],
        characters: [],
-       members: []
+       members: [],
+       members_page: 1,
+       members_per_page: @members_per_page
      )}
   end
 
@@ -92,10 +99,8 @@ defmodule WandererAppWeb.AccessListsLive do
       |> assign(:page_title, "Access Lists - Members")
       |> assign(:selected_acl_id, acl_id)
       |> assign(:access_list, access_list)
-      |> assign(
-        :members,
-        members
-      )
+      |> assign(:members, members)
+      |> assign(:members_page, 1)
     else
       _ ->
         socket
@@ -281,11 +286,7 @@ defmodule WandererAppWeb.AccessListsLive do
     |> Enum.find(&(&1.id == member_id))
     |> WandererApp.Api.AccessListMember.destroy!()
 
-    Phoenix.PubSub.broadcast(
-      WandererApp.PubSub,
-      "acls:#{socket.assigns.selected_acl_id}",
-      {:acl_updated, %{acl_id: socket.assigns.selected_acl_id}}
-    )
+    broadcast_acl_updated(socket.assigns.selected_acl_id)
 
     {:noreply,
      socket
@@ -327,6 +328,20 @@ defmodule WandererAppWeb.AccessListsLive do
     {:noreply, assign(socket, form: form)}
   end
 
+  @impl true
+  def handle_event("members_prev_page", _, socket) do
+    new_page = max(1, socket.assigns.members_page - 1)
+    {:noreply, assign(socket, :members_page, new_page)}
+  end
+
+  @impl true
+  def handle_event("members_next_page", _, socket) do
+    total_members = length(socket.assigns.members)
+    max_page = max(1, ceil(total_members / socket.assigns.members_per_page))
+    new_page = min(max_page, socket.assigns.members_page + 1)
+    {:noreply, assign(socket, :members_page, new_page)}
+  end
+
   @impl true
   def handle_event("noop", _, socket) do
     {:noreply, socket}
@@ -444,11 +459,7 @@ defmodule WandererAppWeb.AccessListsLive do
 
         :telemetry.execute([:wanderer_app, :acl, :member, :update], %{count: 1})
 
-        Phoenix.PubSub.broadcast(
-          WandererApp.PubSub,
-          "acls:#{socket.assigns.selected_acl_id}",
-          {:acl_updated, %{acl_id: socket.assigns.selected_acl_id}}
-        )
+        broadcast_acl_updated(socket.assigns.selected_acl_id)
 
         socket
         |> assign(
@@ -574,11 +585,7 @@ defmodule WandererAppWeb.AccessListsLive do
 
         :telemetry.execute([:wanderer_app, :acl, :member, :add], %{count: 1})
 
-        Phoenix.PubSub.broadcast(
-          WandererApp.PubSub,
-          "acls:#{access_list_id}",
-          {:acl_updated, %{acl_id: access_list_id}}
-        )
+        broadcast_acl_updated(access_list_id)
 
         {:ok, member}
 
@@ -613,11 +620,7 @@ defmodule WandererAppWeb.AccessListsLive do
 
         :telemetry.execute([:wanderer_app, :acl, :member, :add], %{count: 1})
 
-        Phoenix.PubSub.broadcast(
-          WandererApp.PubSub,
-          "acls:#{access_list_id}",
-          {:acl_updated, %{acl_id: access_list_id}}
-        )
+        broadcast_acl_updated(access_list_id)
 
         {:ok, member}
 
@@ -653,11 +656,7 @@ defmodule WandererAppWeb.AccessListsLive do
 
         :telemetry.execute([:wanderer_app, :acl, :member, :add], %{count: 1})
 
-        Phoenix.PubSub.broadcast(
-          WandererApp.PubSub,
-          "acls:#{access_list_id}",
-          {:acl_updated, %{acl_id: access_list_id}}
-        )
+        broadcast_acl_updated(access_list_id)
 
         {:ok, member}
 
@@ -688,7 +687,7 @@ defmodule WandererAppWeb.AccessListsLive do
     """
   end
 
-  slot(:option)
+  attr(:option, :any, required: true)
 
   def search_member_item(assigns) do
     ~H"""
@@ -737,4 +736,44 @@ defmodule WandererAppWeb.AccessListsLive do
   defp map_ui_acl(acl, selected_id) do
     acl |> Map.put(:selected, acl.id == selected_id)
   end
+
+  defp paginated_members(members, page, per_page) do
+    members
+    |> Enum.sort_by(&{&1.role, &1.name}, &<=/2)
+    |> Enum.drop((page - 1) * per_page)
+    |> Enum.take(per_page)
+  end
+
+  defp total_pages(members, per_page) do
+    max(1, ceil(length(members) / per_page))
+  end
+
+  # Broadcast ACL update and invalidate map_characters cache for all maps using this ACL
+  # This ensures the tracking page shows updated members even when map server isn't running
+  defp broadcast_acl_updated(acl_id) do
+    invalidate_map_characters_cache(acl_id)
+
+    Phoenix.PubSub.broadcast(
+      WandererApp.PubSub,
+      "acls:#{acl_id}",
+      {:acl_updated, %{acl_id: acl_id}}
+    )
+  end
+
+  defp invalidate_map_characters_cache(acl_id) do
+    case Ash.read(
+           WandererApp.Api.MapAccessList
+           |> Ash.Query.for_read(:read_by_acl, %{acl_id: acl_id})
+         ) do
+      {:ok, map_acls} ->
+        Enum.each(map_acls, fn %{map_id: map_id} ->
+          WandererApp.Cache.delete("map_characters-#{map_id}")
+        end)
+
+      {:error, error} ->
+        Logger.warning(
+          "Failed to invalidate map_characters cache for ACL #{acl_id}: #{inspect(error)}"
+        )
+    end
+  end
 end