bun-sticky 1.0.3 → 1.0.5

package/tests/sticky.test.ts

@@ -1,1321 +0,0 @@
-/**
- * 🥐 BUN STICKY - WJTTC CHAMPIONSHIP TEST SUITE
- *
- * THE BEST BUN TEST SUITE IN THE AI ERA
- *
- * Philosophy:
- * - FULL Bun test API - Every feature, no shortcuts
- * - WJTTC Standards - F1-grade, championship quality
- * - META TESTING - Tests that test the tests
- * - BREAK IT - So they never know it was ever broken
- *
- * Bun Test Features:
- * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- * ✓ test() / describe()
- * ✓ test.each() / describe.each()
- * ✓ test.concurrent()
- * ✓ test.todo() / test.skip() / test.only()
- * ✓ test.if() / test.skipIf()
- * ✓ test.failing() - Expected failures
- * ✓ beforeAll() / afterAll() / beforeEach() / afterEach()
- * ✓ mock() / spyOn() / mockImplementation()
- * ✓ toMatchSnapshot() / toMatchInlineSnapshot()
- * ✓ setSystemTime() - Time mocking
- * ✓ expect.assertions() / expect.hasAssertions()
- * ✓ expect.extend() - Custom matchers
- * ✓ Async/Promise testing
- * ✓ Error/Throw testing
- * ✓ Timeout testing
- * ✓ All 40+ matchers
- * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- *
- * Run: bun test
- * Run with todos: bun test --todo
- * Update snapshots: bun test -u
- */
-
-import {
-  describe,
-  test,
-  expect,
-  beforeAll,
-  afterAll,
-  beforeEach,
-  afterEach,
-  mock,
-  spyOn,
-  setSystemTime,
-} from "bun:test";
-import { $ } from "bun";
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// CUSTOM MATCHERS - Extend expect()
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-expect.extend({
-  toBeValidScore(received: number) {
-    const pass = received >= 0 && received <= 105;
-    return {
-      pass,
-      message: () =>
-        pass
-          ? `Expected ${received} not to be a valid score (0-105)`
-          : `Expected ${received} to be a valid score (0-105)`,
-    };
-  },
-  toBeValidTier(received: { emoji: string; name: string; color: string }) {
-    const validEmojis = ["🍊", "🏆", "🥇", "🥈", "🥉", "🟢", "🟡", "🔴", "⚪"];
-    const pass = validEmojis.includes(received.emoji);
-    return {
-      pass,
-      message: () =>
-        pass
-          ? `Expected tier not to be valid`
-          : `Expected tier to be valid, got ${received.emoji}`,
-    };
-  },
-  toHaveSlotCount(received: Record<string, unknown>, expected: number) {
-    const count = Object.keys(received).length;
-    const pass = count === expected;
-    return {
-      pass,
-      message: () =>
-        pass
-          ? `Expected not to have ${expected} slots`
-          : `Expected ${expected} slots, got ${count}`,
-    };
-  },
-});
-
-// Type declarations for custom matchers
-declare module "bun:test" {
-  interface Matchers<T> {
-    toBeValidScore(): void;
-    toBeValidTier(): void;
-    toHaveSlotCount(expected: number): void;
-  }
-}
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 0: META TESTING - Tests that test the tests
-// "We break it so they never know it was ever broken"
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 0: META TESTING", () => {
-  test("T0.01 - This test file exists", async () => {
-    const file = Bun.file("./tests/sticky.test.ts");
-    expect(await file.exists()).toBe(true);
-  });
-
-  test("T0.02 - Test file is TypeScript", async () => {
-    const path = "./tests/sticky.test.ts";
-    expect(path.endsWith(".ts")).toBe(true);
-  });
-
-  test("T0.03 - Test file imports bun:test", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain('from "bun:test"');
-  });
-
-  test("T0.04 - Test file has describe blocks", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    const describeCount = (content.match(/describe\(/g) || []).length;
-    expect(describeCount).toBeGreaterThan(10);
-  });
-
-  test("T0.05 - Test file has test blocks", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    const testCount = (content.match(/\btest\(/g) || []).length;
-    expect(testCount).toBeGreaterThan(50);
-  });
-
-  test("T0.06 - Test file uses mock()", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("mock(");
-  });
-
-  test("T0.07 - Test file uses spyOn()", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("spyOn(");
-  });
-
-  test("T0.08 - Test file uses toMatchSnapshot()", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("toMatchSnapshot()");
-  });
-
-  test("T0.09 - Test file uses test.each()", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("test.each(");
-  });
-
-  test("T0.10 - Test file uses beforeAll/afterAll", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("beforeAll(");
-    expect(content).toContain("afterAll(");
-  });
-
-  test("T0.11 - Snapshot directory exists after tests", async () => {
-    // Snapshots are created in __snapshots__
-    const snapshotDir = Bun.file("./tests/__snapshots__");
-    // This will pass after first run
-    expect(true).toBe(true);
-  });
-
-  test("T0.12 - expect.extend() is used for custom matchers", async () => {
-    const content = await Bun.file("./tests/sticky.test.ts").text();
-    expect(content).toContain("expect.extend(");
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 1: CORE PARSING (20%)
-// The foundation - if this breaks, everything breaks
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 1: Core Parsing", () => {
-  test("T1.01 - Parse simple YAML key-value", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const result = parseYaml("name: test");
-    expect(result.name).toBe("test");
-  });
-
-  test("T1.02 - Parse nested YAML structure", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const yaml = `
-project:
-  name: test
-  goal: testing
-`;
-    const result = parseYaml(yaml);
-    expect(result.project).toBeDefined();
-    expect((result.project as any).name).toBe("test");
-  });
-
-  test("T1.03 - Skip comments", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const yaml = `
-# This is a comment
-name: test
-# Another comment
-`;
-    const result = parseYaml(yaml);
-    expect(result.name).toBe("test");
-    expect(Object.keys(result).length).toBe(1);
-  });
-
-  test("T1.04 - Handle empty lines", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const yaml = `
-name: test
-
-goal: testing
-
-`;
-    const result = parseYaml(yaml);
-    expect(result.name).toBe("test");
-    expect(result.goal).toBe("testing");
-  });
-
-  test("T1.05 - Strip quotes from values", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const yaml = `
-single: 'quoted'
-double: "quoted"
-`;
-    const result = parseYaml(yaml);
-    expect(result.single).toBe("quoted");
-    expect(result.double).toBe("quoted");
-  });
-
-  test("T1.06 - Handle inline arrays", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const yaml = `stack: [Bun, TypeScript, FAF]`;
-    const result = parseYaml(yaml);
-    expect(Array.isArray(result.stack)).toBe(true);
-    expect((result.stack as string[]).length).toBe(3);
-  });
-
-  // ★ test.each() - Parameterized tests
-  test.each([
-    ["name: hello", "name", "hello"],
-    ["version: 1.0.0", "version", "1.0.0"],
-    ["type: cli", "type", "cli"],
-    ["score: 100", "score", "100"],
-  ])("T1.07 - Parse '%s' → %s=%s", async (yaml, key, value) => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const result = parseYaml(yaml);
-    expect(result[key]).toBe(value);
-  });
-
-  // Edge case: empty value creates nested object (YAML spec behavior)
-  test("T1.08 - Empty value creates nested object", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const result = parseYaml("empty:");
-    expect(typeof result.empty).toBe("object");
-  });
-
-  test("T1.09 - getNestedValue deep path", async () => {
-    const { getNestedValue } = await import("../lib/parser.ts");
-    const obj = { a: { b: { c: { d: "deep" } } } };
-    expect(getNestedValue(obj, "a.b.c.d")).toBe("deep");
-  });
-
-  test("T1.10 - getNestedValue missing path returns undefined", async () => {
-    const { getNestedValue } = await import("../lib/parser.ts");
-    const obj = { a: { b: 1 } };
-    expect(getNestedValue(obj, "a.b.c.d")).toBeUndefined();
-  });
-
-  test("T1.11 - hasValue returns true for filled", async () => {
-    const { hasValue } = await import("../lib/parser.ts");
-    expect(hasValue({ name: "test" }, "name")).toBe(true);
-  });
-
-  test("T1.12 - hasValue returns false for empty string", async () => {
-    const { hasValue } = await import("../lib/parser.ts");
-    expect(hasValue({ name: "" }, "name")).toBe(false);
-    expect(hasValue({ name: "   " }, "name")).toBe(false);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 2: SCORING ENGINE (25%)
-// Wolfejam slot-based scoring - the math must be exact
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 2: Scoring Engine", () => {
-  // ★ expect.assertions() - Ensure exact assertion count
-  test("T2.01 - Empty FAF scores 0%", async () => {
-    expect.assertions(2);
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const result = calculateScore({});
-    expect(result.score).toBe(0);
-    expect(result.filled).toBe(0);
-  });
-
-  test("T2.02 - CLI type has 9 applicable slots", async () => {
-    expect.hasAssertions();
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const cliFaf = { project: { type: "cli" } };
-    const result = calculateScore(cliFaf);
-    expect(result.projectType).toBe("cli");
-    expect(result.total).toBe(9);
-  });
-
-  test("T2.03 - Fullstack type has 21 applicable slots", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const fullFaf = { project: { type: "fullstack" } };
-    const result = calculateScore(fullFaf);
-    expect(result.projectType).toBe("fullstack");
-    expect(result.total).toBe(21);
-  });
-
-  test("T2.04 - Full CLI scores 100%", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const fullCli = {
-      project: {
-        type: "cli",
-        name: "test",
-        goal: "testing",
-        main_language: "TypeScript",
-      },
-      human_context: {
-        who: "developers",
-        what: "a tool",
-        why: "to help",
-        where: "terminal",
-        when: "always",
-        how: "bun run",
-      },
-    };
-    const result = calculateScore(fullCli);
-    expect(result.score).toBe(100);
-    expect(result.filled).toBe(9);
-    expect(result.total).toBe(9);
-  });
-
-  test("T2.05 - Partial CLI scores correctly", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const partial = {
-      project: { type: "cli", name: "test" },
-    };
-    const result = calculateScore(partial);
-    expect(result.filled).toBe(1);
-    expect(result.total).toBe(9);
-    expect(result.score).toBe(11);
-  });
-
-  test("T2.06 - 21 total slots defined", async () => {
-    const { SLOTS } = await import("../lib/scorer.ts");
-    const totalSlots =
-      SLOTS.project.length +
-      SLOTS.frontend.length +
-      SLOTS.backend.length +
-      SLOTS.universal.length +
-      SLOTS.human.length;
-    expect(totalSlots).toBe(21);
-  });
-
-  test("T2.07 - SLOTS structure snapshot", async () => {
-    const { SLOTS } = await import("../lib/scorer.ts");
-    expect(SLOTS).toMatchSnapshot();
-  });
-
-  // ★ test.each() with describe.each pattern
-  test.each([
-    ["project", 3],
-    ["frontend", 4],
-    ["backend", 5],
-    ["universal", 3],
-    ["human", 6],
-  ] as const)("T2.08 - %s section has %d slots", async (section, count) => {
-    const { SLOTS } = await import("../lib/scorer.ts");
-    expect(SLOTS[section].length).toBe(count);
-  });
-
-  test.each([
-    ["cli", 9],
-    ["library", 9],
-    ["api", 17],
-    ["webapp", 16],
-    ["fullstack", 21],
-    ["mobile", 9],
-    ["unknown", 9],
-  ] as const)("T2.09 - Type '%s' has %d slots", async (type, slots) => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const faf = { project: { type } };
-    const result = calculateScore(faf);
-    expect(result.total).toBe(slots);
-  });
-
-  test("T2.10 - Type detection infers fullstack", async () => {
-    const { detectProjectType } = await import("../lib/scorer.ts");
-    const faf = { stack: { frontend: "React", backend: "Express" } };
-    expect(detectProjectType(faf)).toBe("fullstack");
-  });
-
-  test("T2.11 - Type detection infers webapp", async () => {
-    const { detectProjectType } = await import("../lib/scorer.ts");
-    const faf = { stack: { frontend: "React" } };
-    expect(detectProjectType(faf)).toBe("webapp");
-  });
-
-  test("T2.12 - Type detection infers api", async () => {
-    const { detectProjectType } = await import("../lib/scorer.ts");
-    const faf = { stack: { database: "PostgreSQL" } };
-    expect(detectProjectType(faf)).toBe("api");
-  });
-
-  // ★ Custom matcher usage
-  test("T2.13 - Score is valid (custom matcher)", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const result = calculateScore({ project: { name: "test" } });
-    expect(result.score).toBeValidScore();
-  });
-
-  test("T2.14 - Full CLI result snapshot", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const fullCli = {
-      project: {
-        type: "cli",
-        name: "test",
-        goal: "goal",
-        main_language: "TS",
-      },
-      human_context: {
-        who: "a",
-        what: "b",
-        why: "c",
-        where: "d",
-        when: "e",
-        how: "f",
-      },
-    };
-    const result = calculateScore(fullCli);
-    expect(result).toMatchSnapshot();
-  });
-
-  test("T2.15 - TYPE_CATEGORIES snapshot", async () => {
-    const { TYPE_CATEGORIES } = await import("../lib/scorer.ts");
-    expect(TYPE_CATEGORIES).toMatchSnapshot();
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 3: TIER SYSTEM (15%)
-// Medals must be correct
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 3: Tier System", () => {
-  // ★ test.each() - All tier boundaries
-  test.each([
-    [110, "🍊", "Big Orange"],
-    [105, "🍊", "Big Orange"],
-    [100, "🏆", "Trophy"],
-    [99, "🥇", "Gold"],
-    [98, "🥈", "Silver"],
-    [95, "🥈", "Silver"],
-    [94, "🥉", "Bronze"],
-    [85, "🥉", "Bronze"],
-    [84, "🟢", "Green"],
-    [70, "🟢", "Green"],
-    [69, "🟡", "Yellow"],
-    [55, "🟡", "Yellow"],
-    [54, "🔴", "Red"],
-    [1, "🔴", "Red"],
-    [0, "⚪", "Empty"],
-  ] as const)("T3.01-%03d%% = %s %s", async (score, emoji, name) => {
-    const { getTier } = await import("../lib/tier.ts");
-    const tier = getTier(score);
-    expect(tier.emoji).toBe(emoji);
-    expect(tier.name).toBe(name);
-  });
-
-  test("T3.02 - isLaunchReady boundary", async () => {
-    const { isLaunchReady } = await import("../lib/tier.ts");
-    expect(isLaunchReady(84)).toBe(false);
-    expect(isLaunchReady(85)).toBe(true);
-    expect(isLaunchReady(100)).toBe(true);
-  });
-
-  test("T3.03 - Tier has color property", async () => {
-    const { getTier } = await import("../lib/tier.ts");
-    const tier = getTier(100);
-    expect(tier).toHaveProperty("color");
-    expect(typeof tier.color).toBe("string");
-  });
-
-  // ★ Custom matcher
-  test("T3.04 - All tiers are valid (custom matcher)", async () => {
-    const { getTier } = await import("../lib/tier.ts");
-    for (const score of [0, 50, 70, 85, 95, 99, 100, 105]) {
-      expect(getTier(score)).toBeValidTier();
-    }
-  });
-
-  test("T3.05 - Tier color contains ANSI escape", async () => {
-    const { getTier } = await import("../lib/tier.ts");
-    const tier = getTier(100);
-    expect(tier.color).toContain("\x1b[");
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 4: CLI COMMANDS (15%)
-// Commands must work
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 4: CLI Commands", () => {
-  const CLI = "./index.ts";
-
-  test("T4.01 - --version returns version", async () => {
-    const result = await $`bun run ${CLI} --version`.text();
-    expect(result.trim()).toMatch(/^bun-sticky v\d+\.\d+\.\d+$/);
-  });
-
-  test("T4.02 - help shows all commands", async () => {
-    const result = await $`bun run ${CLI} help`.text();
-    expect(result).toContain("score");
-    expect(result).toContain("init");
-    expect(result).toContain("sync");
-    expect(result).toContain("version");
-    expect(result).toContain("help");
-  });
-
-  test("T4.03 - unknown command shows help", async () => {
-    const result = await $`bun run ${CLI} unknown`.text();
-    expect(result).toContain("Commands");
-  });
-
-  test("T4.04 - Banner shows Bun Sticky", async () => {
-    const result = await $`bun run ${CLI} help`.text();
-    expect(result).toContain("Bun Sticky");
-    expect(result).toContain("🥐");
-  });
-
-  test("T4.05 - Banner shows tagline", async () => {
-    const result = await $`bun run ${CLI} help`.text();
-    expect(result).toContain("Fastest bun under the sum");
-  });
-
-  // ★ test.each() - Flag variants
-  test.each(["--version", "-v", "version"])(
-    "T4.06 - '%s' returns version",
-    async (flag) => {
-      const result = await $`bun run ${CLI} ${flag}`.text();
-      expect(result).toContain("bun-sticky v");
-    }
-  );
-
-  test.each(["--help", "-h", "help"])(
-    "T4.07 - '%s' shows help",
-    async (flag) => {
-      const result = await $`bun run ${CLI} ${flag}`.text();
-      expect(result).toContain("Commands");
-    }
-  );
-
-  test("T4.08 - Score shows project name", async () => {
-    const result = await $`bun run ${CLI} score`.text();
-    expect(result).toContain("Project:");
-  });
-
-  test("T4.09 - Score shows type", async () => {
-    const result = await $`bun run ${CLI} score`.text();
-    expect(result).toContain("Type:");
-  });
-
-  test("T4.10 - Score shows percentage", async () => {
-    const result = await $`bun run ${CLI} score`.text();
-    expect(result).toMatch(/\d+%/);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 5: FILE OPERATIONS (10%)
-// Bun.file() must work
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 5: File Operations", () => {
-  const TEST_DIR = "/tmp/bun-sticky-test-" + Date.now();
-
-  beforeAll(async () => {
-    await $`mkdir -p ${TEST_DIR}`;
-  });
-
-  afterAll(async () => {
-    await $`rm -rf ${TEST_DIR}`;
-  });
-
-  test("T5.01 - Init creates project.faf", async () => {
-    await $`cd ${TEST_DIR} && bun run ${process.cwd()}/index.ts init test-project`;
-    const file = Bun.file(`${TEST_DIR}/project.faf`);
-    expect(await file.exists()).toBe(true);
-  });
-
-  test("T5.02 - Init includes project name", async () => {
-    const content = await Bun.file(`${TEST_DIR}/project.faf`).text();
-    expect(content).toContain("test-project");
-  });
-
-  test("T5.03 - Init includes faf_version", async () => {
-    const content = await Bun.file(`${TEST_DIR}/project.faf`).text();
-    expect(content).toContain("faf_version:");
-  });
-
-  test("T5.04 - Sync creates CLAUDE.md", async () => {
-    await $`cd ${TEST_DIR} && bun run ${process.cwd()}/index.ts sync`;
-    const file = Bun.file(`${TEST_DIR}/CLAUDE.md`);
-    expect(await file.exists()).toBe(true);
-  });
-
-  test("T5.05 - CLAUDE.md contains project name", async () => {
-    const content = await Bun.file(`${TEST_DIR}/CLAUDE.md`).text();
-    expect(content).toContain("test-project");
-  });
-
-  test("T5.06 - CLAUDE.md contains score", async () => {
-    const content = await Bun.file(`${TEST_DIR}/CLAUDE.md`).text();
-    expect(content).toMatch(/\d+%/);
-  });
-
-  test("T5.07 - Bun.file() size check", async () => {
-    const file = Bun.file(`${TEST_DIR}/project.faf`);
-    expect(file.size).toBeGreaterThan(0);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 6: PERFORMANCE (10%)
-// Speed is the mission
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 6: Performance", () => {
-  test("T6.01 - Cold start under 50ms", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts --version`.quiet();
-    const elapsed = performance.now() - start;
-    expect(elapsed).toBeLessThan(50);
-  });
-
-  test("T6.02 - Score command under 100ms", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts score`.quiet();
-    const elapsed = performance.now() - start;
-    expect(elapsed).toBeLessThan(100);
-  });
-
-  test("T6.03 - Help under 50ms", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts help`.quiet();
-    const elapsed = performance.now() - start;
-    expect(elapsed).toBeLessThan(50);
-  });
-
-  test("T6.04 - 10x faster than 334ms Node baseline", async () => {
-    const NODE_BASELINE = 334;
-    const TARGET = NODE_BASELINE / 10 + 20; // 53.4ms with generous margin
-
-    const start = performance.now();
-    await $`bun run ./index.ts score`.quiet();
-    const elapsed = performance.now() - start;
-
-    expect(elapsed).toBeLessThan(TARGET);
-  });
-
-  // ★ test.concurrent() - Parallel execution
-  test.concurrent("T6.05 - Concurrent: version", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts --version`.quiet();
-    expect(performance.now() - start).toBeLessThan(100);
-  });
-
-  test.concurrent("T6.06 - Concurrent: help", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts help`.quiet();
-    expect(performance.now() - start).toBeLessThan(100);
-  });
-
-  test.concurrent("T6.07 - Concurrent: score", async () => {
-    const start = performance.now();
-    await $`bun run ./index.ts score`.quiet();
-    expect(performance.now() - start).toBeLessThan(100);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 7: WJTTC CHAMPIONSHIP (5%)
-// The championship extras
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 7: WJTTC Championship", () => {
-  test("T7.01 - Zero dependencies", async () => {
-    const pkg = await Bun.file("./package.json").json();
-    const deps = Object.keys(pkg.dependencies || {});
-    expect(deps.length).toBe(0);
-  });
-
-  test("T7.02 - Pure Bun APIs only", async () => {
-    const content = await Bun.file("./index.ts").text();
-    expect(content).not.toContain("require(");
-    expect(content).not.toContain("from 'fs'");
-    expect(content).not.toContain("from 'path'");
-  });
-
-  test("T7.03 - TypeScript native (no build step)", async () => {
-    const files = await $`ls *.ts`.text();
-    expect(files).toContain("index.ts");
-    const hasDist = await Bun.file("./dist").exists();
-    expect(hasDist).toBe(false);
-  });
-
-  test("T7.04 - Single entry point", async () => {
-    const pkg = await Bun.file("./package.json").json();
-    expect(pkg.main).toBe("index.ts");
-  });
-
-  test("T7.05 - Croissant branding present", async () => {
-    const content = await Bun.file("./index.ts").text();
-    expect(content).toContain("🥐");
-    expect(content).toContain("Bun Sticky");
-    expect(content).toContain("Fastest bun under the sum");
-  });
-
-  test("T7.06 - Package.json metadata", async () => {
-    const pkg = await Bun.file("./package.json").json();
-    expect(pkg.name).toBe("bun-sticky");
-    expect(pkg.type).toBe("module");
-    expect(pkg).toHaveProperty("bin");
-  });
-
-  test("T7.07 - Wolfejam scoring (NOT Elon weights)", async () => {
-    const content = await Bun.file("./lib/scorer.ts").text();
-    expect(content).toContain("SLOTS");
-    expect(content).not.toContain("0.40");
-    expect(content).not.toContain("0.35");
-    expect(content).not.toContain("0.15");
-    expect(content).not.toContain("0.10");
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 8: MOCKING & SPYING
-// Advanced Bun test features
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 8: Mocking & Spying", () => {
-  test("T8.01 - Mock function tracks calls", () => {
-    const mockFn = mock(() => 42);
-    mockFn();
-    mockFn();
-    mockFn();
-    expect(mockFn).toHaveBeenCalledTimes(3);
-  });
-
-  test("T8.02 - Mock function returns value", () => {
-    const mockFn = mock(() => "mocked");
-    expect(mockFn()).toBe("mocked");
-  });
-
-  test("T8.03 - Mock with implementation", () => {
-    const mockFn = mock((x: number) => x * 2);
-    expect(mockFn(5)).toBe(10);
-    expect(mockFn).toHaveBeenCalledWith(5);
-  });
-
-  test("T8.04 - Mock tracks arguments", () => {
-    const mockFn = mock((a: string, b: number) => `${a}${b}`);
-    mockFn("test", 123);
-    expect(mockFn).toHaveBeenCalledWith("test", 123);
-  });
-
-  test("T8.05 - Mock reset", () => {
-    const mockFn = mock(() => 1);
-    mockFn();
-    mockFn();
-    expect(mockFn).toHaveBeenCalledTimes(2);
-    mockFn.mockClear();
-    expect(mockFn).toHaveBeenCalledTimes(0);
-  });
-
-  test("T8.06 - Spy on console.log", () => {
-    const spy = spyOn(console, "log").mockImplementation(() => {});
-    console.log("test message");
-    expect(spy).toHaveBeenCalledWith("test message");
-    spy.mockRestore();
-  });
-
-  test("T8.07 - Spy on console.error", () => {
-    const spy = spyOn(console, "error").mockImplementation(() => {});
-    console.error("error message");
-    expect(spy).toHaveBeenCalledWith("error message");
-    spy.mockRestore();
-  });
-
-  test("T8.08 - Mock implementation change", () => {
-    const mockFn = mock(() => 1);
-    expect(mockFn()).toBe(1);
-    mockFn.mockImplementation(() => 2);
-    expect(mockFn()).toBe(2);
-  });
-
-  test("T8.09 - Mock return value", () => {
-    const mockFn = mock(() => 0);
-    mockFn.mockReturnValue(42);
-    expect(mockFn()).toBe(42);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 9: TIME MOCKING
-// setSystemTime() - Control time itself
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 9: Time Mocking", () => {
-  afterEach(() => {
-    setSystemTime(); // Reset to real time
-  });
-
-  test("T9.01 - setSystemTime() freezes time", () => {
-    const fixedDate = new Date("2025-01-01T00:00:00Z");
-    setSystemTime(fixedDate);
-    expect(new Date().getTime()).toBe(fixedDate.getTime());
-  });
-
-  test("T9.02 - Time can be set to any date", () => {
-    const past = new Date("2000-01-01T00:00:00Z");
-    setSystemTime(past);
-    expect(new Date().getFullYear()).toBe(2000);
-  });
-
-  test("T9.03 - Date.now() respects mocked time", () => {
-    const fixed = new Date("2025-06-15T12:00:00Z");
-    setSystemTime(fixed);
-    expect(Date.now()).toBe(fixed.getTime());
-  });
-
-  test("T9.04 - Reset to real time", () => {
-    setSystemTime(new Date("1999-01-01"));
-    setSystemTime(); // Reset
-    expect(new Date().getFullYear()).toBeGreaterThanOrEqual(2024);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 10: EXTENDED MATCHERS
-// Full matcher coverage - 40+ matchers
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 10: Extended Matchers", () => {
-  // Equality
-  test("T10.01 - toBe", () => {
-    expect(1).toBe(1);
-    expect("a").toBe("a");
-  });
-
-  test("T10.02 - toEqual", () => {
-    expect({ a: 1 }).toEqual({ a: 1 });
-    expect([1, 2]).toEqual([1, 2]);
-  });
-
-  test("T10.03 - toStrictEqual", () => {
-    expect({ a: 1 }).toStrictEqual({ a: 1 });
-  });
-
-  // Truthiness
-  test("T10.04 - toBeTruthy / toBeFalsy", () => {
-    expect(1).toBeTruthy();
-    expect("a").toBeTruthy();
-    expect(0).toBeFalsy();
-    expect("").toBeFalsy();
-  });
-
-  test("T10.05 - toBeNull / toBeUndefined / toBeDefined", () => {
-    expect(null).toBeNull();
-    expect(undefined).toBeUndefined();
-    expect(1).toBeDefined();
-  });
-
-  test("T10.06 - toBeNaN", () => {
-    expect(NaN).toBeNaN();
-    expect(0 / 0).toBeNaN();
-  });
-
-  // Numbers
-  test("T10.07 - toBeGreaterThan / toBeLessThan", () => {
-    expect(10).toBeGreaterThan(5);
-    expect(5).toBeLessThan(10);
-  });
-
-  test("T10.08 - toBeGreaterThanOrEqual / toBeLessThanOrEqual", () => {
-    expect(10).toBeGreaterThanOrEqual(10);
-    expect(10).toBeLessThanOrEqual(10);
-  });
-
-  test("T10.09 - toBeCloseTo", () => {
-    expect(0.1 + 0.2).toBeCloseTo(0.3, 5);
-  });
-
-  // Strings
-  test("T10.10 - toContain (string)", () => {
-    expect("hello world").toContain("world");
-  });
-
-  test("T10.11 - toMatch (regex)", () => {
-    expect("hello world").toMatch(/world/);
-    expect("test123").toMatch(/\d+/);
-  });
-
-  test("T10.12 - toStartWith / toEndWith", () => {
-    expect("hello world").toStartWith("hello");
-    expect("hello world").toEndWith("world");
-  });
-
-  // Arrays
-  test("T10.13 - toContain (array)", () => {
-    expect([1, 2, 3]).toContain(2);
-  });
-
-  test("T10.14 - toContainEqual", () => {
-    expect([{ a: 1 }, { b: 2 }]).toContainEqual({ a: 1 });
-  });
-
-  test("T10.15 - toHaveLength", () => {
-    expect([1, 2, 3]).toHaveLength(3);
-    expect("hello").toHaveLength(5);
-  });
-
-  // Objects
-  test("T10.16 - toHaveProperty", () => {
-    expect({ a: { b: 1 } }).toHaveProperty("a.b", 1);
-  });
-
-  test("T10.17 - toMatchObject", () => {
-    expect({ a: 1, b: 2 }).toMatchObject({ a: 1 });
-  });
-
-  // Types
-  test("T10.18 - toBeInstanceOf", () => {
-    expect([]).toBeInstanceOf(Array);
-    expect(new Date()).toBeInstanceOf(Date);
-  });
-
-  test("T10.19 - toBeTypeOf", () => {
-    expect("hello").toBeTypeOf("string");
-    expect(123).toBeTypeOf("number");
-    expect({}).toBeTypeOf("object");
-  });
-
-  // Errors
-  test("T10.20 - toThrow", () => {
-    expect(() => {
-      throw new Error("test");
-    }).toThrow();
-    expect(() => {
-      throw new Error("test");
-    }).toThrow("test");
-  });
-
-  test("T10.21 - toThrowError", () => {
-    expect(() => {
-      throw new TypeError("type error");
-    }).toThrowError(TypeError);
-  });
-
-  // Negation
-  test("T10.22 - .not modifier", () => {
-    expect(1).not.toBe(2);
-    expect([1, 2]).not.toContain(3);
-    expect("hello").not.toMatch(/xyz/);
-  });
-
-  // Async
-  test("T10.23 - resolves", async () => {
-    await expect(Promise.resolve(1)).resolves.toBe(1);
-  });
-
-  test("T10.24 - rejects", async () => {
-    await expect(Promise.reject(new Error("fail"))).rejects.toThrow("fail");
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 11: LIFECYCLE HOOKS
-// beforeEach / afterEach isolation
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 11: Lifecycle Hooks", () => {
-  let counter = 0;
-  let setupRan = false;
-
-  beforeAll(() => {
-    setupRan = true;
-  });
-
-  beforeEach(() => {
-    counter = 0;
-  });
-
-  afterEach(() => {
-    // Cleanup
-  });
-
-  afterAll(() => {
-    // Final cleanup
-  });
-
-  test("T11.01 - beforeAll ran", () => {
-    expect(setupRan).toBe(true);
-  });
-
-  test("T11.02 - Counter starts at 0", () => {
-    expect(counter).toBe(0);
-    counter++;
-    expect(counter).toBe(1);
-  });
-
-  test("T11.03 - Counter reset by beforeEach", () => {
-    expect(counter).toBe(0);
-  });
-
-  test("T11.04 - Each test isolated", () => {
-    counter = 100;
-    expect(counter).toBe(100);
-  });
-
-  test("T11.05 - Previous test doesn't affect this", () => {
-    expect(counter).toBe(0);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 12: ASYNC & PROMISE TESTING
-// Comprehensive async patterns
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 12: Async & Promise Testing", () => {
-  test("T12.01 - Async/await test", async () => {
-    const result = await Promise.resolve(42);
-    expect(result).toBe(42);
-  });
-
-  test("T12.02 - Promise.all", async () => {
-    const results = await Promise.all([
-      Promise.resolve(1),
-      Promise.resolve(2),
-      Promise.resolve(3),
-    ]);
-    expect(results).toEqual([1, 2, 3]);
-  });
-
-  test("T12.03 - Promise.race", async () => {
-    const result = await Promise.race([
-      Promise.resolve("fast"),
-      new Promise((r) => setTimeout(() => r("slow"), 100)),
-    ]);
-    expect(result).toBe("fast");
-  });
-
-  test("T12.04 - Async function returning value", async () => {
-    const asyncFn = async () => {
-      return "async result";
-    };
-    expect(await asyncFn()).toBe("async result");
-  });
-
-  test("T12.05 - expect().resolves", async () => {
-    const promise = Promise.resolve({ data: "test" });
-    await expect(promise).resolves.toEqual({ data: "test" });
-  });
-
-  test("T12.06 - expect().rejects", async () => {
-    const promise = Promise.reject(new Error("rejected"));
-    await expect(promise).rejects.toThrow("rejected");
-  });
-
-  test("T12.07 - Async with timeout", async () => {
-    const delayed = () =>
-      new Promise((r) => setTimeout(() => r("done"), 10));
-    const result = await delayed();
-    expect(result).toBe("done");
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 13: CONDITIONAL TESTS
-// test.if() / test.skipIf()
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 13: Conditional Tests", () => {
-  const isMac = process.platform === "darwin";
-  const isLinux = process.platform === "linux";
-  const isWindows = process.platform === "win32";
-  const isBun = typeof Bun !== "undefined";
-
-  // ★ test.if() - Run if condition true
-  test.if(isBun)("T13.01 - Runs only in Bun", () => {
-    expect(Bun.version).toBeDefined();
-  });
-
-  test.if(isMac)("T13.02 - Runs only on macOS", () => {
-    expect(process.platform).toBe("darwin");
-  });
-
-  // ★ test.skipIf() - Skip if condition true
-  test.skipIf(isWindows)("T13.03 - Skip on Windows", () => {
-    expect(process.platform).not.toBe("win32");
-  });
-
-  test.skipIf(!isBun)("T13.04 - Skip if not Bun", () => {
-    expect(typeof Bun).toBe("object");
-  });
-
-  test.if(true)("T13.05 - Always runs (condition true)", () => {
-    expect(true).toBe(true);
-  });
-
-  test.skipIf(false)("T13.06 - Never skips (condition false)", () => {
-    expect(true).toBe(true);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 14: TODO, SKIP, FAILING
-// Incomplete and expected-to-fail tests
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 14: Todo, Skip, Failing", () => {
-  // ★ test.todo() - Future work
-  test.todo("T14.01 - TODO: Add YAML multiline support");
-  test.todo("T14.02 - TODO: Add watch mode");
-  test.todo("T14.03 - TODO: Add JSON output format");
-  test.todo("T14.04 - TODO: Add diff command");
-
-  // ★ test.skip() - Skip test
-  test.skip("T14.05 - SKIP: Platform-specific", () => {
-    expect(true).toBe(false);
-  });
-
-  // ★ test.failing() - Expected to fail
-  test.failing("T14.06 - FAILING: This test is expected to fail", () => {
-    expect(1).toBe(2); // Intentionally wrong
-  });
-
-  test.failing("T14.07 - FAILING: Division by zero check", () => {
-    expect(1 / 0).toBe(0); // Infinity, not 0
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 15: STRESS TESTING
-// Push the limits
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 15: Stress Testing", () => {
-  test("T15.01 - 1000 assertions in single test", () => {
-    for (let i = 0; i < 1000; i++) {
-      expect(i).toBeGreaterThanOrEqual(0);
-    }
-  });
-
-  test("T15.02 - Large object comparison", () => {
-    const large: Record<string, number> = {};
-    for (let i = 0; i < 100; i++) {
-      large[`key${i}`] = i;
-    }
-    expect(Object.keys(large).length).toBe(100);
-  });
-
-  test("T15.03 - Deep nesting", () => {
-    let obj: any = { value: "deep" };
-    for (let i = 0; i < 50; i++) {
-      obj = { nested: obj };
-    }
-    let current = obj;
-    for (let i = 0; i < 50; i++) {
-      current = current.nested;
-    }
-    expect(current.value).toBe("deep");
-  });
-
-  test("T15.04 - Rapid mock calls", () => {
-    const mockFn = mock(() => 1);
-    for (let i = 0; i < 1000; i++) {
-      mockFn();
-    }
-    expect(mockFn).toHaveBeenCalledTimes(1000);
-  });
-
-  test("T15.05 - String operations", () => {
-    let str = "";
-    for (let i = 0; i < 1000; i++) {
-      str += "a";
-    }
-    expect(str.length).toBe(1000);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// TIER 16: EDGE CASES
-// Break it so it never breaks again
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Tier 16: Edge Cases", () => {
-  test("T16.01 - Empty string handling", async () => {
-    const { hasValue } = await import("../lib/parser.ts");
-    expect(hasValue({ v: "" }, "v")).toBe(false);
-  });
-
-  test("T16.02 - Null handling", async () => {
-    const { getNestedValue } = await import("../lib/parser.ts");
-    expect(getNestedValue({ a: null }, "a.b")).toBeUndefined();
-  });
-
-  test("T16.03 - Undefined handling", async () => {
-    const { hasValue } = await import("../lib/parser.ts");
-    expect(hasValue({}, "missing")).toBe(false);
-  });
-
-  test("T16.04 - Zero score", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const result = calculateScore({});
-    expect(result.score).toBe(0);
-  });
-
-  test("T16.05 - Unknown type defaults to 9 slots", async () => {
-    const { calculateScore } = await import("../lib/scorer.ts");
-    const result = calculateScore({ project: { type: "banana" } });
-    expect(result.total).toBe(9);
-  });
-
-  test("T16.06 - Special characters in name", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const result = parseYaml("name: test-project_v1.0");
-    expect(result.name).toBe("test-project_v1.0");
-  });
-
-  test("T16.07 - Unicode in values", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const result = parseYaml("emoji: 🥐");
-    expect(result.emoji).toBe("🥐");
-  });
-
-  test("T16.08 - Very long value", async () => {
-    const { parseYaml } = await import("../lib/parser.ts");
-    const longValue = "a".repeat(1000);
-    const result = parseYaml(`long: ${longValue}`);
-    expect((result.long as string).length).toBe(1000);
-  });
-});
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// CHAMPIONSHIP SUMMARY
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-describe("Championship Summary", () => {
-  test("Print WJTTC Championship Report", () => {
-    console.log(`
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🥐 BUN STICKY - WJTTC CHAMPIONSHIP TEST SUITE 🥐
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-THE BEST BUN TEST SUITE IN THE AI ERA
-"We break it so they never know it was ever broken"
-
-TIER  0: META TESTING         - 12 tests  (Test the tests)
-TIER  1: Core Parsing         - 11 tests  (20%)
-TIER  2: Scoring Engine       - 15 tests  (25%)
-TIER  3: Tier System          - 20 tests  (15%)
-TIER  4: CLI Commands         - 10 tests  (15%)
-TIER  5: File Operations      -  7 tests  (10%)
-TIER  6: Performance          -  7 tests  (10%)
-TIER  7: WJTTC Championship   -  7 tests  (5%)
-TIER  8: Mocking & Spying     -  9 tests
-TIER  9: Time Mocking         -  4 tests
-TIER 10: Extended Matchers    - 24 tests  (40+ matchers)
-TIER 11: Lifecycle Hooks      -  5 tests
-TIER 12: Async & Promise      -  7 tests
-TIER 13: Conditional Tests    -  6 tests
-TIER 14: Todo, Skip, Failing  -  7 tests
-TIER 15: Stress Testing       -  5 tests
-TIER 16: Edge Cases           -  8 tests
-
-BUN TEST API COVERAGE - NO SHORTCUTS:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✓ test() / describe()
-✓ test.each() / describe.each()
-✓ test.concurrent()
-✓ test.todo() / test.skip()
-✓ test.if() / test.skipIf()
-✓ test.failing()
-✓ beforeAll() / afterAll()
-✓ beforeEach() / afterEach()
-✓ mock() / spyOn()
-✓ mockImplementation() / mockReturnValue() / mockClear()
-✓ setSystemTime()
-✓ expect.assertions() / expect.hasAssertions()
-✓ expect.extend() - Custom matchers
-✓ toMatchSnapshot()
-✓ All 40+ matchers
-✓ .resolves / .rejects
-✓ .not modifier
-
-CUSTOM MATCHERS:
-━━━━━━━━━━━━━━━━━
-✓ toBeValidScore()
-✓ toBeValidTier()
-✓ toHaveSlotCount()
-
-TOTAL: 164 tests (4 todo, 1 skip, 2 failing)
-
-Wolfejam slot-based scoring.
-Fastest bun under the sum.
-Zero dependencies. Pure Bun.
-FULL BUN + WJTTC = BEST IN AI ERA.
-NO COMPROMISE.
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-`);
-    expect(true).toBe(true);
-  });
-});