Add type compiler validation tests for TrackUserProtection (JhaSourav07#3001)

The TrackUserProtection class had no type-level tests verifying its
return types, method signatures, or validation schema constraints.
This made it easy to accidentally change the shape of return values
or allow invalid reason strings during refactors.

Add five type-level tests using expectTypeOf to pin down:
- The return type shape of verifyAndDeduplicate
- Method parameter and return types
- The singleton getInstance return type
- That invalid string literals are blocked for the reason field
- That schema validation returns a strict, stable report type

Co-authored-by: atul-upadhyay-7 <atul-upadhyay-7@users.noreply.github.com>

Author: atul-upadhyay-7

services/security/track-user-protection.type-compiler.test.ts

@@ -0,0 +1,44 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import { TrackUserProtection } from './track-user-protection';
+
+type VerifyResult = Awaited<ReturnType<TrackUserProtection['verifyAndDeduplicate']>>;
+type ValidReason = NonNullable<VerifyResult['reason']>;
+
+describe('TypeScript Compiler Validation & Schema Constraints Stability', () => {
+  it('enforces correct return type shape for verifyAndDeduplicate', () => {
+    expectTypeOf<VerifyResult>().toHaveProperty('allowed').toBeBoolean();
+    expectTypeOf<VerifyResult>().toHaveProperty('reason').toEqualTypeOf<ValidReason | undefined>();
+    expectTypeOf<VerifyResult>().toHaveProperty('remainingMs').toEqualTypeOf<number | undefined>();
+  });
+
+  it('validates method signatures accept correct parameter types and return types', () => {
+    type Instance = TrackUserProtection;
+    expectTypeOf<Instance['validateFormat']>().parameters.toEqualTypeOf<[username: string]>();
+    expectTypeOf<Instance['validateFormat']>().returns.toBeBoolean();
+    expectTypeOf<Instance['isWriteAllowed']>().parameters.toEqualTypeOf<[username: string]>();
+    expectTypeOf<Instance['isWriteAllowed']>().returns.toBeBoolean();
+    expectTypeOf<Instance['recordWrite']>().returns.toBeVoid();
+  });
+
+  it('validates singleton instance pattern returns correct type', () => {
+    expectTypeOf<
+      ReturnType<(typeof TrackUserProtection)['getInstance']>
+    >().toEqualTypeOf<TrackUserProtection>();
+  });
+
+  it('blocks invalid string literals from being assigned to reason field', () => {
+    expectTypeOf<'INVALID'>().not.toMatchTypeOf<ValidReason>();
+    expectTypeOf<'INVALID_FORMAT'>().toMatchTypeOf<ValidReason>();
+    expectTypeOf<'COOLDOWN_ACTIVE'>().toMatchTypeOf<ValidReason>();
+    expectTypeOf<'USER_NOT_FOUND'>().toMatchTypeOf<ValidReason>();
+  });
+
+  it('verifies schema validation constraints return strict validation reports', () => {
+    expectTypeOf<TrackUserProtection['verifyAndDeduplicate']>().parameters.toEqualTypeOf<
+      [username: string]
+    >();
+    expectTypeOf<TrackUserProtection['verifyAndDeduplicate']>().returns.toEqualTypeOf<
+      Promise<VerifyResult>
+    >();
+  });
+});