chore: fixes module pathing

package.json

@@ -6,19 +6,23 @@
         "build": "node esbuild.config.mjs",
         "push": "npm run build && ts-node publish.ts",
         "format": "prettier --check --ignore-path .gitignore .",
-        "format:fix": "prettier --write --ignore-path .gitignore ."
+        "format:fix": "prettier --write --ignore-path .gitignore .",
+        "test": "jest"
     },
     "dependencies": {
         "@trivago/prettier-plugin-sort-imports": "^6.0.2",
         "@types/screeps": "^3.3.8",
         "dotenv": "^17.4.2",
         "esbuild": "^0.28.0",
+        "jest": "^30.3.0",
         "prettier": "^3.8.3",
+        "ts-jest": "^29.4.9",
         "ts-node": "^10.9.2",
         "typescript": "^6.0.3",
         "zod": "^4.3.6"
     },
     "devDependencies": {
+        "@types/jest": "^30.0.0",
         "@types/node": "^25.6.0"
     },
     "prettier": {
@@ -36,5 +40,24 @@
             "jsx",
             "decorators-legacy"
         ]
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "transform": {
+            "^.+\\.(ts|tsx)$": "ts-jest"
+        },
+        "moduleNameMapper": {
+            "\\.(png|jpg|jpeg|gif|webp|svg|ico)$": "<rootDir>/tests/setup/__mocks__/fileMock.js",
+            "^@/(.*)$": "<rootDir>/src/$1",
+            "^~/(.*)$": "<rootDir>/$1"
+        },
+        "moduleFileExtensions": [
+            "ts",
+            "tsx",
+            "js"
+        ],
+        "testMatch": [
+            "**/?(*.)+(spec|test).[jt]s?(x)"
+        ]
     }
 }

src/CreepRunner.ts

@@ -1,5 +1,5 @@
-import { CreepRole, CreepRoles } from 'types/creeps';
+import { CreepRole, CreepRoles } from '@/types/creeps';
-import { getRoomCreeps } from 'utils/funcs/getRoomCreeps';
+import { getRoomCreeps } from '@/utils/funcs/getRoomCreeps';
 
 class CreepRunner {
     public static run(room: Room, state: GameState): GameState {

src/RequisitionsManager.ts

@@ -1,8 +1,8 @@
-import { CreepRequisition, CreepRole, CreepRoles } from 'types/creeps';
+import { CreepRequisition, CreepRole, CreepRoles } from '@/types/creeps';
-import { DEFAULT_GAME_CONFIG } from 'types/gameConfig';
+import { DEFAULT_GAME_CONFIG } from '@/types/gameConfig';
-import { get_role_cost } from 'utils/funcs/getRoleCost';
+import { get_role_cost } from '@/utils/funcs/getRoleCost';
-import { getRoomCreeps } from 'utils/funcs/getRoomCreeps';
+import { getRoomCreeps } from '@/utils/funcs/getRoomCreeps';
-import { sortCreepRolesByPriority } from 'utils/funcs/sortCreepRolesByPriority';
+import { sortCreepRolesByPriority } from '@/utils/funcs/sortCreepRolesByPriority';
 
 class RequisitionsManager {
     public static validateState(room: Room, state: GameState): GameState {

src/RoomInspector.ts

@@ -1,11 +1,11 @@
-import { checkPositionWalkable } from 'utils/funcs/checkPosition';
+import { checkPositionWalkable } from '@/utils/funcs/checkPosition';
 import {
     createSourcePositionMatrix,
     forEachMatrixSpot,
     getPositionWithDelta,
     PositionSpotStatus,
     setSpotStatus,
-} from 'utils/positions';
+} from '@/utils/positions';
 
 class RoomInspector {
     public static inspectState(room: Room, state: GameState): GameState {

src/RoomRunner.ts

@@ -1,6 +1,6 @@
-import CreepRunner from 'CreepRunner';
+import CreepRunner from '@/CreepRunner';
-import RequisitionsManager from 'RequisitionsManager';
+import RequisitionsManager from '@/RequisitionsManager';
-import RoomInspector from 'RoomInspector';
+import RoomInspector from '@/RoomInspector';
 
 class RoomRunner {
     public static run(room: Room, state: GameState): GameState {

src/global.d.ts

@@ -0,0 +1,48 @@
+import { CreepDestination } from '@/types/creeps';
+import { PositionMatrix } from '@/utils/positions';
+
+declare global {
+    /*
+    Example types, expand on these or remove them and add your own.
+    Note: Values, properties defined here do no fully *exist* by this type definiton alone.
+          You must also give them an implemention if you would like to use them. (ex. actually setting a `role` property in a Creeps memory)
+
+    Types added in this `global` block are in an ambient, global context. This is needed because `main.ts` is a module file (uses import or export).
+    Interfaces matching on name from @types/screeps will be merged. This is how you can extend the 'built-in' interfaces from @types/screeps.
+  */
+    interface SourceState {
+        id: string;
+        spots: PositionMatrix;
+        pos: RoomPosition;
+    }
+
+    interface GameState {
+        sourcesStates: { [sourceId: string]: SourceState };
+        maxHarvesters: number; // Maximum number of harvesters allowed in the game
+    }
+
+    // Memory extension samples
+    interface Memory {
+        uuid: number;
+        log: any;
+        roomStateRegistry: { [name: string]: GameState };
+    }
+
+    interface CreepMemory {
+        role: string;
+        room: string;
+        spawnId: string;
+        working: boolean;
+        destination?: CreepDestination;
+        previousDestination?: CreepDestination;
+    }
+
+    // Syntax for adding proprties to `global` (ex "global.log")
+    namespace NodeJS {
+        interface Global {
+            log: any;
+        }
+    }
+}
+
+export {};

src/main.ts

@@ -1,50 +1,4 @@
-import RoomRunner from 'RoomRunner';
+import RoomRunner from '@/RoomRunner';
-import { CreepDestination } from 'types/creeps';
-import { PositionMatrix } from 'utils/positions';
-
-declare global {
-    /*
-    Example types, expand on these or remove them and add your own.
-    Note: Values, properties defined here do no fully *exist* by this type definiton alone.
-          You must also give them an implemention if you would like to use them. (ex. actually setting a `role` property in a Creeps memory)
-
-    Types added in this `global` block are in an ambient, global context. This is needed because `main.ts` is a module file (uses import or export).
-    Interfaces matching on name from @types/screeps will be merged. This is how you can extend the 'built-in' interfaces from @types/screeps.
-  */
-    interface SourceState {
-        id: string;
-        spots: PositionMatrix;
-        pos: RoomPosition;
-    }
-
-    interface GameState {
-        sourcesStates: { [sourceId: string]: SourceState };
-        maxHarvesters: number; // Maximum number of harvesters allowed in the game
-    }
-
-    // Memory extension samples
-    interface Memory {
-        uuid: number;
-        log: any;
-        roomStateRegistry: { [name: string]: GameState };
-    }
-
-    interface CreepMemory {
-        role: string;
-        room: string;
-        spawnId: string;
-        working: boolean;
-        destination?: CreepDestination;
-        previousDestination?: CreepDestination;
-    }
-
-    // Syntax for adding proprties to `global` (ex "global.log")
-    namespace NodeJS {
-        interface Global {
-            log: any;
-        }
-    }
-}
 
 export const loop = () => {
     Memory.roomStateRegistry = Memory.roomStateRegistry || {};

src/roleHandlers/harvester.handler.ts

@@ -1,12 +1,12 @@
 import { RoleHandler } from './BaseHandler.interface';
-import { SourceDestination } from 'types/creeps';
+import { SourceDestination } from '@/types/creeps';
-import { getSourceById, getSpawnById } from 'utils/funcs/getById';
+import { getSourceById, getSpawnById } from '@/utils/funcs/getById';
 import {
     getNextEmptySpot,
     getPositionWithDelta,
     PositionSpotStatus,
     setSpotStatus,
-} from 'utils/positions';
+} from '@/utils/positions';
 
 class HarvesterHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {

src/roleHandlers/upgrader.handler.ts

@@ -1,12 +1,12 @@
 import { RoleHandler } from './BaseHandler.interface';
-import { SourceDestination } from 'types/creeps';
+import { SourceDestination } from '@/types/creeps';
-import { getControllerById, getSourceById } from 'utils/funcs/getById';
+import { getControllerById, getSourceById } from '@/utils/funcs/getById';
 import {
     getNextEmptySpot,
+    getPositionWithDelta,
     PositionSpotStatus,
     setSpotStatus,
-    getPositionWithDelta,
+} from '@/utils/positions';
-} from 'utils/positions';
 
 class UpgraderHandler extends RoleHandler {
     public static destroy(creepMemory: CreepMemory, state: GameState): void {

src/types/creeps.ts

@@ -1,5 +1,5 @@
-import { HarvesterHandler, RoleHandler, UpgraderHandler } from 'roleHandlers';
+import { HarvesterHandler, RoleHandler, UpgraderHandler } from '@/roleHandlers';
-import { PositionDelta } from 'utils/positions';
+import { PositionDelta } from '@/utils/positions';
 
 export type RoleDefinition = {
     name: string;

src/utils/funcs/getRoleCost.ts

@@ -1,4 +1,4 @@
-import { RoleDefinition } from 'types/creeps';
+import { RoleDefinition } from '@/types/creeps';
 
 export const get_role_cost = (role: RoleDefinition) => {
     return role.body.reduce((cost, part) => {

src/utils/funcs/sortCreepRolesByPriority.ts

@@ -3,7 +3,7 @@ import {
     CreepRole,
     CreepRoles,
     RoleDefinition,
-} from 'types/creeps';
+} from '@/types/creeps';
 
 export const sortCreepRolesByPriority = (
     requisition: CreepRequisition

tests/__mocks__/screeps.ts

@@ -0,0 +1,35 @@
+/**
+ * Minimal Screeps global mocks used across tests.
+ */
+
+// Constants
+(global as any).RESOURCE_ENERGY = 'energy';
+(global as any).ERR_NOT_IN_RANGE = -9;
+(global as any).OK = 0;
+(global as any).WORK = 'work';
+(global as any).CARRY = 'carry';
+(global as any).MOVE = 'move';
+
+// RoomPosition constructor mock
+(global as any).RoomPosition = class RoomPosition {
+    x: number;
+    y: number;
+    roomName: string;
+
+    constructor(x: number, y: number, roomName: string) {
+        this.x = x;
+        this.y = y;
+        this.roomName = roomName;
+    }
+
+    getRangeTo(_target: any): number {
+        return 0;
+    }
+};
+
+// Game mock
+(global as any).Game = {
+    getObjectById: jest.fn(),
+};
+
+export {};

tests/roleHandlers/harvester.handler.test.ts

@@ -0,0 +1,371 @@
+import HarvesterHandler from '@/roleHandlers/harvester.handler';
+import * as getById from '@/utils/funcs/getById';
+import {
+    PositionSpotStatus,
+    createSourcePositionMatrix,
+} from '@/utils/positions';
+import '~/tests/__mocks__/screeps';
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeMatrix(fill: string = PositionSpotStatus.EMPTY) {
+    const m = createSourcePositionMatrix(fill as any);
+    return m;
+}
+
+function makeState(overrides: Partial<GameState> = {}): GameState {
+    const spots = makeMatrix();
+    return {
+        sourcesStates: {
+            src1: { spots },
+        },
+        ...overrides,
+    } as unknown as GameState;
+}
+
+function makeCreepMemory(overrides: Partial<CreepMemory> = {}): CreepMemory {
+    return {
+        role: 'harvester',
+        spawnId: 'spawn1',
+        ...overrides,
+    } as CreepMemory;
+}
+
+function makeStore(used: number, capacity: number) {
+    return {
+        getFreeCapacity: (_res: string) => capacity - used,
+        getUsedCapacity: (_res: string) => used,
+    };
+}
+
+function makePos(x = 0, y = 0, roomName = 'W1N1') {
+    return new (global as any).RoomPosition(x, y, roomName);
+}
+
+function makeSource(id = 'src1', x = 5, y = 5, roomName = 'W1N1') {
+    return {
+        id,
+        pos: makePos(x, y, roomName),
+    } as unknown as Source;
+}
+
+function makeSpawn(id = 'spawn1') {
+    return { id } as unknown as StructureSpawn;
+}
+
+function makeCreep(
+    memoryOverrides: Partial<CreepMemory> = {},
+    storeUsed = 0,
+    storeCapacity = 50
+): Creep {
+    const memory = makeCreepMemory(memoryOverrides);
+    return {
+        name: 'Creep1',
+        memory,
+        store: makeStore(storeUsed, storeCapacity),
+        pos: makePos(),
+        room: {},
+        harvest: jest.fn().mockReturnValue((global as any).OK),
+        moveTo: jest.fn().mockReturnValue((global as any).OK),
+        transfer: jest.fn().mockReturnValue((global as any).OK),
+    } as unknown as Creep;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('HarvesterHandler', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    // ── destroy ──────────────────────────────────────────────────────────────
+
+    describe('destroy', () => {
+        it('releases the source spot from destination and clears it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[0] = PositionSpotStatus.OCCUPIED;
+
+            const memory = makeCreepMemory({
+                destination: { type: 'source', id: 'src1', sourceSpot: 0 },
+            });
+
+            HarvesterHandler.destroy(memory, state);
+
+            expect(state.sourcesStates['src1'].spots[0]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(memory.destination).toBeUndefined();
+        });
+
+        it('releases the source spot from previousDestination and clears it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[2] = PositionSpotStatus.OCCUPIED;
+
+            const memory = makeCreepMemory({
+                previousDestination: {
+                    type: 'source',
+                    id: 'src1',
+                    sourceSpot: 2,
+                },
+            });
+
+            HarvesterHandler.destroy(memory, state);
+
+            expect(state.sourcesStates['src1'].spots[2]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(memory.previousDestination).toBeUndefined();
+        });
+
+        it('does nothing when destination is not a source', () => {
+            const state = makeState();
+            const memory = makeCreepMemory({
+                destination: { type: 'spawn', id: 'spawn1' },
+            });
+
+            HarvesterHandler.destroy(memory, state);
+
+            // None of the source spots should have changed
+            expect(
+                state.sourcesStates['src1'].spots.every(
+                    (s: PositionSpotStatus) =>
+                        s === PositionSpotStatus.EMPTY ||
+                        s === PositionSpotStatus.CENTER
+                )
+            ).toBe(true);
+        });
+
+        it('does nothing when memory has no destination', () => {
+            const state = makeState();
+            const memory = makeCreepMemory();
+
+            expect(() => HarvesterHandler.destroy(memory, state)).not.toThrow();
+        });
+    });
+
+    // ── validateCreepMemory (via run) ────────────────────────────────────────
+
+    describe('validateCreepMemory (via run)', () => {
+        it('releases previousDestination source spot and deletes it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[1] = PositionSpotStatus.OCCUPIED;
+
+            const creep = makeCreep({
+                previousDestination: {
+                    type: 'source',
+                    id: 'src1',
+                    sourceSpot: 1,
+                },
+            });
+
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
+
+            HarvesterHandler.run(creep, state);
+
+            expect(state.sourcesStates['src1'].spots[1]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(creep.memory.previousDestination).toBeUndefined();
+        });
+
+        it('transitions from source to spawn destination when energy is full', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+            jest.spyOn(getById, 'getSpawnById').mockReturnValue(makeSpawn());
+
+            const creep = makeCreep(
+                {
+                    destination: { type: 'source', id: 'src1', sourceSpot: 0 },
+                    spawnId: 'spawn1',
+                },
+                50, // used = full
+                50
+            );
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.memory.destination?.type).toBe('spawn');
+            expect(creep.memory.previousDestination?.type).toBe('source');
+        });
+
+        it('clears spawn destination when energy is empty', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSpawnById').mockReturnValue(makeSpawn());
+
+            const creep = makeCreep(
+                {
+                    destination: { type: 'spawn', id: 'spawn1' },
+                },
+                0, // used = 0
+                50
+            );
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.memory.destination).toBeUndefined();
+        });
+    });
+
+    // ── onFindNewSource ───────────────────────────────────────────────────────
+
+    describe('onFindNewSource', () => {
+        it('assigns the first available source spot to the creep', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
+
+            const creep = makeCreep(); // no destination, empty store
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.memory.destination?.type).toBe('source');
+            expect((creep.memory.destination as any).id).toBe('src1');
+        });
+
+        it('does not assign a source when all spots are occupied', () => {
+            const state = makeState();
+            // Fill all non-center spots with OCCUPIED
+            state.sourcesStates['src1'].spots = state.sourcesStates[
+                'src1'
+            ].spots.map((s: PositionSpotStatus) =>
+                s === PositionSpotStatus.CENTER
+                    ? s
+                    : PositionSpotStatus.OCCUPIED
+            ) as any;
+
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
+            const creep = makeCreep();
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.memory.destination).toBeUndefined();
+        });
+    });
+
+    // ── onSourceDestination ───────────────────────────────────────────────────
+
+    describe('onSourceDestination', () => {
+        it('harvests when in range', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+
+            const creep = makeCreep(
+                { destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
+                0,
+                50
+            );
+            (creep.harvest as jest.Mock).mockReturnValue((global as any).OK);
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.harvest).toHaveBeenCalledWith(source);
+            expect(creep.moveTo).not.toHaveBeenCalled();
+        });
+
+        it('moves to source when not in range', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+
+            const creep = makeCreep(
+                { destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
+                0,
+                50
+            );
+            (creep.harvest as jest.Mock).mockReturnValue(
+                (global as any).ERR_NOT_IN_RANGE
+            );
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.moveTo).toHaveBeenCalled();
+        });
+
+        it('logs and returns when source is not found', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
+
+            const creep = makeCreep(
+                {
+                    destination: {
+                        type: 'source',
+                        id: 'unknown',
+                        sourceSpot: 0,
+                    },
+                },
+                0,
+                50
+            );
+
+            expect(() => HarvesterHandler.run(creep, state)).not.toThrow();
+            expect(creep.harvest).not.toHaveBeenCalled();
+        });
+    });
+
+    // ── onSpawnDestination ────────────────────────────────────────────────────
+
+    describe('onSpawnDestination', () => {
+        it('transfers energy when in range', () => {
+            const state = makeState();
+            const spawn = makeSpawn();
+            jest.spyOn(getById, 'getSpawnById').mockReturnValue(spawn);
+
+            const creep = makeCreep(
+                { destination: { type: 'spawn', id: 'spawn1' } },
+                50,
+                50
+            );
+            (creep.transfer as jest.Mock).mockReturnValue((global as any).OK);
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.transfer).toHaveBeenCalledWith(
+                spawn,
+                (global as any).RESOURCE_ENERGY
+            );
+            expect(creep.moveTo).not.toHaveBeenCalled();
+        });
+
+        it('moves to spawn when not in range', () => {
+            const state = makeState();
+            const spawn = makeSpawn();
+            jest.spyOn(getById, 'getSpawnById').mockReturnValue(spawn);
+
+            const creep = makeCreep(
+                { destination: { type: 'spawn', id: 'spawn1' } },
+                50,
+                50
+            );
+            (creep.transfer as jest.Mock).mockReturnValue(
+                (global as any).ERR_NOT_IN_RANGE
+            );
+
+            HarvesterHandler.run(creep, state);
+
+            expect(creep.moveTo).toHaveBeenCalledWith(
+                spawn,
+                expect.any(Object)
+            );
+        });
+
+        it('logs and returns when spawn is not found', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSpawnById').mockReturnValue(null);
+
+            const creep = makeCreep(
+                { destination: { type: 'spawn', id: 'spawn1' } },
+                50,
+                50
+            );
+
+            expect(() => HarvesterHandler.run(creep, state)).not.toThrow();
+            expect(creep.transfer).not.toHaveBeenCalled();
+        });
+    });
+});

tests/roleHandlers/upgrader.handler.test.ts

@@ -0,0 +1,404 @@
+import UpgraderHandler from '@/roleHandlers/upgrader.handler';
+import * as getById from '@/utils/funcs/getById';
+import {
+    PositionSpotStatus,
+    createSourcePositionMatrix,
+} from '@/utils/positions';
+import '~/tests/__mocks__/screeps';
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeState(overrides: Partial<GameState> = {}): GameState {
+    const spots = createSourcePositionMatrix(PositionSpotStatus.EMPTY);
+    return {
+        sourcesStates: {
+            src1: { spots },
+        },
+        ...overrides,
+    } as unknown as GameState;
+}
+
+function makeCreepMemory(overrides: Partial<CreepMemory> = {}): CreepMemory {
+    return {
+        role: 'upgrader',
+        spawnId: 'spawn1',
+        ...overrides,
+    } as CreepMemory;
+}
+
+function makeStore(used: number, capacity: number) {
+    return {
+        getFreeCapacity: (_res: string) => capacity - used,
+        getUsedCapacity: (_res: string) => used,
+    };
+}
+
+function makePos(x = 0, y = 0, roomName = 'W1N1') {
+    return new (global as any).RoomPosition(x, y, roomName);
+}
+
+function makeSource(id = 'src1', x = 5, y = 5, roomName = 'W1N1') {
+    return {
+        id,
+        pos: makePos(x, y, roomName),
+    } as unknown as Source;
+}
+
+function makeController(id = 'ctrl1') {
+    return { id } as unknown as StructureController;
+}
+
+function makeCreep(
+    memoryOverrides: Partial<CreepMemory> = {},
+    storeUsed = 0,
+    storeCapacity = 50,
+    controller: StructureController | null = null
+): Creep {
+    const memory = makeCreepMemory(memoryOverrides);
+    return {
+        name: 'Creep1',
+        memory,
+        store: makeStore(storeUsed, storeCapacity),
+        pos: makePos(),
+        room: {
+            controller:
+                controller !== null ? (controller ?? makeController()) : null,
+        },
+        harvest: jest.fn().mockReturnValue((global as any).OK),
+        moveTo: jest.fn().mockReturnValue((global as any).OK),
+        upgradeController: jest.fn().mockReturnValue((global as any).OK),
+    } as unknown as Creep;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('UpgraderHandler', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    // ── destroy ──────────────────────────────────────────────────────────────
+
+    describe('destroy', () => {
+        it('releases the source spot from destination and clears it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[0] = PositionSpotStatus.OCCUPIED;
+
+            const memory = makeCreepMemory({
+                destination: { type: 'source', id: 'src1', sourceSpot: 0 },
+            });
+
+            UpgraderHandler.destroy(memory, state);
+
+            expect(state.sourcesStates['src1'].spots[0]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(memory.destination).toBeUndefined();
+        });
+
+        it('releases the source spot from previousDestination and clears it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[3] = PositionSpotStatus.OCCUPIED;
+
+            const memory = makeCreepMemory({
+                previousDestination: {
+                    type: 'source',
+                    id: 'src1',
+                    sourceSpot: 3,
+                },
+            });
+
+            UpgraderHandler.destroy(memory, state);
+
+            expect(state.sourcesStates['src1'].spots[3]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(memory.previousDestination).toBeUndefined();
+        });
+
+        it('does nothing when destination is not a source', () => {
+            const state = makeState();
+            const memory = makeCreepMemory({
+                destination: { type: 'controller', id: 'ctrl1' },
+            });
+
+            UpgraderHandler.destroy(memory, state);
+
+            expect(
+                state.sourcesStates['src1'].spots.every(
+                    (s: PositionSpotStatus) =>
+                        s === PositionSpotStatus.EMPTY ||
+                        s === PositionSpotStatus.CENTER
+                )
+            ).toBe(true);
+        });
+
+        it('does nothing when memory has no destination', () => {
+            const state = makeState();
+            const memory = makeCreepMemory();
+
+            expect(() => UpgraderHandler.destroy(memory, state)).not.toThrow();
+        });
+    });
+
+    // ── validateCreepMemory (via run) ────────────────────────────────────────
+
+    describe('validateCreepMemory (via run)', () => {
+        it('releases previousDestination source spot and deletes it', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots[1] = PositionSpotStatus.OCCUPIED;
+
+            const creep = makeCreep({
+                previousDestination: {
+                    type: 'source',
+                    id: 'src1',
+                    sourceSpot: 1,
+                },
+            });
+
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
+
+            UpgraderHandler.run(creep, state);
+
+            expect(state.sourcesStates['src1'].spots[1]).toBe(
+                PositionSpotStatus.EMPTY
+            );
+            expect(creep.memory.previousDestination).toBeUndefined();
+        });
+
+        it('transitions from source to controller destination when energy is full', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+
+            const controller = makeController();
+            jest.spyOn(getById, 'getControllerById').mockReturnValue(
+                controller
+            );
+
+            const creep = makeCreep(
+                {
+                    destination: { type: 'source', id: 'src1', sourceSpot: 0 },
+                },
+                50, // full
+                50,
+                controller
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.memory.destination?.type).toBe('controller');
+            expect(creep.memory.previousDestination?.type).toBe('source');
+        });
+
+        it('clears controller destination when energy is empty', () => {
+            const state = makeState();
+            const controller = makeController();
+            jest.spyOn(getById, 'getControllerById').mockReturnValue(
+                controller
+            );
+
+            const creep = makeCreep(
+                { destination: { type: 'controller', id: 'ctrl1' } },
+                0, // empty
+                50,
+                controller
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.memory.destination).toBeUndefined();
+        });
+
+        it('clears destination and logs when room has no controller during source→controller transition', () => {
+            const state = makeState();
+            // Occupy all spots so onFindNewSource cannot reassign a source
+            state.sourcesStates['src1'].spots = state.sourcesStates[
+                'src1'
+            ].spots.map((s: PositionSpotStatus) =>
+                s === PositionSpotStatus.CENTER
+                    ? s
+                    : PositionSpotStatus.OCCUPIED
+            ) as any;
+
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
+
+            const creep = makeCreep(
+                { destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
+                50,
+                50,
+                null // no controller in room
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.memory.destination).toBeUndefined();
+        });
+    });
+
+    // ── onFindNewSource ───────────────────────────────────────────────────────
+
+    describe('onFindNewSource', () => {
+        it('assigns the first available source spot to the creep', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
+
+            const creep = makeCreep(); // no destination, empty store
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.memory.destination?.type).toBe('source');
+            expect((creep.memory.destination as any).id).toBe('src1');
+        });
+
+        it('does not assign a source when all spots are occupied', () => {
+            const state = makeState();
+            state.sourcesStates['src1'].spots = state.sourcesStates[
+                'src1'
+            ].spots.map((s: PositionSpotStatus) =>
+                s === PositionSpotStatus.CENTER
+                    ? s
+                    : PositionSpotStatus.OCCUPIED
+            ) as any;
+
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(makeSource());
+            const creep = makeCreep();
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.memory.destination).toBeUndefined();
+        });
+    });
+
+    // ── onSourceDestination ───────────────────────────────────────────────────
+
+    describe('onSourceDestination', () => {
+        it('harvests when in range', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+
+            const creep = makeCreep(
+                { destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
+                0,
+                50
+            );
+            (creep.harvest as jest.Mock).mockReturnValue((global as any).OK);
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.harvest).toHaveBeenCalledWith(source);
+            expect(creep.moveTo).not.toHaveBeenCalled();
+        });
+
+        it('moves to source when not in range', () => {
+            const state = makeState();
+            const source = makeSource();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(source);
+
+            const creep = makeCreep(
+                { destination: { type: 'source', id: 'src1', sourceSpot: 0 } },
+                0,
+                50
+            );
+            (creep.harvest as jest.Mock).mockReturnValue(
+                (global as any).ERR_NOT_IN_RANGE
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.moveTo).toHaveBeenCalled();
+        });
+
+        it('logs and returns when source is not found', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getSourceById').mockReturnValue(null);
+
+            const creep = makeCreep(
+                {
+                    destination: {
+                        type: 'source',
+                        id: 'unknown',
+                        sourceSpot: 0,
+                    },
+                },
+                0,
+                50
+            );
+
+            expect(() => UpgraderHandler.run(creep, state)).not.toThrow();
+            expect(creep.harvest).not.toHaveBeenCalled();
+        });
+    });
+
+    // ── onControllerDestination ───────────────────────────────────────────────
+
+    describe('onControllerDestination', () => {
+        it('upgrades controller when in range', () => {
+            const state = makeState();
+            const controller = makeController();
+            jest.spyOn(getById, 'getControllerById').mockReturnValue(
+                controller
+            );
+
+            const creep = makeCreep(
+                { destination: { type: 'controller', id: 'ctrl1' } },
+                50,
+                50,
+                controller
+            );
+            (creep.upgradeController as jest.Mock).mockReturnValue(
+                (global as any).OK
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.upgradeController).toHaveBeenCalledWith(controller);
+            expect(creep.moveTo).not.toHaveBeenCalled();
+        });
+
+        it('moves to controller when not in range', () => {
+            const state = makeState();
+            const controller = makeController();
+            jest.spyOn(getById, 'getControllerById').mockReturnValue(
+                controller
+            );
+
+            const creep = makeCreep(
+                { destination: { type: 'controller', id: 'ctrl1' } },
+                50,
+                50,
+                controller
+            );
+            (creep.upgradeController as jest.Mock).mockReturnValue(
+                (global as any).ERR_NOT_IN_RANGE
+            );
+
+            UpgraderHandler.run(creep, state);
+
+            expect(creep.moveTo).toHaveBeenCalledWith(
+                controller,
+                expect.any(Object)
+            );
+        });
+
+        it('logs and returns when controller is not found by ID', () => {
+            const state = makeState();
+            jest.spyOn(getById, 'getControllerById').mockReturnValue(null);
+
+            const creep = makeCreep(
+                { destination: { type: 'controller', id: 'ctrl1' } },
+                50,
+                50
+            );
+
+            expect(() => UpgraderHandler.run(creep, state)).not.toThrow();
+            expect(creep.upgradeController).not.toHaveBeenCalled();
+        });
+    });
+});

tsconfig.json

@@ -5,8 +5,7 @@
         "module": "commonjs",
         "moduleResolution": "node",
         "outDir": "dist",
-        "rootDir": "src",
+        "baseUrl": ".",
-        "baseUrl": "src",
         "strict": true,
         "noImplicitReturns": true,
         "noUnusedLocals": true,
@@ -16,8 +15,13 @@
         "sourceMap": true,
         "experimentalDecorators": true,
         "allowSyntheticDefaultImports": true,
-        "types": ["node", "screeps"]
+        "types": ["node", "screeps", "jest"],
+        "paths": {
+            "@/*": ["./src/*"],
+            "~/*": ["./*"]
+        },
+        "typeRoots": ["node_modules/@types", "src"]
     },
-    "include": ["src/*.ts", "src/**/*.ts"],
+    "include": ["src/global.d.ts", "src/*.ts", "src/**/*.ts"],
     "exclude": ["node_modules", "dist"]
 }

tsconfig.test.json

@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "module": "CommonJs"
-    }
-}