test(background-refresh): add type compiler validation coverage (JhaSourav07#3300)

## Description

Fixes JhaSourav07#2922

Added TypeScript compiler validation and schema constraint stability
tests for the background refresh service.

### Changes Made

* Created `services/github/background-refresh.type-compiler.test.ts`
* Added type-level assertions using `expectTypeOf`
* Verified public method parameter and return types
* Added checks to ensure invalid parameter types are rejected by
TypeScript
* Verified optional values are accepted without type errors
* Added runtime validation tests for stale and fresh timestamps

These tests help prevent regressions in the BackgroundRefresh API and
ensure type safety remains stable during future updates.

## Pillar

* [ ] 🎨 Pillar 1 — New Theme Design
* [ ] 📐 Pillar 2 — Geometric SVG Improvement
* [ ] 🕐 Pillar 3 — Timezone Logic Optimization
* [x] 🛠️ Other (Bug fix, refactoring, docs)

## Checklist before requesting a review:

* [x] I have read the `CONTRIBUTING.md` file.
* [x] I have tested these changes locally.
* [x] I have run `npm run format` and resolved formatting issues.
* [x] My commits follow the Conventional Commits format.
* [ ] I have updated `README.md` if I added a new theme or URL
parameter.
* [x] I have started the repo.
* [x] I have made sure that I have only one commit to merge in this PR.
* [x] The changes do not affect SVG output.
* [ ] (Recommended) I joined the CommitPulse Discord community for
contributor discussions, mentorship, and faster PR support.

Author: JhaSourav07

services/github/background-refresh.type-compiler.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import backgroundRefresh, { BackgroundRefresh } from './background-refresh';
+
+describe('BackgroundRefresh type compiler validation', () => {
+  it('exposes singleton instance with correct type', () => {
+    expectTypeOf(BackgroundRefresh.getInstance()).toEqualTypeOf<BackgroundRefresh>();
+    expectTypeOf(backgroundRefresh).toEqualTypeOf<BackgroundRefresh>();
+  });
+
+  it('enforces public method input and return types', () => {
+    expectTypeOf(backgroundRefresh.isStale).parameters.toEqualTypeOf<
+      [lastSyncedAt: string | undefined]
+    >();
+    expectTypeOf(backgroundRefresh.isStale).returns.toEqualTypeOf<boolean>();
+
+    expectTypeOf(backgroundRefresh.triggerRefresh).parameters.toEqualTypeOf<[username: string]>();
+    expectTypeOf(backgroundRefresh.triggerRefresh).returns.toEqualTypeOf<void>();
+
+    expectTypeOf(backgroundRefresh.isJobActive).parameters.toEqualTypeOf<[username: string]>();
+    expectTypeOf(backgroundRefresh.isJobActive).returns.toEqualTypeOf<boolean>();
+  });
+
+  it('blocks invalid parameters during static type checking', () => {
+    type IsStaleParams = Parameters<typeof backgroundRefresh.isStale>;
+    type TriggerRefreshParams = Parameters<typeof backgroundRefresh.triggerRefresh>;
+    type IsJobActiveParams = Parameters<typeof backgroundRefresh.isJobActive>;
+
+    expectTypeOf<[number]>().not.toMatchTypeOf<IsStaleParams>();
+    expectTypeOf<[]>().not.toMatchTypeOf<TriggerRefreshParams>();
+    expectTypeOf<[null]>().not.toMatchTypeOf<IsJobActiveParams>();
+  });
+
+  it('accepts optional timestamp values without compile errors', () => {
+    expect(backgroundRefresh.isStale(undefined)).toBe(true);
+    expect(backgroundRefresh.isStale(new Date().toISOString())).toBe(false);
+  });
+
+  it('validates stale date constraints strictly', () => {
+    const staleDate = new Date(Date.now() - 11 * 60 * 1000).toISOString();
+    const freshDate = new Date().toISOString();
+
+    expect(backgroundRefresh.isStale(staleDate)).toBe(true);
+    expect(backgroundRefresh.isStale(freshDate)).toBe(false);
+    expect(backgroundRefresh.isStale('invalid-date')).toBe(false);
+  });
+});