test: add 100% coverage for apps/api and packages/types

Adds full Vitest test suites with @vitest/coverage-v8, targeting 100%
statement/branch/function/line coverage. Uses v8 ignore comments for
genuinely unreachable defensive branches.

apps/api/test/services/transcendence.spec.ts

@@ -0,0 +1,171 @@
+/* eslint-disable max-lines-per-function -- Test suites naturally have many cases */
+/* eslint-disable @typescript-eslint/consistent-type-assertions -- Tests build minimal state objects */
+import { describe, expect, it } from "vitest";
+import {
+  buildPostTranscendenceState,
+  calculateEchoes,
+  computeTranscendenceMultipliers,
+  isEligibleForTranscendence,
+} from "../../src/services/transcendence.js";
+import type { GameState } from "@elysium/types";
+
+const makeMinimalState = (overrides: Partial<GameState> = {}): GameState =>
+  ({
+    player: { discordId: "t", username: "u", discriminator: "0", avatar: null, totalGoldEarned: 0, totalClicks: 0, characterName: "T" },
+    resources: { gold: 0, essence: 0, crystals: 0, runestones: 0 },
+    adventurers: [],
+    upgrades: [],
+    quests: [],
+    bosses: [],
+    equipment: [],
+    achievements: [],
+    zones: [],
+    exploration: { areas: [], materials: [], craftedRecipeIds: [], craftedGoldMultiplier: 1, craftedEssenceMultiplier: 1, craftedClickMultiplier: 1, craftedCombatMultiplier: 1 },
+    companions: { unlockedCompanionIds: [], activeCompanionId: null },
+    prestige: { count: 0, runestones: 0, productionMultiplier: 1, purchasedUpgradeIds: [] },
+    baseClickPower: 1,
+    lastTickAt: 0,
+    schemaVersion: 1,
+    ...overrides,
+  } as GameState);
+
+describe("computeTranscendenceMultipliers", () => {
+  it("returns all 1s with empty ids", () => {
+    const result = computeTranscendenceMultipliers([]);
+    expect(result.echoIncomeMultiplier).toBe(1);
+    expect(result.echoCombatMultiplier).toBe(1);
+    expect(result.echoPrestigeThresholdMultiplier).toBe(1);
+    expect(result.echoPrestigeRunestoneMultiplier).toBe(1);
+    expect(result.echoMetaMultiplier).toBe(1);
+  });
+
+  it("applies income upgrade when purchased", () => {
+    const result = computeTranscendenceMultipliers(["echo_income_1"]);
+    expect(result.echoIncomeMultiplier).toBeGreaterThan(1);
+    expect(result.echoCombatMultiplier).toBe(1);
+  });
+
+  it("applies combat upgrade when purchased", () => {
+    const result = computeTranscendenceMultipliers(["echo_combat_1"]);
+    expect(result.echoCombatMultiplier).toBeGreaterThan(1);
+    expect(result.echoIncomeMultiplier).toBe(1);
+  });
+
+  it("applies prestige_threshold upgrade when purchased", () => {
+    const result = computeTranscendenceMultipliers(["echo_prestige_threshold_1"]);
+    expect(result.echoPrestigeThresholdMultiplier).not.toBe(1);
+  });
+
+  it("applies prestige_runestones upgrade when purchased", () => {
+    const result = computeTranscendenceMultipliers(["echo_prestige_runestones_1"]);
+    expect(result.echoPrestigeRunestoneMultiplier).toBeGreaterThan(1);
+  });
+
+  it("applies echo_meta upgrade when purchased", () => {
+    const result = computeTranscendenceMultipliers(["echo_meta_1"]);
+    expect(result.echoMetaMultiplier).toBeGreaterThan(1);
+  });
+});
+
+describe("isEligibleForTranscendence", () => {
+  it("returns true when final boss is defeated", () => {
+    const state = makeMinimalState({
+      bosses: [{ id: "the_absolute_one", status: "defeated" }] as GameState["bosses"],
+    });
+    expect(isEligibleForTranscendence(state)).toBe(true);
+  });
+
+  it("returns false when final boss is available but not defeated", () => {
+    const state = makeMinimalState({
+      bosses: [{ id: "the_absolute_one", status: "available" }] as GameState["bosses"],
+    });
+    expect(isEligibleForTranscendence(state)).toBe(false);
+  });
+
+  it("returns false when final boss is not in the list", () => {
+    const state = makeMinimalState({ bosses: [] });
+    expect(isEligibleForTranscendence(state)).toBe(false);
+  });
+
+  it("returns false when a different boss is defeated", () => {
+    const state = makeMinimalState({
+      bosses: [{ id: "some_other_boss", status: "defeated" }] as GameState["bosses"],
+    });
+    expect(isEligibleForTranscendence(state)).toBe(false);
+  });
+});
+
+describe("calculateEchoes", () => {
+  it("handles prestige count of 0 by treating it as 1", () => {
+    // safeCount = max(0, 1) = 1; floor(853 / sqrt(1)) = 853
+    expect(calculateEchoes(0, 1)).toBe(853);
+  });
+
+  it("calculates echoes at count 1", () => {
+    expect(calculateEchoes(1, 1)).toBe(853);
+  });
+
+  it("decreases echoes with higher prestige count", () => {
+    const echoesAt1 = calculateEchoes(1, 1);
+    const echoesAt4 = calculateEchoes(4, 1);
+    expect(echoesAt4).toBeLessThan(echoesAt1);
+    // floor(853 / sqrt(4)) = floor(853 / 2) = 426
+    expect(echoesAt4).toBe(426);
+  });
+
+  it("applies echoMetaMultiplier", () => {
+    const base = calculateEchoes(1, 1);
+    const withMult = calculateEchoes(1, 2);
+    expect(withMult).toBe(base * 2);
+  });
+});
+
+describe("buildPostTranscendenceState", () => {
+  it("increments transcendence count from 0", () => {
+    const state = makeMinimalState();
+    const { newTranscendenceData } = buildPostTranscendenceState(state, "T");
+    expect(newTranscendenceData.count).toBe(1);
+  });
+
+  it("accumulates echoes", () => {
+    const state = makeMinimalState({
+      transcendence: {
+        count: 1, echoes: 100, purchasedUpgradeIds: [],
+        echoIncomeMultiplier: 1, echoCombatMultiplier: 1,
+        echoPrestigeThresholdMultiplier: 1, echoPrestigeRunestoneMultiplier: 1, echoMetaMultiplier: 1,
+      },
+    });
+    const { newTranscendenceData, echoesEarned } = buildPostTranscendenceState(state, "T");
+    expect(newTranscendenceData.echoes).toBe(100 + echoesEarned);
+  });
+
+  it("persists codex from current state", () => {
+    const codex = { entries: [{ id: "e1", unlockedAt: 1000, sourceType: "exploration" as const }] };
+    const state = makeMinimalState({ codex });
+    const { newState } = buildPostTranscendenceState(state, "T");
+    expect(newState.codex).toEqual(codex);
+  });
+
+  it("persists story from current state", () => {
+    const story = { unlockedChapterIds: ["ch1"], completedChapters: [] };
+    const state = makeMinimalState({ story });
+    const { newState } = buildPostTranscendenceState(state, "T");
+    expect(newState.story).toEqual(story);
+  });
+
+  it("persists apotheosis from current state", () => {
+    const apotheosis = { count: 2 };
+    const state = makeMinimalState({ apotheosis });
+    const { newState } = buildPostTranscendenceState(state, "T");
+    expect(newState.apotheosis).toEqual(apotheosis);
+  });
+
+  it("resets prestige to fresh state", () => {
+    const state = makeMinimalState({
+      prestige: { count: 5, runestones: 500, productionMultiplier: 2, purchasedUpgradeIds: [] },
+    });
+    const { newState } = buildPostTranscendenceState(state, "T");
+    expect(newState.prestige.count).toBe(0);
+    expect(newState.prestige.runestones).toBe(0);
+  });
+});