gridstamp 1.0.0

package/tests/stress/simulation.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Integration Simulation — Full robot lifecycle from registration to elite status
+ *
+ * Simulates a realistic fleet scenario:
+ * - Fleet of 20 delivery robots
+ * - 90-day operation period
+ * - Varying success rates, zone visits, incidents
+ * - One attacker bot attempting spoofing
+ * - Tracks all metrics for competitive analysis output
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  TrustTierSystem,
+  TrustTier,
+  BadgeSystem,
+  StreakSystem,
+  ZoneMasterySystem,
+  FleetLeaderboard,
+  LeaderboardMetric,
+  type RobotMetrics,
+} from '../../src/gamification/index.js';
+import {
+  generateSpatialProof,
+  verifySpatialProofIntegrity,
+  createSettlement,
+} from '../../src/verification/spatial-proof.js';
+import { signFrame, generateNonce } from '../../src/utils/crypto.js';
+import { PlaceCellPopulation, GridCellSystem, computeSpatialCode } from '../../src/memory/place-cells.js';
+import type { CameraFrame, Pose, RenderedView } from '../../src/types/index.js';
+
+const SECRET = 'z'.repeat(32);
+const FLEET_ID = 'dallas-delivery-fleet';
+const NUM_ROBOTS = 20;
+const SIMULATION_DAYS = 90;
+const OPS_PER_DAY = 8; // 8 deliveries per robot per day
+
+function makePose(x: number, y: number): Pose {
+  return { position: { x, y, z: 0 }, orientation: { w: 1, x: 0, y: 0, z: 0 }, timestamp: Date.now() };
+}
+
+function makeFrame(seed: number, seq: number): CameraFrame {
+  const rgb = new Uint8Array(32 * 32 * 3);
+  for (let i = 0; i < rgb.length; i++) rgb[i] = (i * 17 + seed * 31) % 256;
+  const ts = Date.now();
+  return {
+    id: generateNonce(8), timestamp: ts, rgb, width: 32, height: 32,
+    depth: new Float32Array(32 * 32).fill(2.5),
+    pose: makePose(seed, seed),
+    hmac: signFrame(rgb, ts, seq, SECRET),
+    sequenceNumber: seq,
+  };
+}
+
+describe('Fleet Simulation: 20 robots × 90 days', () => {
+  // Shared state across the simulation
+  const trustSystem = new TrustTierSystem(SECRET);
+  const badgeSystem = new BadgeSystem(SECRET);
+  const streakSystem = new StreakSystem(SECRET);
+  const zoneMastery = new ZoneMasterySystem(SECRET, 5.0);
+  const leaderboard = new FleetLeaderboard(SECRET);
+
+  // Define realistic delivery zones
+  const zones = [
+    { name: 'Downtown Dallas', min: { x: 0, y: 0, z: 0 }, max: { x: 50, y: 50, z: 3 } },
+    { name: 'Deep Ellum', min: { x: 50, y: 0, z: 0 }, max: { x: 100, y: 30, z: 3 } },
+    { name: 'Uptown', min: { x: 0, y: 50, z: 0 }, max: { x: 40, y: 100, z: 3 } },
+    { name: 'Bishop Arts', min: { x: -30, y: -30, z: 0 }, max: { x: 0, y: 0, z: 3 } },
+    { name: 'Oak Lawn', min: { x: -30, y: 50, z: 0 }, max: { x: 0, y: 100, z: 3 } },
+    { name: 'Fair Park', min: { x: 60, y: 30, z: 0 }, max: { x: 100, y: 60, z: 3 } },
+    { name: 'Greenville Ave', min: { x: 30, y: 70, z: 0 }, max: { x: 60, y: 100, z: 3 } },
+    { name: 'Design District', min: { x: -50, y: 20, z: 0 }, max: { x: -20, y: 50, z: 3 } },
+  ];
+
+  // Robot personality profiles (different success rates simulate real fleet variance)
+  const robotProfiles = Array.from({ length: NUM_ROBOTS }, (_, i) => ({
+    id: `DLV-${String(i + 1).padStart(3, '0')}`,
+    successRate: i === 19 ? 0.3 : 0.85 + Math.random() * 0.14, // Robot 20 is an attacker (30%)
+    isAttacker: i === 19,
+    preferredZones: [i % zones.length, (i + 3) % zones.length, (i + 5) % zones.length],
+    nightOperations: Math.floor(Math.random() * 40),
+    fastOps: Math.floor(Math.random() * 15),
+  }));
+
+  it('Phase 1: Registration', () => {
+    for (const robot of robotProfiles) {
+      trustSystem.register(robot.id);
+      streakSystem.register(robot.id);
+    }
+    for (const zone of zones) {
+      zoneMastery.defineZone(zone.name, { min: zone.min, max: zone.max });
+    }
+    expect(trustSystem.robotCount).toBe(NUM_ROBOTS);
+    expect(streakSystem.robotCount).toBe(NUM_ROBOTS);
+    expect(zoneMastery.totalZones).toBe(8);
+  });
+
+  it('Phase 2: 90-day operation simulation', () => {
+    const baseDate = new Date('2025-06-01T08:00:00Z').getTime();
+    const simStats: Record<string, {
+      totalOps: number;
+      successes: number;
+      failures: number;
+      spoofAttempts: number;
+      pointsEarned: number;
+    }> = {};
+
+    for (const robot of robotProfiles) {
+      simStats[robot.id] = { totalOps: 0, successes: 0, failures: 0, spoofAttempts: 0, pointsEarned: 0 };
+    }
+
+    for (let day = 0; day < SIMULATION_DAYS; day++) {
+      const dayTimestamp = baseDate + day * 86400000;
+
+      for (const robot of robotProfiles) {
+        const stats = simStats[robot.id]!;
+        let daySuccess = true;
+
+        for (let op = 0; op < OPS_PER_DAY; op++) {
+          stats.totalOps++;
+          const isSuccess = Math.random() < robot.successRate;
+          const isSpoofAttempt = robot.isAttacker && Math.random() < 0.2;
+
+          if (isSpoofAttempt) {
+            stats.spoofAttempts++;
+            trustSystem.recordFailure(robot.id, true);
+            streakSystem.breakStreak(robot.id);
+            daySuccess = false;
+          } else if (isSuccess) {
+            stats.successes++;
+            const basePoints = 50;
+            const streakResult = streakSystem.recordActivity(robot.id, basePoints, dayTimestamp);
+            const totalEarned = streakResult.totalPoints;
+            stats.pointsEarned += totalEarned;
+            trustSystem.recordSuccess(robot.id, totalEarned);
+
+            // Visit a zone
+            const zoneIdx = robot.preferredZones[op % robot.preferredZones.length]!;
+            const zone = zones[zoneIdx]!;
+            const pos = {
+              x: zone.min.x + Math.random() * (zone.max.x - zone.min.x),
+              y: zone.min.y + Math.random() * (zone.max.y - zone.min.y),
+              z: 1,
+            };
+            zoneMastery.recordVisit(robot.id, pos, true, totalEarned);
+          } else {
+            stats.failures++;
+            trustSystem.recordFailure(robot.id, false);
+            daySuccess = false;
+          }
+        }
+      }
+    }
+
+    // Verify simulation completed
+    const totalOps = Object.values(simStats).reduce((s, v) => s + v.totalOps, 0);
+    expect(totalOps).toBe(NUM_ROBOTS * SIMULATION_DAYS * OPS_PER_DAY); // 14,400 operations
+  });
+
+  it('Phase 3: Badge evaluation', () => {
+    for (const robot of robotProfiles) {
+      const profile = trustSystem.getProfile(robot.id)!;
+      const streakRecord = streakSystem.getRecord(robot.id)!;
+      const metrics: RobotMetrics = {
+        successful_verifications: profile.successfulVerifications,
+        spoofing_incidents: profile.spoofingIncidents,
+        threats_detected: 0,
+        zones_mapped: zoneMastery.getZoneCount(robot.id),
+        max_zone_mastery: zoneMastery.getMaxMastery(robot.id),
+        unique_routes: Math.floor(profile.successfulVerifications * 0.3),
+        consecutive_days: streakRecord.longestStreak,
+        night_operations: robot.nightOperations,
+        total_verifications: profile.totalVerifications,
+        success_rate: profile.totalVerifications > 0
+          ? (profile.successfulVerifications / profile.totalVerifications) * 100
+          : 0,
+        max_ssim: 0.85 + Math.random() * 0.14,
+        max_zones_per_trip: robot.preferredZones.length,
+        fast_operations: robot.fastOps,
+      };
+      badgeSystem.evaluate(robot.id, metrics);
+    }
+
+    // Top performers should have many badges
+    const topRobot = robotProfiles[0]!;
+    const topBadges = badgeSystem.getBadgeCount(topRobot.id);
+    expect(topBadges).toBeGreaterThan(5);
+
+    // Attacker should have fewer badges
+    const attacker = robotProfiles.find(r => r.isAttacker)!;
+    const attackerBadges = badgeSystem.getBadgeCount(attacker.id);
+    expect(attackerBadges).toBeLessThan(topBadges);
+  });
+
+  it('Phase 4: Leaderboard generation', () => {
+    for (const robot of robotProfiles) {
+      const profile = trustSystem.getProfile(robot.id)!;
+      const streakRecord = streakSystem.getRecord(robot.id)!;
+      leaderboard.updateStats({
+        robotId: robot.id,
+        fleetId: FLEET_ID,
+        trustTier: profile.currentTier,
+        points: profile.points,
+        totalVerifications: profile.totalVerifications,
+        successfulVerifications: profile.successfulVerifications,
+        zonesExplored: zoneMastery.getZoneCount(robot.id),
+        badgeCount: badgeSystem.getBadgeCount(robot.id),
+        streakDays: streakRecord.currentStreak,
+        maxZoneMastery: zoneMastery.getMaxMastery(robot.id),
+        spoofingIncidents: profile.spoofingIncidents,
+      });
+    }
+
+    const board = leaderboard.getFleetLeaderboard(FLEET_ID, LeaderboardMetric.COMPOSITE);
+    expect(board).toHaveLength(NUM_ROBOTS);
+
+    // Attacker should be near bottom
+    const attacker = robotProfiles.find(r => r.isAttacker)!;
+    const attackerEntry = board.find(e => e.robotId === attacker.id)!;
+    expect(attackerEntry.rank).toBeGreaterThan(NUM_ROBOTS / 2);
+
+    // Top robot should be a high-performer
+    const topEntry = board[0]!;
+    expect(topEntry.score).toBeGreaterThan(0);
+    expect(topEntry.spoofingIncidents).toBe(0);
+  });
+
+  it('Phase 5: Trust tier distribution analysis', () => {
+    const tierCounts: Record<TrustTier, number> = {
+      [TrustTier.UNTRUSTED]: 0,
+      [TrustTier.PROBATION]: 0,
+      [TrustTier.VERIFIED]: 0,
+      [TrustTier.TRUSTED]: 0,
+      [TrustTier.ELITE]: 0,
+      [TrustTier.AUTONOMOUS]: 0,
+    };
+
+    for (const robot of robotProfiles) {
+      const profile = trustSystem.getProfile(robot.id)!;
+      tierCounts[profile.currentTier]++;
+    }
+
+    // After 90 days of mostly-successful operations:
+    // Most robots should be at Verified or above
+    const advancedCount = tierCounts[TrustTier.VERIFIED]
+      + tierCounts[TrustTier.TRUSTED]
+      + tierCounts[TrustTier.ELITE]
+      + tierCounts[TrustTier.AUTONOMOUS];
+    expect(advancedCount).toBeGreaterThan(NUM_ROBOTS / 2);
+
+    // Attacker should be at low tier
+    const attacker = robotProfiles.find(r => r.isAttacker)!;
+    const attackerProfile = trustSystem.getProfile(attacker.id)!;
+    expect(attackerProfile.currentTier).toBeLessThanOrEqual(TrustTier.PROBATION);
+  });
+
+  it('Phase 6: Fleet summary health check', () => {
+    const summary = leaderboard.getFleetSummary(FLEET_ID);
+    expect(summary.robotCount).toBe(NUM_ROBOTS);
+    expect(summary.totalDeliveries).toBeGreaterThan(0);
+    // Average success rate should reflect mostly-good fleet
+    expect(summary.averageSuccessRate).toBeGreaterThan(0.7);
+    expect(summary.topRobotId).toBeTruthy();
+    expect(summary.totalZonesExplored).toBeGreaterThan(0);
+  });
+
+  it('Phase 7: Integrity verification', () => {
+    // All tier histories should be valid
+    for (const robot of robotProfiles) {
+      const result = trustSystem.verifyHistory(robot.id);
+      expect(result.valid).toBe(true);
+    }
+
+    // All badges should be authentic
+    for (const robot of robotProfiles) {
+      const result = badgeSystem.verifyAllBadges(robot.id);
+      expect(result.valid).toBe(true);
+      expect(result.forged).toHaveLength(0);
+    }
+
+    // All streak records should verify
+    for (const robot of robotProfiles) {
+      expect(streakSystem.verifyRecord(robot.id)).toBe(true);
+    }
+
+    // Leaderboard entries should be signed
+    const board = leaderboard.getFleetLeaderboard(FLEET_ID);
+    for (const entry of board) {
+      expect(entry.signature).toHaveLength(64);
+    }
+  });
+
+  it('Phase 8: Spatial verification integration', () => {
+    // Run 10 real spatial verifications to ensure the pipeline works
+    let passed = 0;
+    let failed = 0;
+
+    for (let i = 0; i < 10; i++) {
+      const frame = makeFrame(i, i + 1);
+      const identicalRender: RenderedView = {
+        rgb: frame.rgb, depth: frame.depth!, width: 32, height: 32,
+        pose: makePose(i, i), renderTimeMs: 1,
+      };
+      const proof = generateSpatialProof(
+        'DLV-001', makePose(i, i), frame, identicalRender,
+        'merkle-root', [], SECRET,
+      );
+      const integrity = verifySpatialProofIntegrity(proof, SECRET);
+      expect(integrity.valid).toBe(true);
+
+      if (proof.passed) {
+        const settlement = createSettlement(proof, 15.00, 'USD', 'merchant-1', SECRET);
+        expect(settlement.status).toBe('verified');
+        passed++;
+      } else {
+        failed++;
+      }
+    }
+    // With identical render/frame, all should pass
+    expect(passed).toBe(10);
+  });
+
+  it('Phase 9: Performance benchmarks', () => {
+    // Benchmark: badge evaluation for 20 robots
+    const start1 = performance.now();
+    for (let round = 0; round < 100; round++) {
+      for (const robot of robotProfiles) {
+        const profile = trustSystem.getProfile(robot.id)!;
+        badgeSystem.evaluate(robot.id, {
+          successful_verifications: profile.successfulVerifications,
+          spoofing_incidents: profile.spoofingIncidents,
+          threats_detected: 0, zones_mapped: 3, max_zone_mastery: 0.5,
+          unique_routes: 10, consecutive_days: 30, night_operations: 5,
+          total_verifications: profile.totalVerifications, success_rate: 90,
+          max_ssim: 0.9, max_zones_per_trip: 2, fast_operations: 3,
+        });
+      }
+    }
+    const badgeEvalMs = performance.now() - start1;
+    expect(badgeEvalMs).toBeLessThan(3000); // 2000 evaluations under 3s
+
+    // Benchmark: leaderboard generation
+    const start2 = performance.now();
+    for (let round = 0; round < 100; round++) {
+      leaderboard.getFleetLeaderboard(FLEET_ID, LeaderboardMetric.COMPOSITE);
+    }
+    const leaderboardMs = performance.now() - start2;
+    expect(leaderboardMs).toBeLessThan(2000); // 100 leaderboard generations under 2s
+
+    // Benchmark: spatial code computation
+    const placeCells = new PlaceCellPopulation(2.0);
+    placeCells.coverRegion({ x: 0, y: 0, z: 0 }, { x: 50, y: 50, z: 0 }, 3.0);
+    const gridCells = new GridCellSystem(0.5, Math.SQRT2, 4, 16);
+    const start3 = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      computeSpatialCode({ x: Math.random() * 50, y: Math.random() * 50, z: 0 }, placeCells, gridCells);
+    }
+    const spatialCodeMs = performance.now() - start3;
+    expect(spatialCodeMs).toBeLessThan(5000); // 1000 spatial codes under 5s
+  });
+});

package/tests/utils/crypto.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import {
+  hmacSign,
+  hmacVerify,
+  signFrame,
+  verifyFrame,
+  generateNonce,
+  sha256,
+  deriveKey,
+} from '../../src/utils/crypto.js';
+
+const TEST_SECRET = 'a'.repeat(32); // minimum length secret for testing
+
+describe('Crypto Utilities', () => {
+  describe('hmacSign / hmacVerify', () => {
+    it('signs and verifies data correctly', () => {
+      const data = Buffer.from('hello world');
+      const sig = hmacSign(data, TEST_SECRET);
+      expect(sig).toHaveLength(64); // SHA-256 hex = 64 chars
+      expect(hmacVerify(data, sig, TEST_SECRET)).toBe(true);
+    });
+
+    it('rejects tampered data', () => {
+      const data = Buffer.from('hello world');
+      const sig = hmacSign(data, TEST_SECRET);
+      const tampered = Buffer.from('hello World'); // capital W
+      expect(hmacVerify(tampered, sig, TEST_SECRET)).toBe(false);
+    });
+
+    it('rejects wrong secret', () => {
+      const data = Buffer.from('hello world');
+      const sig = hmacSign(data, TEST_SECRET);
+      const wrongSecret = 'b'.repeat(32);
+      expect(hmacVerify(data, sig, wrongSecret)).toBe(false);
+    });
+
+    it('throws on short secret', () => {
+      expect(() => hmacSign(Buffer.from('test'), 'short')).toThrow('at least 32');
+    });
+
+    it('rejects empty secret', () => {
+      expect(() => hmacSign(Buffer.from('test'), '')).toThrow('at least 32');
+    });
+  });
+
+  describe('signFrame / verifyFrame', () => {
+    it('signs and verifies frame data', () => {
+      const rgb = new Uint8Array([255, 0, 0, 0, 255, 0]);
+      const timestamp = 1712600000000;
+      const seq = 42;
+      const sig = signFrame(rgb, timestamp, seq, TEST_SECRET);
+      expect(verifyFrame(rgb, timestamp, seq, sig, TEST_SECRET)).toBe(true);
+    });
+
+    it('rejects altered pixel data', () => {
+      const rgb = new Uint8Array([255, 0, 0, 0, 255, 0]);
+      const sig = signFrame(rgb, 1000, 1, TEST_SECRET);
+      const altered = new Uint8Array([255, 0, 0, 0, 255, 1]); // 1 pixel changed
+      expect(verifyFrame(altered, 1000, 1, sig, TEST_SECRET)).toBe(false);
+    });
+
+    it('rejects altered timestamp', () => {
+      const rgb = new Uint8Array([255, 0, 0]);
+      const sig = signFrame(rgb, 1000, 1, TEST_SECRET);
+      expect(verifyFrame(rgb, 1001, 1, sig, TEST_SECRET)).toBe(false);
+    });
+
+    it('rejects altered sequence number', () => {
+      const rgb = new Uint8Array([255, 0, 0]);
+      const sig = signFrame(rgb, 1000, 1, TEST_SECRET);
+      expect(verifyFrame(rgb, 1000, 2, sig, TEST_SECRET)).toBe(false);
+    });
+  });
+
+  describe('generateNonce', () => {
+    it('generates hex string of correct length', () => {
+      const nonce = generateNonce(16);
+      expect(nonce).toHaveLength(32); // 16 bytes = 32 hex chars
+    });
+
+    it('generates unique values', () => {
+      const a = generateNonce();
+      const b = generateNonce();
+      expect(a).not.toBe(b);
+    });
+  });
+
+  describe('sha256', () => {
+    it('hashes strings correctly', () => {
+      const hash = sha256('hello');
+      expect(hash).toHaveLength(64);
+      expect(hash).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+    });
+
+    it('hashes buffers correctly', () => {
+      const hash = sha256(Buffer.from('hello'));
+      expect(hash).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+    });
+  });
+
+  describe('deriveKey', () => {
+    it('derives different keys for different contexts', () => {
+      const key1 = deriveKey(TEST_SECRET, 'frame-signing');
+      const key2 = deriveKey(TEST_SECRET, 'memory-signing');
+      expect(key1).not.toBe(key2);
+      expect(key1).toHaveLength(64);
+    });
+
+    it('derives same key for same inputs', () => {
+      const key1 = deriveKey(TEST_SECRET, 'test');
+      const key2 = deriveKey(TEST_SECRET, 'test');
+      expect(key1).toBe(key2);
+    });
+  });
+});

package/tests/utils/math.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest';
+import {
+  vec3Add, vec3Sub, vec3Scale, vec3Dot, vec3Length, vec3Normalize,
+  vec3Distance, vec3Cross, vec3Lerp,
+  quatMultiply, quatConjugate, quatNormalize, quatRotateVec3,
+  quatFromAxisAngle, quatSlerp, QUAT_IDENTITY,
+  poseToMat4, egoToAllo, alloToEgo, stereoDepth,
+  gaussian, gaussian3D, clamp, meanAbsoluteError,
+} from '../../src/utils/math.js';
+
+describe('Vector Operations', () => {
+  it('adds vectors', () => {
+    const result = vec3Add({ x: 1, y: 2, z: 3 }, { x: 4, y: 5, z: 6 });
+    expect(result).toEqual({ x: 5, y: 7, z: 9 });
+  });
+
+  it('subtracts vectors', () => {
+    const result = vec3Sub({ x: 5, y: 7, z: 9 }, { x: 4, y: 5, z: 6 });
+    expect(result).toEqual({ x: 1, y: 2, z: 3 });
+  });
+
+  it('scales vectors', () => {
+    expect(vec3Scale({ x: 1, y: 2, z: 3 }, 2)).toEqual({ x: 2, y: 4, z: 6 });
+  });
+
+  it('computes dot product', () => {
+    expect(vec3Dot({ x: 1, y: 0, z: 0 }, { x: 0, y: 1, z: 0 })).toBe(0);
+    expect(vec3Dot({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })).toBe(14);
+  });
+
+  it('computes length', () => {
+    expect(vec3Length({ x: 3, y: 4, z: 0 })).toBe(5);
+  });
+
+  it('normalizes vectors', () => {
+    const n = vec3Normalize({ x: 3, y: 4, z: 0 });
+    expect(n.x).toBeCloseTo(0.6);
+    expect(n.y).toBeCloseTo(0.8);
+    expect(vec3Length(n)).toBeCloseTo(1);
+  });
+
+  it('handles zero vector normalization', () => {
+    const n = vec3Normalize({ x: 0, y: 0, z: 0 });
+    expect(n).toEqual({ x: 0, y: 0, z: 0 });
+  });
+
+  it('computes distance', () => {
+    expect(vec3Distance({ x: 0, y: 0, z: 0 }, { x: 3, y: 4, z: 0 })).toBe(5);
+  });
+
+  it('computes cross product', () => {
+    const result = vec3Cross({ x: 1, y: 0, z: 0 }, { x: 0, y: 1, z: 0 });
+    expect(result).toEqual({ x: 0, y: 0, z: 1 });
+  });
+
+  it('lerps between vectors', () => {
+    const a = { x: 0, y: 0, z: 0 };
+    const b = { x: 10, y: 10, z: 10 };
+    const mid = vec3Lerp(a, b, 0.5);
+    expect(mid).toEqual({ x: 5, y: 5, z: 5 });
+  });
+
+  it('clamps lerp parameter', () => {
+    const a = { x: 0, y: 0, z: 0 };
+    const b = { x: 10, y: 10, z: 10 };
+    expect(vec3Lerp(a, b, -1)).toEqual(a);
+    expect(vec3Lerp(a, b, 2)).toEqual(b);
+  });
+});
+
+describe('Quaternion Operations', () => {
+  it('identity quaternion preserves rotation', () => {
+    const v = { x: 1, y: 2, z: 3 };
+    const rotated = quatRotateVec3(QUAT_IDENTITY, v);
+    expect(rotated.x).toBeCloseTo(1);
+    expect(rotated.y).toBeCloseTo(2);
+    expect(rotated.z).toBeCloseTo(3);
+  });
+
+  it('rotates 90 degrees around Z axis', () => {
+    const q = quatFromAxisAngle({ x: 0, y: 0, z: 1 }, Math.PI / 2);
+    const v = { x: 1, y: 0, z: 0 };
+    const rotated = quatRotateVec3(q, v);
+    expect(rotated.x).toBeCloseTo(0);
+    expect(rotated.y).toBeCloseTo(1);
+    expect(rotated.z).toBeCloseTo(0);
+  });
+
+  it('conjugate reverses rotation', () => {
+    const q = quatFromAxisAngle({ x: 0, y: 0, z: 1 }, Math.PI / 4);
+    const v = { x: 1, y: 0, z: 0 };
+    const rotated = quatRotateVec3(q, v);
+    const unrotated = quatRotateVec3(quatConjugate(q), rotated);
+    expect(unrotated.x).toBeCloseTo(1);
+    expect(unrotated.y).toBeCloseTo(0);
+    expect(unrotated.z).toBeCloseTo(0);
+  });
+
+  it('slerp interpolates between quaternions', () => {
+    const a = QUAT_IDENTITY;
+    const b = quatFromAxisAngle({ x: 0, y: 0, z: 1 }, Math.PI);
+    const mid = quatSlerp(a, b, 0.5);
+    // At t=0.5, should be 90 degrees rotation
+    const v = quatRotateVec3(mid, { x: 1, y: 0, z: 0 });
+    expect(v.x).toBeCloseTo(0, 1);
+    expect(Math.abs(v.y)).toBeCloseTo(1, 1);
+  });
+});
+
+describe('Coordinate Transforms', () => {
+  it('ego to allo with identity pose is identity', () => {
+    const pose = {
+      position: { x: 0, y: 0, z: 0 },
+      orientation: QUAT_IDENTITY,
+      timestamp: 0,
+    };
+    const result = egoToAllo({ x: 1, y: 2, z: 3 }, pose);
+    expect(result.x).toBeCloseTo(1);
+    expect(result.y).toBeCloseTo(2);
+    expect(result.z).toBeCloseTo(3);
+  });
+
+  it('ego to allo applies translation', () => {
+    const pose = {
+      position: { x: 10, y: 20, z: 30 },
+      orientation: QUAT_IDENTITY,
+      timestamp: 0,
+    };
+    const result = egoToAllo({ x: 1, y: 2, z: 3 }, pose);
+    expect(result.x).toBeCloseTo(11);
+    expect(result.y).toBeCloseTo(22);
+    expect(result.z).toBeCloseTo(33);
+  });
+
+  it('allo to ego reverses ego to allo', () => {
+    const pose = {
+      position: { x: 5, y: 10, z: 15 },
+      orientation: quatFromAxisAngle({ x: 0, y: 0, z: 1 }, Math.PI / 4),
+      timestamp: 0,
+    };
+    const worldPoint = { x: 7, y: 12, z: 18 };
+    const ego = alloToEgo(worldPoint, pose);
+    const back = egoToAllo(ego, pose);
+    expect(back.x).toBeCloseTo(worldPoint.x);
+    expect(back.y).toBeCloseTo(worldPoint.y);
+    expect(back.z).toBeCloseTo(worldPoint.z);
+  });
+
+  it('computes stereo depth correctly', () => {
+    // Z = f*B/d
+    expect(stereoDepth(500, 0.1, 10)).toBeCloseTo(5); // 500*0.1/10 = 5m
+    expect(stereoDepth(500, 0.1, 0)).toBe(Infinity); // zero disparity = infinity
+  });
+});
+
+describe('Statistical Functions', () => {
+  it('gaussian peaks at center', () => {
+    expect(gaussian(0, 0, 1)).toBeCloseTo(1);
+    expect(gaussian(0, 0, 1, 2)).toBeCloseTo(2);
+  });
+
+  it('gaussian falls off with distance', () => {
+    const atCenter = gaussian(0, 0, 1);
+    const at1Sigma = gaussian(1, 0, 1);
+    const at2Sigma = gaussian(2, 0, 1);
+    expect(atCenter).toBeGreaterThan(at1Sigma);
+    expect(at1Sigma).toBeGreaterThan(at2Sigma);
+  });
+
+  it('3D gaussian works in 3D', () => {
+    const center = { x: 0, y: 0, z: 0 };
+    expect(gaussian3D(center, center, 1)).toBeCloseTo(1);
+    expect(gaussian3D({ x: 1, y: 0, z: 0 }, center, 1)).toBeLessThan(1);
+  });
+
+  it('clamp works', () => {
+    expect(clamp(5, 0, 10)).toBe(5);
+    expect(clamp(-5, 0, 10)).toBe(0);
+    expect(clamp(15, 0, 10)).toBe(10);
+  });
+
+  it('meanAbsoluteError computes correctly', () => {
+    const a = new Float32Array([1, 2, 3]);
+    const b = new Float32Array([1, 2, 3]);
+    expect(meanAbsoluteError(a, b)).toBe(0);
+
+    const c = new Float32Array([1, 2, 3]);
+    const d = new Float32Array([2, 3, 4]);
+    expect(meanAbsoluteError(c, d)).toBe(1);
+  });
+
+  it('meanAbsoluteError throws on mismatch', () => {
+    expect(() => meanAbsoluteError(new Float32Array(3), new Float32Array(4))).toThrow('mismatch');
+  });
+});