wjttc 1.0.2 → 1.2.0

package/README.md

@@ -9,12 +9,23 @@
 
 ---
 
+## What is WJTTC?
+
+WJTTC is the **WolfeJam Technical Testing Certification**. wolfejam is the dev who created the [IANA-registered .faf format](https://www.iana.org/assignments/media-types/application/vnd.faf+yaml) for AI context - the first and only MCP of its kind. He achieved this largely due to his obsession with technical details and testing.
+
+WJTTC is the rollout of his self-certification secrets to help grade other MCP servers for free, with a view to improving MCP server quality system-wide.
+
+**Score your Server for free. Full leaderboard going live soon - what will your server score?**
+
+---
+
 ## What is Big Orange?
 
-The 🍊 **Big Orange** is a super-score - recognition that an MCP server is above and beyond the standard.
+The 🍊 **Big Orange** is a super-score - recognition that the Server Owner(s) have gone above and beyond the 100% pass rate.
 
-- **100%** = Pass all 46 tests across ALL 7 tiers
+- **100%** = Pass all 49 scored tests across ALL 9 tiers (Tiers 1-8)
 - **+5%** = Awarded for documentation and professional polish
+- **Tier 9** = TAF Receipt Validation (informational only, doesn't affect score)
 
 The 🍊, much like a Michelin Star for a restaurant, is awarded for excellence and well-deserved for Best-of-Class MCP servers.
 
@@ -26,16 +37,16 @@ The 🍊, much like a Michelin Star for a restaurant, is awarded for excellence
 
 ## Certification Tiers
 
-| Tier | Score | Badge | Meaning |
-|------|-------|-------|---------|
-| Big Orange | 105% | 🍊 | *The Michelin Star - Perfection + Excellence* |
-| Trophy | 100% | 🏆 | Perfect MCP compliance |
-| Gold | 99%+ | 🥇 | Exceptional |
-| Silver | 95%+ | 🥈 | Top tier - Excellent |
-| Bronze | 85%+ | 🥉 | Strong - Production ready |
-| Green | 70%+ | 🟢 | Good - Solid foundation |
-| Yellow | 55%+ | 🟡 | Caution - Needs improvement |
-| Red | <55% | 🔴 | Critical - Major work needed |
+| Badge | Tier | Score | Meaning |
+|-------|------|-------|---------|
+| 🍊 | Big Orange | 105% | The Michelin Star of MCP servers |
+| 🏆 | Trophy | 100% | Perfect - 100% pass rate |
+| 🥇 | Gold | 99%+ | Exceptional |
+| 🥈 | Silver | 95%+ | Excellent, room for polish |
+| 🥉 | Bronze | 85%+ | Production ready (minimum recommended) |
+| 🟢 | Green | 70%+ | Solid foundation |
+| 🟡 | Yellow | 55%+ | Needs improvement |
+| 🔴 | Red | <55% | Critical issues |
 
 ---
 
@@ -48,7 +59,7 @@ npx wjttc certify --mcp "npx your-mcp-server"
 # Example output:
 # 🍊 CERTIFICATION: BIG-ORANGE
 #    Score:  105/100
-#    Tests:  46/46 passed
+#    Tests:  49/49 passed (+ 3 validation checks)
 ```
 
 ---
@@ -65,7 +76,7 @@ npx wjttc certify --mcp "npx your-mcp-server"
 
 ## Test System
 
-**46 tests across 7 tiers:**
+**52 tests across 9 tiers** (49 scored + 3 validation checks):
 
 | Tier | Name | Weight | Tests |
 |------|------|--------|-------|
@@ -76,6 +87,10 @@ npx wjttc certify --mcp "npx your-mcp-server"
 | 5 | Security Validation | 15% | 3 |
 | 6 | Performance Benchmarks | 15% | 6 |
 | 7 | Integration Readiness | 10% | 5 |
+| 8 | FAF Documentation | 5% | 3 |
+| 9 | TAF Receipt Validation | Informational | 3 |
+
+**Note:** Tier 9 validates `.taf` receipt files but doesn't affect the 0-100% score. It provides proof of testing history over time.
 
 ---
 

package/dist/__tests__/badge.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WJTTC Badge Generator Tests
+ * Testing the testing tool - F1 grade
+ */
+export {};
+//# sourceMappingURL=badge.test.d.ts.map

package/dist/__tests__/badge.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"badge.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/badge.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/__tests__/badge.test.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * WJTTC Badge Generator Tests
+ * Testing the testing tool - F1 grade
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const badge_1 = require("../badge");
+describe('BadgeGenerator', () => {
+    describe('generate()', () => {
+        it('should generate valid badge JSON for big-orange tier', () => {
+            const badge = badge_1.BadgeGenerator.generate({ score: 105, tier: 'big-orange' });
+            expect(badge.schemaVersion).toBe(1);
+            expect(badge.label).toBe('WJTTC');
+            expect(badge.message).toContain('big-orange');
+            expect(badge.message).toContain('105%');
+            expect(badge.color).toBe('FF8C00');
+        });
+        it('should generate valid badge JSON for trophy tier', () => {
+            const badge = badge_1.BadgeGenerator.generate({ score: 100, tier: 'trophy' });
+            expect(badge.message).toContain('trophy');
+            expect(badge.message).toContain('100%');
+            expect(badge.color).toBe('FFD700');
+        });
+        it('should generate valid badge JSON for silver tier', () => {
+            const badge = badge_1.BadgeGenerator.generate({ score: 95, tier: 'silver' });
+            expect(badge.message).toContain('silver');
+            expect(badge.message).toContain('95%');
+            expect(badge.color).toBe('C0C0C0');
+        });
+        it('should generate valid badge JSON for bronze tier', () => {
+            const badge = badge_1.BadgeGenerator.generate({ score: 85, tier: 'bronze' });
+            expect(badge.message).toContain('bronze');
+            expect(badge.color).toBe('CD7F32');
+        });
+        it('should generate valid badge JSON for red tier', () => {
+            const badge = badge_1.BadgeGenerator.generate({ score: 40, tier: 'red' });
+            expect(badge.message).toContain('red');
+            expect(badge.color).toBe('D50000');
+        });
+        it('should include correct emoji for each tier', () => {
+            const tiers = ['big-orange', 'trophy', 'gold', 'silver', 'bronze', 'green', 'yellow', 'red', 'white'];
+            const emojis = ['🍊', '🏆', '🥇', '🥈', '🥉', '🟢', '🟡', '🔴', '🤍'];
+            tiers.forEach((tier, index) => {
+                const badge = badge_1.BadgeGenerator.generate({ score: 100, tier });
+                expect(badge.message).toContain(emojis[index]);
+            });
+        });
+    });
+    describe('generateUrl()', () => {
+        it('should generate a valid shields.io URL', () => {
+            const url = badge_1.BadgeGenerator.generateUrl({ score: 95, tier: 'silver' });
+            expect(url).toContain('https://img.shields.io/endpoint');
+            expect(url).toContain('data:application/json');
+        });
+        it('should include encoded badge data in URL', () => {
+            const url = badge_1.BadgeGenerator.generateUrl({ score: 105, tier: 'big-orange' });
+            expect(url).toContain('WJTTC');
+            expect(url).toContain('FF8C00');
+        });
+    });
+    describe('generateMarkdown()', () => {
+        it('should generate valid markdown without repo URL', () => {
+            const md = badge_1.BadgeGenerator.generateMarkdown({ score: 95, tier: 'silver' });
+            expect(md).toMatch(/^!\[WJTTC silver\]\(https:\/\/img\.shields\.io/);
+        });
+        it('should generate linked markdown with repo URL', () => {
+            const md = badge_1.BadgeGenerator.generateMarkdown({ score: 105, tier: 'big-orange' }, 'https://github.com/example/repo');
+            expect(md).toMatch(/^\[!\[WJTTC big-orange\]/);
+            expect(md).toContain('https://github.com/example/repo');
+        });
+    });
+    describe('generateHtml()', () => {
+        it('should generate valid HTML img tag without repo URL', () => {
+            const html = badge_1.BadgeGenerator.generateHtml({ score: 85, tier: 'bronze' });
+            expect(html).toMatch(/^<img src="https:\/\/img\.shields\.io/);
+            expect(html).toContain('alt="WJTTC bronze"');
+        });
+        it('should generate linked HTML with repo URL', () => {
+            const html = badge_1.BadgeGenerator.generateHtml({ score: 100, tier: 'trophy' }, 'https://github.com/example/repo');
+            expect(html).toMatch(/^<a href="https:\/\/github\.com\/example\/repo">/);
+            expect(html).toContain('<img');
+            expect(html).toContain('</a>');
+        });
+    });
+});
+//# sourceMappingURL=badge.test.js.map

package/dist/__tests__/badge.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"badge.test.js","sourceRoot":"","sources":["../../src/__tests__/badge.test.ts"],"names":[],"mappings":"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"}

package/dist/__tests__/certifier.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WJTTC Certifier Tests
+ * Comprehensive tests for the core certification engine
+ * "Testing the tester" - F1 Championship Grade
+ */
+export {};
+//# sourceMappingURL=certifier.test.d.ts.map

package/dist/__tests__/certifier.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certifier.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/certifier.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/__tests__/certifier.test.js

@@ -0,0 +1,451 @@
+"use strict";
+/**
+ * WJTTC Certifier Tests
+ * Comprehensive tests for the core certification engine
+ * "Testing the tester" - F1 Championship Grade
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER SYSTEM CONSTANTS (extracted for testing)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+const TIER_NAMES = {
+    1: 'Protocol Compliance',
+    2: 'Capability Negotiation',
+    3: 'Tool Integrity',
+    4: 'Resource Management',
+    5: 'Security Validation',
+    6: 'Performance Benchmarks',
+    7: 'Integration Readiness',
+};
+const TIER_WEIGHTS = {
+    1: 20,
+    2: 10,
+    3: 20,
+    4: 10,
+    5: 15,
+    6: 15,
+    7: 10,
+};
+const TIER_TEST_COUNTS = {
+    1: 12,
+    2: 8,
+    3: 6,
+    4: 6,
+    5: 3,
+    6: 6,
+    7: 5,
+};
+// Score tier boundaries
+const TIER_BOUNDARIES = [
+    { min: 105, max: 105, tier: 'big-orange' },
+    { min: 100, max: 104, tier: 'trophy' },
+    { min: 99, max: 99, tier: 'gold' },
+    { min: 95, max: 98, tier: 'silver' },
+    { min: 85, max: 94, tier: 'bronze' },
+    { min: 70, max: 84, tier: 'green' },
+    { min: 55, max: 69, tier: 'yellow' },
+    { min: 0, max: 54, tier: 'red' },
+];
+// Helper to determine tier from score
+function getTierFromScore(score) {
+    if (score >= 105)
+        return 'big-orange';
+    if (score >= 100)
+        return 'trophy';
+    if (score >= 99)
+        return 'gold';
+    if (score >= 95)
+        return 'silver';
+    if (score >= 85)
+        return 'bronze';
+    if (score >= 70)
+        return 'green';
+    if (score >= 55)
+        return 'yellow';
+    return 'red';
+}
+// Helper to calculate weighted score (mirrors certifier logic)
+function calculateWeightedScore(tierResults) {
+    let weightedScore = 0;
+    let totalWeight = 0;
+    for (const result of tierResults) {
+        const weight = TIER_WEIGHTS[result.tier] || 10;
+        const tierScore = result.totalTests > 0
+            ? (result.passedTests / result.totalTests) * 100
+            : 0;
+        weightedScore += tierScore * weight;
+        totalWeight += weight;
+    }
+    return totalWeight > 0 ? Math.round(weightedScore / totalWeight) : 0;
+}
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER SYSTEM TESTS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Tier System', () => {
+    describe('Tier Names', () => {
+        it('should have exactly 7 tiers', () => {
+            expect(Object.keys(TIER_NAMES)).toHaveLength(7);
+        });
+        it('should have tier 1 as Protocol Compliance', () => {
+            expect(TIER_NAMES[1]).toBe('Protocol Compliance');
+        });
+        it('should have tier 2 as Capability Negotiation', () => {
+            expect(TIER_NAMES[2]).toBe('Capability Negotiation');
+        });
+        it('should have tier 3 as Tool Integrity', () => {
+            expect(TIER_NAMES[3]).toBe('Tool Integrity');
+        });
+        it('should have tier 4 as Resource Management', () => {
+            expect(TIER_NAMES[4]).toBe('Resource Management');
+        });
+        it('should have tier 5 as Security Validation', () => {
+            expect(TIER_NAMES[5]).toBe('Security Validation');
+        });
+        it('should have tier 6 as Performance Benchmarks', () => {
+            expect(TIER_NAMES[6]).toBe('Performance Benchmarks');
+        });
+        it('should have tier 7 as Integration Readiness', () => {
+            expect(TIER_NAMES[7]).toBe('Integration Readiness');
+        });
+    });
+    describe('Tier Weights', () => {
+        it('should have exactly 7 tier weights', () => {
+            expect(Object.keys(TIER_WEIGHTS)).toHaveLength(7);
+        });
+        it('should have weights that sum to 100', () => {
+            const totalWeight = Object.values(TIER_WEIGHTS).reduce((a, b) => a + b, 0);
+            expect(totalWeight).toBe(100);
+        });
+        it('should have Protocol Compliance (T1) weighted at 20%', () => {
+            expect(TIER_WEIGHTS[1]).toBe(20);
+        });
+        it('should have Capability Negotiation (T2) weighted at 10%', () => {
+            expect(TIER_WEIGHTS[2]).toBe(10);
+        });
+        it('should have Tool Integrity (T3) weighted at 20%', () => {
+            expect(TIER_WEIGHTS[3]).toBe(20);
+        });
+        it('should have Resource Management (T4) weighted at 10%', () => {
+            expect(TIER_WEIGHTS[4]).toBe(10);
+        });
+        it('should have Security Validation (T5) weighted at 15%', () => {
+            expect(TIER_WEIGHTS[5]).toBe(15);
+        });
+        it('should have Performance Benchmarks (T6) weighted at 15%', () => {
+            expect(TIER_WEIGHTS[6]).toBe(15);
+        });
+        it('should have Integration Readiness (T7) weighted at 10%', () => {
+            expect(TIER_WEIGHTS[7]).toBe(10);
+        });
+    });
+    describe('Test Counts', () => {
+        it('should have 46 total tests across all tiers', () => {
+            const totalTests = Object.values(TIER_TEST_COUNTS).reduce((a, b) => a + b, 0);
+            expect(totalTests).toBe(46);
+        });
+        it('should have 12 tests in Tier 1', () => {
+            expect(TIER_TEST_COUNTS[1]).toBe(12);
+        });
+        it('should have 8 tests in Tier 2', () => {
+            expect(TIER_TEST_COUNTS[2]).toBe(8);
+        });
+        it('should have 6 tests in Tier 3', () => {
+            expect(TIER_TEST_COUNTS[3]).toBe(6);
+        });
+        it('should have 6 tests in Tier 4', () => {
+            expect(TIER_TEST_COUNTS[4]).toBe(6);
+        });
+        it('should have 3 tests in Tier 5', () => {
+            expect(TIER_TEST_COUNTS[5]).toBe(3);
+        });
+        it('should have 6 tests in Tier 6', () => {
+            expect(TIER_TEST_COUNTS[6]).toBe(6);
+        });
+        it('should have 5 tests in Tier 7', () => {
+            expect(TIER_TEST_COUNTS[7]).toBe(5);
+        });
+    });
+});
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// SCORE CALCULATION TESTS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Score Calculation', () => {
+    describe('Weighted Score Algorithm', () => {
+        it('should return 100 when all tests pass', () => {
+            const allPassing = Object.entries(TIER_TEST_COUNTS).map(([tier, count]) => ({
+                tier: parseInt(tier),
+                passedTests: count,
+                totalTests: count,
+            }));
+            const score = calculateWeightedScore(allPassing);
+            expect(score).toBe(100);
+        });
+        it('should return 0 when no tests pass', () => {
+            const nonePassing = Object.entries(TIER_TEST_COUNTS).map(([tier, count]) => ({
+                tier: parseInt(tier),
+                passedTests: 0,
+                totalTests: count,
+            }));
+            const score = calculateWeightedScore(nonePassing);
+            expect(score).toBe(0);
+        });
+        it('should return 50 when half tests pass in each tier', () => {
+            const halfPassing = Object.entries(TIER_TEST_COUNTS).map(([tier, count]) => ({
+                tier: parseInt(tier),
+                passedTests: Math.floor(count / 2),
+                totalTests: count,
+            }));
+            const score = calculateWeightedScore(halfPassing);
+            expect(score).toBeGreaterThanOrEqual(45);
+            expect(score).toBeLessThanOrEqual(55);
+        });
+        it('should weight Tier 1 and Tier 3 more heavily (20% each)', () => {
+            // Only Tier 1 passing = 20% of 100 = 20
+            const onlyTier1 = [
+                { tier: 1, passedTests: TIER_TEST_COUNTS[1], totalTests: TIER_TEST_COUNTS[1] },
+                { tier: 2, passedTests: 0, totalTests: TIER_TEST_COUNTS[2] },
+                { tier: 3, passedTests: 0, totalTests: TIER_TEST_COUNTS[3] },
+                { tier: 4, passedTests: 0, totalTests: TIER_TEST_COUNTS[4] },
+                { tier: 5, passedTests: 0, totalTests: TIER_TEST_COUNTS[5] },
+                { tier: 6, passedTests: 0, totalTests: TIER_TEST_COUNTS[6] },
+                { tier: 7, passedTests: 0, totalTests: TIER_TEST_COUNTS[7] },
+            ];
+            const score = calculateWeightedScore(onlyTier1);
+            expect(score).toBe(20);
+        });
+        it('should correctly calculate partial tier scores', () => {
+            // Tier 1: 10/12 passed, weight 20%
+            // Score contribution: (10/12) * 100 * 20 / 100 = 16.67
+            const partialTier1 = [
+                { tier: 1, passedTests: 10, totalTests: 12 },
+                { tier: 2, passedTests: 0, totalTests: 8 },
+                { tier: 3, passedTests: 0, totalTests: 6 },
+                { tier: 4, passedTests: 0, totalTests: 6 },
+                { tier: 5, passedTests: 0, totalTests: 3 },
+                { tier: 6, passedTests: 0, totalTests: 6 },
+                { tier: 7, passedTests: 0, totalTests: 5 },
+            ];
+            const score = calculateWeightedScore(partialTier1);
+            expect(score).toBe(17); // Rounded
+        });
+    });
+    describe('Tier Level Determination', () => {
+        it('should return big-orange for score of 105', () => {
+            expect(getTierFromScore(105)).toBe('big-orange');
+        });
+        it('should return trophy for score of 100', () => {
+            expect(getTierFromScore(100)).toBe('trophy');
+        });
+        it('should return gold for score of 99', () => {
+            expect(getTierFromScore(99)).toBe('gold');
+        });
+        it('should return silver for score of 95-98', () => {
+            expect(getTierFromScore(95)).toBe('silver');
+            expect(getTierFromScore(96)).toBe('silver');
+            expect(getTierFromScore(97)).toBe('silver');
+            expect(getTierFromScore(98)).toBe('silver');
+        });
+        it('should return bronze for score of 85-94', () => {
+            expect(getTierFromScore(85)).toBe('bronze');
+            expect(getTierFromScore(90)).toBe('bronze');
+            expect(getTierFromScore(94)).toBe('bronze');
+        });
+        it('should return green for score of 70-84', () => {
+            expect(getTierFromScore(70)).toBe('green');
+            expect(getTierFromScore(77)).toBe('green');
+            expect(getTierFromScore(84)).toBe('green');
+        });
+        it('should return yellow for score of 55-69', () => {
+            expect(getTierFromScore(55)).toBe('yellow');
+            expect(getTierFromScore(62)).toBe('yellow');
+            expect(getTierFromScore(69)).toBe('yellow');
+        });
+        it('should return red for score below 55', () => {
+            expect(getTierFromScore(54)).toBe('red');
+            expect(getTierFromScore(30)).toBe('red');
+            expect(getTierFromScore(0)).toBe('red');
+        });
+    });
+    describe('Tier Boundary Edge Cases', () => {
+        it('should handle boundary between trophy (100) and gold (99)', () => {
+            expect(getTierFromScore(100)).toBe('trophy');
+            expect(getTierFromScore(99)).toBe('gold');
+        });
+        it('should handle boundary between gold (99) and silver (98)', () => {
+            expect(getTierFromScore(99)).toBe('gold');
+            expect(getTierFromScore(98)).toBe('silver');
+        });
+        it('should handle boundary between silver (95) and bronze (94)', () => {
+            expect(getTierFromScore(95)).toBe('silver');
+            expect(getTierFromScore(94)).toBe('bronze');
+        });
+        it('should handle boundary between bronze (85) and green (84)', () => {
+            expect(getTierFromScore(85)).toBe('bronze');
+            expect(getTierFromScore(84)).toBe('green');
+        });
+        it('should handle boundary between green (70) and yellow (69)', () => {
+            expect(getTierFromScore(70)).toBe('green');
+            expect(getTierFromScore(69)).toBe('yellow');
+        });
+        it('should handle boundary between yellow (55) and red (54)', () => {
+            expect(getTierFromScore(55)).toBe('yellow');
+            expect(getTierFromScore(54)).toBe('red');
+        });
+    });
+});
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// BIG ORANGE TESTS - THE MICHELIN STAR
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Big Orange (105%) - The Michelin Star', () => {
+    it('should be 5% above perfect score', () => {
+        expect(105 - 100).toBe(5);
+    });
+    it('should only be achievable with 100% pass rate', () => {
+        // Big Orange requires ALL tests passing, then bonus
+        const almostPerfect = Object.entries(TIER_TEST_COUNTS).map(([tier, count]) => ({
+            tier: parseInt(tier),
+            passedTests: tier === '1' ? count - 1 : count, // Miss 1 test in tier 1
+            totalTests: count,
+        }));
+        const score = calculateWeightedScore(almostPerfect);
+        expect(score).toBeLessThan(100);
+        expect(getTierFromScore(score)).not.toBe('big-orange');
+    });
+    it('should represent excellence beyond standard compliance', () => {
+        // This is documented behavior - 105% = 100% tests + 5% documentation/polish bonus
+        expect(getTierFromScore(105)).toBe('big-orange');
+        expect(getTierFromScore(104)).not.toBe('big-orange');
+    });
+});
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TYPE DEFINITIONS TESTS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Type Definitions', () => {
+    describe('TierLevel Type', () => {
+        const validTiers = [
+            'big-orange',
+            'trophy',
+            'gold',
+            'silver',
+            'bronze',
+            'green',
+            'yellow',
+            'red',
+            'white',
+        ];
+        it('should include all 9 tier levels', () => {
+            expect(validTiers).toHaveLength(9);
+        });
+        it('should include big-orange as highest tier', () => {
+            expect(validTiers).toContain('big-orange');
+        });
+        it('should include white as lowest/empty tier', () => {
+            expect(validTiers).toContain('white');
+        });
+        it('should include all medal tiers (gold, silver, bronze)', () => {
+            expect(validTiers).toContain('gold');
+            expect(validTiers).toContain('silver');
+            expect(validTiers).toContain('bronze');
+        });
+        it('should include traffic light tiers (green, yellow, red)', () => {
+            expect(validTiers).toContain('green');
+            expect(validTiers).toContain('yellow');
+            expect(validTiers).toContain('red');
+        });
+    });
+});
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// CERTIFICATION RESULT STRUCTURE TESTS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Certification Result Structure', () => {
+    // Mock result structure for testing
+    const mockResult = {
+        score: 95,
+        totalTests: 46,
+        passedTests: 44,
+        failedTests: 2,
+        tierResults: [
+            { tier: 1, name: 'Protocol Compliance', passed: true, passedTests: 12, totalTests: 12, failedTests: [], duration: 100 },
+            { tier: 2, name: 'Capability Negotiation', passed: true, passedTests: 8, totalTests: 8, failedTests: [], duration: 50 },
+            { tier: 3, name: 'Tool Integrity', passed: false, passedTests: 5, totalTests: 6, failedTests: ['Test failed'], duration: 200 },
+        ],
+        timestamp: '2025-12-02T00:00:00.000Z',
+    };
+    it('should have required score field', () => {
+        expect(mockResult).toHaveProperty('score');
+        expect(typeof mockResult.score).toBe('number');
+    });
+    it('should have required totalTests field', () => {
+        expect(mockResult).toHaveProperty('totalTests');
+        expect(typeof mockResult.totalTests).toBe('number');
+    });
+    it('should have required passedTests field', () => {
+        expect(mockResult).toHaveProperty('passedTests');
+        expect(typeof mockResult.passedTests).toBe('number');
+    });
+    it('should have required failedTests field', () => {
+        expect(mockResult).toHaveProperty('failedTests');
+        expect(typeof mockResult.failedTests).toBe('number');
+    });
+    it('should have required tierResults array', () => {
+        expect(mockResult).toHaveProperty('tierResults');
+        expect(Array.isArray(mockResult.tierResults)).toBe(true);
+    });
+    it('should have required timestamp field', () => {
+        expect(mockResult).toHaveProperty('timestamp');
+        expect(typeof mockResult.timestamp).toBe('string');
+    });
+    it('should have passedTests + failedTests equal totalTests', () => {
+        expect(mockResult.passedTests + mockResult.failedTests).toBe(mockResult.totalTests);
+    });
+});
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER RESULT STRUCTURE TESTS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+describe('Tier Result Structure', () => {
+    const mockTierResult = {
+        tier: 1,
+        name: 'Protocol Compliance',
+        passed: true,
+        passedTests: 12,
+        totalTests: 12,
+        failedTests: [],
+        duration: 100,
+    };
+    it('should have tier number', () => {
+        expect(mockTierResult).toHaveProperty('tier');
+        expect(typeof mockTierResult.tier).toBe('number');
+    });
+    it('should have tier name', () => {
+        expect(mockTierResult).toHaveProperty('name');
+        expect(typeof mockTierResult.name).toBe('string');
+    });
+    it('should have passed boolean', () => {
+        expect(mockTierResult).toHaveProperty('passed');
+        expect(typeof mockTierResult.passed).toBe('boolean');
+    });
+    it('should have passedTests count', () => {
+        expect(mockTierResult).toHaveProperty('passedTests');
+        expect(typeof mockTierResult.passedTests).toBe('number');
+    });
+    it('should have totalTests count', () => {
+        expect(mockTierResult).toHaveProperty('totalTests');
+        expect(typeof mockTierResult.totalTests).toBe('number');
+    });
+    it('should have failedTests array', () => {
+        expect(mockTierResult).toHaveProperty('failedTests');
+        expect(Array.isArray(mockTierResult.failedTests)).toBe(true);
+    });
+    it('should have duration in ms', () => {
+        expect(mockTierResult).toHaveProperty('duration');
+        expect(typeof mockTierResult.duration).toBe('number');
+    });
+    it('should have passed=true when passedTests equals totalTests', () => {
+        expect(mockTierResult.passedTests).toBe(mockTierResult.totalTests);
+        expect(mockTierResult.passed).toBe(true);
+    });
+    it('should have empty failedTests array when all pass', () => {
+        expect(mockTierResult.failedTests).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=certifier.test.js.map