@holoscript/framework 6.0.3

package/src/ai/__tests__/GoalPlannerDepth.prod.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi } from 'vitest';
+import { GoalPlanner, type WorldState, type PlanAction, type Goal } from '../GoalPlanner';
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+
+function makeAction(
+  id: string,
+  cost: number,
+  pre: Record<string, boolean>,
+  effects: Record<string, boolean>,
+  execute = vi.fn()
+): PlanAction {
+  return {
+    id,
+    name: id,
+    cost,
+    preconditions: new Map(Object.entries(pre)),
+    effects: new Map(Object.entries(effects)),
+    execute,
+  };
+}
+
+function makeGoal(id: string, priority: number, conditions: Record<string, boolean>): Goal {
+  return { id, name: id, priority, conditions: new Map(Object.entries(conditions)) };
+}
+
+function makeState(entries: Record<string, boolean>): WorldState {
+  return new Map(Object.entries(entries));
+}
+
+// ─── tests ───────────────────────────────────────────────────────────────────
+
+describe('GoalPlanner — registration', () => {
+  it('getActionCount starts at 0', () => expect(new GoalPlanner().getActionCount()).toBe(0));
+  it('getGoalCount starts at 0', () => expect(new GoalPlanner().getGoalCount()).toBe(0));
+  it('addAction increments count', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('a', 1, {}, {}));
+    expect(gp.getActionCount()).toBe(1);
+  });
+  it('addGoal increments count', () => {
+    const gp = new GoalPlanner();
+    gp.addGoal(makeGoal('g', 1, {}));
+    expect(gp.getGoalCount()).toBe(1);
+  });
+  it('removeAction decrements count', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('act1', 1, {}, {}));
+    gp.removeAction('act1');
+    expect(gp.getActionCount()).toBe(0);
+  });
+  it('removeGoal decrements count', () => {
+    const gp = new GoalPlanner();
+    gp.addGoal(makeGoal('g1', 1, {}));
+    gp.removeGoal('g1');
+    expect(gp.getGoalCount()).toBe(0);
+  });
+  it('addAction multiple keeps all', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('a', 1, {}, {}));
+    gp.addAction(makeAction('b', 1, {}, {}));
+    expect(gp.getActionCount()).toBe(2);
+  });
+});
+
+describe('GoalPlanner — plan() no goals/actions', () => {
+  it('returns null when no goals', () => {
+    const gp = new GoalPlanner();
+    expect(gp.plan(makeState({}))).toBeNull();
+  });
+  it('returns null when goal already satisfied', () => {
+    const gp = new GoalPlanner();
+    gp.addGoal(makeGoal('g', 10, { done: true }));
+    // Already satisfied — returns a plan with 0 actions
+    const plan = gp.plan(makeState({ done: true }));
+    // Implementation may return a plan (empty) or null — either is valid
+    if (plan !== null) {
+      expect(plan.actions).toHaveLength(0);
+    }
+  });
+  it('returns null when no path to goal', () => {
+    const gp = new GoalPlanner();
+    gp.addGoal(makeGoal('g', 10, { impossible: true }));
+    // No actions available to achieve it
+    expect(gp.plan(makeState({}))).toBeNull();
+  });
+});
+
+describe('GoalPlanner — single-action plan', () => {
+  it('finds plan for single-step goal', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('unlock', 1, { hasKey: true }, { doorOpen: true }));
+    gp.addGoal(makeGoal('openDoor', 10, { doorOpen: true }));
+    const plan = gp.plan(makeState({ hasKey: true, doorOpen: false }));
+    expect(plan).not.toBeNull();
+    expect(plan!.actions).toHaveLength(1);
+    expect(plan!.actions[0].id).toBe('unlock');
+  });
+  it('plan carries correct goalId', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('act', 1, {}, { x: true }));
+    gp.addGoal(makeGoal('myGoal', 5, { x: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.goalId).toBe('myGoal');
+  });
+  it('plan carries correct totalCost', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('act', 7, {}, { x: true }));
+    gp.addGoal(makeGoal('g', 5, { x: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.totalCost).toBe(7);
+  });
+});
+
+describe('GoalPlanner — multi-action plan', () => {
+  it('chains two actions', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('pickupKey', 1, { near_key: true }, { hasKey: true }));
+    gp.addAction(makeAction('openDoor', 1, { hasKey: true }, { doorOpen: true }));
+    gp.addGoal(makeGoal('escape', 10, { doorOpen: true }));
+    const plan = gp.plan(makeState({ near_key: true }));
+    expect(plan).not.toBeNull();
+    expect(plan!.actions).toHaveLength(2);
+    expect(plan!.actions[0].id).toBe('pickupKey');
+    expect(plan!.actions[1].id).toBe('openDoor');
+  });
+  it('total cost is sum of action costs', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('a1', 3, {}, { mid: true }));
+    gp.addAction(makeAction('a2', 5, { mid: true }, { goal: true }));
+    gp.addGoal(makeGoal('g', 10, { goal: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.totalCost).toBe(8);
+  });
+});
+
+describe('GoalPlanner — cost optimization (A*)', () => {
+  it('picks cheaper path when two routes exist', () => {
+    const gp = new GoalPlanner();
+    // Expensive route: single action cost=100
+    gp.addAction(makeAction('expensive', 100, {}, { done: true }));
+    // Cheap route: two actions, total cost=3
+    gp.addAction(makeAction('step1', 1, {}, { mid: true }));
+    gp.addAction(makeAction('step2', 2, { mid: true }, { done: true }));
+    gp.addGoal(makeGoal('goal', 10, { done: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.totalCost).toBe(3);
+    expect(plan!.actions.some((a) => a.id === 'expensive')).toBe(false);
+  });
+});
+
+describe('GoalPlanner — goal priority', () => {
+  it('plans highest priority goal first', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('doA', 1, {}, { goalA: true }));
+    gp.addAction(makeAction('doB', 1, {}, { goalB: true }));
+    gp.addGoal(makeGoal('lowPriority', 1, { goalA: true }));
+    gp.addGoal(makeGoal('highPriority', 100, { goalB: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.goalId).toBe('highPriority');
+  });
+  it('falls back to next goal if first is unreachable', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('doB', 1, {}, { goalB: true }));
+    gp.addGoal(makeGoal('high', 100, { impossible: true }));
+    gp.addGoal(makeGoal('low', 1, { goalB: true }));
+    const plan = gp.plan(makeState({}));
+    expect(plan!.goalId).toBe('low');
+  });
+});
+
+describe('GoalPlanner — precondition enforcement', () => {
+  it('action with unmet precondition is not used', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('guarded', 1, { hasSpecialItem: true }, { done: true }));
+    gp.addGoal(makeGoal('g', 10, { done: true }));
+    // hasSpecialItem is NOT in world state
+    const plan = gp.plan(makeState({ hasSpecialItem: false }));
+    expect(plan).toBeNull();
+  });
+  it('action used when precondition met', () => {
+    const gp = new GoalPlanner();
+    gp.addAction(makeAction('guarded', 1, { hasSpecialItem: true }, { done: true }));
+    gp.addGoal(makeGoal('g', 10, { done: true }));
+    const plan = gp.plan(makeState({ hasSpecialItem: true }));
+    expect(plan).not.toBeNull();
+  });
+});
+
+describe('GoalPlanner — executePlan', () => {
+  it('calls execute on each action in order', () => {
+    const calls: string[] = [];
+    const gp = new GoalPlanner();
+    gp.addAction(
+      makeAction(
+        'a1',
+        1,
+        {},
+        { mid: true },
+        vi.fn(() => calls.push('a1'))
+      )
+    );
+    gp.addAction(
+      makeAction(
+        'a2',
+        1,
+        { mid: true },
+        { done: true },
+        vi.fn(() => calls.push('a2'))
+      )
+    );
+    gp.addGoal(makeGoal('g', 10, { done: true }));
+    const plan = gp.plan(makeState({}));
+    gp.executePlan(plan!);
+    expect(calls).toEqual(['a1', 'a2']);
+  });
+});

package/src/ai/__tests__/HoloScriptGenerator.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { HoloScriptGenerator, validateBatch } from '../HoloScriptGenerator';
+import type { AIAdapter } from '../AIAdapter';
+
+function mockAdapter(): AIAdapter {
+  return {
+    id: 'mock-gen',
+    name: 'Mock Generator Adapter',
+    isReady: () => true,
+    generateHoloScript: vi.fn(async (prompt: string) => ({
+      holoScript: `scene { // ${prompt} }`,
+      confidence: 0.8,
+      objectCount: 1,
+    })),
+    chat: vi.fn(async () => 'response'),
+  };
+}
+
+describe('HoloScriptGenerator', () => {
+  let gen: HoloScriptGenerator;
+  beforeEach(() => {
+    gen = new HoloScriptGenerator();
+  });
+
+  // --- Session management ---
+  it('createSession returns session object', () => {
+    const adapter = mockAdapter();
+    const session = gen.createSession(adapter);
+    expect(session).toBeDefined();
+    expect(session.sessionId).toContain('session-');
+    expect(session.adapter).toBe(adapter);
+    expect(session.history).toEqual([]);
+  });
+
+  it('createSession with custom config', () => {
+    const session = gen.createSession(mockAdapter(), { maxAttempts: 5 });
+    expect(session.config.maxAttempts).toBe(5);
+  });
+
+  it('getCurrentSession returns latest', () => {
+    gen.createSession(mockAdapter());
+    expect(gen.getCurrentSession()).toBeDefined();
+  });
+
+  it('getCurrentSession undefined before createSession', () => {
+    expect(gen.getCurrentSession()).toBeUndefined();
+  });
+
+  // --- History ---
+  it('getHistory returns empty initially', () => {
+    const session = gen.createSession(mockAdapter());
+    expect(gen.getHistory(session)).toEqual([]);
+  });
+
+  it('clearHistory removes entries', async () => {
+    const adapter = mockAdapter();
+    const session = gen.createSession(adapter);
+    // Generate to add to history
+    await gen.generate('test prompt', session);
+    expect(gen.getHistory(session).length).toBeGreaterThanOrEqual(0);
+    gen.clearHistory(session);
+    expect(gen.getHistory(session)).toEqual([]);
+  });
+
+  // --- Stats ---
+  it('getStats returns stats object', () => {
+    const session = gen.createSession(mockAdapter());
+    const stats = gen.getStats(session);
+    expect(stats).toBeDefined();
+    expect(stats!.totalGenerations).toBe(0);
+  });
+
+  // --- Cache ---
+  it('getCacheStats returns stats', () => {
+    const stats = gen.getCacheStats();
+    expect(stats).toBeDefined();
+  });
+
+  // --- Analytics ---
+  it('getAnalytics returns metrics', () => {
+    const analytics = gen.getAnalytics();
+    expect(analytics).toBeDefined();
+  });
+
+  it('generateReport returns string', () => {
+    const report = gen.generateReport();
+    expect(typeof report).toBe('string');
+  });
+
+  // --- generate (async) ---
+  it('generate creates code from prompt', async () => {
+    const adapter = mockAdapter();
+    const session = gen.createSession(adapter);
+    const result = await gen.generate('create a red cube', session);
+    expect(result).toBeDefined();
+    expect(result.holoScript).toBeDefined();
+    expect(result.attempts).toBeGreaterThanOrEqual(1);
+  });
+
+  it('generate handles adapter error gracefully', async () => {
+    const adapter = mockAdapter();
+    adapter.generateHoloScript = vi.fn(async () => {
+      throw new Error('fail');
+    });
+    const session = gen.createSession(adapter);
+    try {
+      await gen.generate('test', session);
+    } catch (_e) {
+      // Expected to throw
+    }
+  });
+});
+
+describe('validateBatch', () => {
+  it('validates array of code strings', () => {
+    const results = validateBatch(['scene { box {} }', 'invalid!!!']);
+    expect(results).toHaveLength(2);
+    expect(results[0]).toHaveProperty('valid');
+    expect(results[0]).toHaveProperty('errors');
+  });
+
+  it('empty array returns empty', () => {
+    expect(validateBatch([])).toEqual([]);
+  });
+});

package/src/ai/__tests__/InfluenceMap.prod.test.ts

@@ -0,0 +1,146 @@
+/**
+ * InfluenceMap — Production Test Suite
+ *
+ * Covers: layer management, setInfluence, addInfluence, stampRadius,
+ * propagation/decay, getInfluence, getInfluenceAtWorld, getMaxCell,
+ * clear, clearAll, bounds checking.
+ */
+import { describe, it, expect } from 'vitest';
+import { InfluenceMap } from '../InfluenceMap';
+
+const DEFAULT_CONFIG = {
+  width: 10,
+  height: 10,
+  cellSize: 1,
+  decayRate: 0.1,
+  propagationRate: 0.2,
+  maxValue: 100,
+};
+
+describe('InfluenceMap — Production', () => {
+  // ─── Layer Management ─────────────────────────────────────────────
+  it('addLayer creates new layer', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    expect(map.getLayerNames()).toContain('threat');
+  });
+
+  it('removeLayer removes layer', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('temp');
+    map.removeLayer('temp');
+    expect(map.getLayerNames()).not.toContain('temp');
+  });
+
+  it('multiple layers tracked independently', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.addLayer('resource');
+    expect(map.getLayerNames().sort()).toEqual(['resource', 'threat']);
+  });
+
+  // ─── Set / Get Influence ──────────────────────────────────────────
+  it('setInfluence + getInfluence', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.setInfluence('threat', 3, 4, 50);
+    expect(map.getInfluence('threat', 3, 4)).toBe(50);
+  });
+
+  it('getInfluence returns 0 for empty cell', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    expect(map.getInfluence('threat', 0, 0)).toBe(0);
+  });
+
+  it('getInfluence returns 0 for out-of-bounds', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    expect(map.getInfluence('threat', -1, 0)).toBe(0);
+    expect(map.getInfluence('threat', 100, 0)).toBe(0);
+  });
+
+  it('setInfluence clamps to maxValue', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.setInfluence('threat', 0, 0, 999);
+    expect(map.getInfluence('threat', 0, 0)).toBe(100);
+  });
+
+  // ─── Add Influence ────────────────────────────────────────────────
+  it('addInfluence accumulates value', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.addInfluence('threat', 5, 5, 30);
+    map.addInfluence('threat', 5, 5, 20);
+    expect(map.getInfluence('threat', 5, 5)).toBe(50);
+  });
+
+  // ─── stampRadius ──────────────────────────────────────────────────
+  it('stampRadius sets influence in radius', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.stampRadius('threat', 5, 5, 2, 80);
+    expect(map.getInfluence('threat', 5, 5)).toBeGreaterThan(0);
+    expect(map.getInfluence('threat', 4, 5)).toBeGreaterThan(0);
+    expect(map.getInfluence('threat', 0, 0)).toBe(0); // outside radius
+  });
+
+  // ─── Propagation + Decay ──────────────────────────────────────────
+  it('update propagates influence to neighbors', () => {
+    const map = new InfluenceMap({ ...DEFAULT_CONFIG, decayRate: 0, propagationRate: 0.5 });
+    map.addLayer('threat');
+    map.setInfluence('threat', 5, 5, 100);
+    map.update();
+    expect(map.getInfluence('threat', 4, 5)).toBeGreaterThan(0);
+    expect(map.getInfluence('threat', 6, 5)).toBeGreaterThan(0);
+  });
+
+  it('update decays influence', () => {
+    const map = new InfluenceMap({ ...DEFAULT_CONFIG, decayRate: 0.5, propagationRate: 0 });
+    map.addLayer('threat');
+    map.setInfluence('threat', 5, 5, 100);
+    map.update();
+    expect(map.getInfluence('threat', 5, 5)).toBeLessThan(100);
+  });
+
+  // ─── World Coordinates ────────────────────────────────────────────
+  it('getInfluenceAtWorld converts world to grid', () => {
+    const map = new InfluenceMap({ ...DEFAULT_CONFIG, cellSize: 2 });
+    map.addLayer('threat');
+    map.setInfluence('threat', 2, 3, 75);
+    expect(map.getInfluenceAtWorld('threat', 4, 6)).toBe(75); // wx/cellSize = 2, wy/cellSize = 3
+  });
+
+  // ─── getMaxCell ───────────────────────────────────────────────────
+  it('getMaxCell finds highest influence', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.setInfluence('threat', 3, 7, 90);
+    map.setInfluence('threat', 1, 1, 10);
+    const max = map.getMaxCell('threat');
+    expect(max.x).toBe(3);
+    expect(max.y).toBe(7);
+    expect(max.value).toBe(90);
+  });
+
+  // ─── Clear ────────────────────────────────────────────────────────
+  it('clear resets single layer', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('threat');
+    map.setInfluence('threat', 5, 5, 50);
+    map.clear('threat');
+    expect(map.getInfluence('threat', 5, 5)).toBe(0);
+  });
+
+  it('clearAll resets all layers', () => {
+    const map = new InfluenceMap(DEFAULT_CONFIG);
+    map.addLayer('a');
+    map.addLayer('b');
+    map.setInfluence('a', 0, 0, 50);
+    map.setInfluence('b', 0, 0, 60);
+    map.clearAll();
+    expect(map.getInfluence('a', 0, 0)).toBe(0);
+    expect(map.getInfluence('b', 0, 0)).toBe(0);
+  });
+});

package/src/ai/__tests__/InfluenceMap.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { InfluenceMap } from '../InfluenceMap';
+
+describe('InfluenceMap', () => {
+  let map: InfluenceMap;
+
+  beforeEach(() => {
+    map = new InfluenceMap({
+      width: 10,
+      height: 10,
+      cellSize: 1,
+      decayRate: 0.1,
+      propagationRate: 0.2,
+      maxValue: 100,
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Layer Management
+  // ---------------------------------------------------------------------------
+
+  it('addLayer creates a named layer', () => {
+    map.addLayer('threat');
+    expect(map.getLayerNames()).toContain('threat');
+  });
+
+  it('removeLayer deletes a layer', () => {
+    map.addLayer('temp');
+    map.removeLayer('temp');
+    expect(map.getLayerNames()).not.toContain('temp');
+  });
+
+  it('getLayerNames returns all layers', () => {
+    map.addLayer('a');
+    map.addLayer('b');
+    expect(map.getLayerNames()).toEqual(expect.arrayContaining(['a', 'b']));
+  });
+
+  // ---------------------------------------------------------------------------
+  // Influence Modification
+  // ---------------------------------------------------------------------------
+
+  it('setInfluence stores and getInfluence retrieves', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 3, 4, 50);
+    expect(map.getInfluence('test', 3, 4)).toBe(50);
+  });
+
+  it('addInfluence accumulates values', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 0, 0, 30);
+    map.addInfluence('test', 0, 0, 20);
+    expect(map.getInfluence('test', 0, 0)).toBe(50);
+  });
+
+  it('setInfluence clamps to maxValue', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 0, 0, 200); // maxValue = 100
+    expect(map.getInfluence('test', 0, 0)).toBe(100);
+  });
+
+  it('out-of-bounds reads return 0', () => {
+    map.addLayer('test');
+    expect(map.getInfluence('test', -1, 0)).toBe(0);
+    expect(map.getInfluence('test', 100, 0)).toBe(0);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Stamp Radius
+  // ---------------------------------------------------------------------------
+
+  it('stampRadius affects cells within radius', () => {
+    map.addLayer('test');
+    map.stampRadius('test', 5, 5, 2, 60);
+    expect(map.getInfluence('test', 5, 5)).toBeGreaterThan(0);
+    expect(map.getInfluence('test', 5, 4)).toBeGreaterThan(0);
+  });
+
+  it('stampRadius does not affect cells outside radius', () => {
+    map.addLayer('test');
+    map.stampRadius('test', 5, 5, 1, 60);
+    expect(map.getInfluence('test', 0, 0)).toBe(0);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Update (Decay + Propagation)
+  // ---------------------------------------------------------------------------
+
+  it('update decays values', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 5, 5, 80);
+    map.update();
+    expect(map.getInfluence('test', 5, 5)).toBeLessThan(80);
+  });
+
+  it('update propagates to neighbors', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 5, 5, 80);
+    map.update();
+    // Neighbors should have picked up some influence
+    expect(map.getInfluence('test', 5, 4)).toBeGreaterThan(0);
+  });
+
+  // ---------------------------------------------------------------------------
+  // World Coordinates
+  // ---------------------------------------------------------------------------
+
+  it('getInfluenceAtWorld converts world to grid', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 3, 4, 42);
+    // cellSize = 1, so world (3, 4) → grid (3, 4)
+    expect(map.getInfluenceAtWorld('test', 3, 4)).toBe(42);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+
+  it('getMaxCell returns position and value of highest cell', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 2, 3, 10);
+    map.setInfluence('test', 7, 8, 90);
+    const max = map.getMaxCell('test');
+    expect(max.x).toBe(7);
+    expect(max.y).toBe(8);
+    expect(max.value).toBe(90);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Clear
+  // ---------------------------------------------------------------------------
+
+  it('clear resets a single layer', () => {
+    map.addLayer('test');
+    map.setInfluence('test', 0, 0, 50);
+    map.clear('test');
+    expect(map.getInfluence('test', 0, 0)).toBe(0);
+  });
+
+  it('clearAll resets all layers', () => {
+    map.addLayer('a');
+    map.addLayer('b');
+    map.setInfluence('a', 0, 0, 50);
+    map.setInfluence('b', 0, 0, 50);
+    map.clearAll();
+    expect(map.getInfluence('a', 0, 0)).toBe(0);
+    expect(map.getInfluence('b', 0, 0)).toBe(0);
+  });
+});