deck validation pt5

src/lib/__tests__/test-cards.json

···
 	"Inspiring Vantage": "3f17c60e-923a-4392-9da8-87d9ded009b7",
 	"Jace, Vryn's Prodigy": "594f6881-c059-46f8-aa4e-7151d502de73",
 	"Karlach, Raging Tiefling": "f40ddd57-ad75-477c-bfe6-1b0ca68b88b6",
+	"Keruga, the Macrosage": "ca5121b2-e6d9-40bc-a2d2-05852c4efbe8",
 	"Ketria Triome": "6bae00e8-06cf-4ac4-a1cc-757e454109fe",
 	"Lightning Bolt": "4457ed35-7c10-48c8-9776-456485fdf070",
 	"Lion's Eye Diamond": "ee6099b0-fb1f-42f1-b862-7708c6e36d05",
···
 	"Tymna the Weaver": "d15642e4-e61c-4d29-af48-de837991245e",
 	"Undercity Sewers": "08d80efc-9542-4ba2-824c-c8615d8d07f2",
 	"Underground Sea": "4b22be3a-8ce1-47d1-b82e-6c3ccfb0548b",
+	"Valki, God of Lies": "907ae517-22d5-4ac7-bc3a-3f4d5eaeeb57",
 	"Vault Skirge": "64cf5d59-7bcd-4b0b-a160-c8468d4c0f60",
 	"Wall of Shards": "8fab68ad-169d-46d3-93c4-5bdee4eea2ce",
 	"Wastes": "05d24b0c-904a-46b6-b42a-96a4d91a0dd4",

src/lib/deck-validation/__tests__/companion.test.ts

···
 } from "@/lib/__tests__/test-card-lookup";
 import type { Deck, DeckCard, Section } from "@/lib/deck-types";
 import type { Card, OracleId, ScryfallId } from "@/lib/scryfall-types";
-import { companionRule } from "../rules/base";
+import { companionRule } from "../rules/companion";
 import type { ValidationContext } from "../types";
 
 describe("companion rules", () => {
···
 				makeCard(solRing, "mainboard"),
 			]);
 			const ctx = makeContext(deck, [lurrus, solRing]);
+			const violations = companionRule.validate(ctx);
+			expect(violations).toHaveLength(0);
+		});
+	});
+
+	describe("Keruga, the Macrosage", () => {
+		it("rejects deck with low MV creatures", async () => {
+			const keruga = await cards.get("Keruga, the Macrosage");
+			const solRing = await cards.get("Sol Ring");
+			const deck = makeDeck([
+				makeCard(keruga, "sideboard"),
+				makeCard(solRing, "mainboard"),
+			]);
+			const ctx = makeContext(deck, [keruga, solRing]);
+			const violations = companionRule.validate(ctx);
+			expect(violations).toHaveLength(0);
+		});
+
+		it("rejects MDFC creature with MV < 3 front face", async () => {
+			const keruga = await cards.get("Keruga, the Macrosage");
+			const valki = await cards.get("Valki, God of Lies");
+			const deck = makeDeck([
+				makeCard(keruga, "sideboard"),
+				makeCard(valki, "mainboard"),
+			]);
+			const ctx = makeContext(deck, [keruga, valki]);
+			const violations = companionRule.validate(ctx);
+			expect(violations).toHaveLength(1);
+			expect(violations[0].message).toContain("Keruga");
+			expect(violations[0].message).toContain("mana value");
+		});
+
+		it("allows deck with only MV 3+ creatures", async () => {
+			const keruga = await cards.get("Keruga, the Macrosage");
+			const selvala = await cards.get("Selvala, Heart of the Wilds");
+			const deck = makeDeck([
+				makeCard(keruga, "sideboard"),
+				makeCard(selvala, "mainboard"),
+			]);
+			const ctx = makeContext(deck, [keruga, selvala]);
+			const violations = companionRule.validate(ctx);
+			expect(violations).toHaveLength(0);
+		});
+	});
+
+	describe("no companion in sideboard", () => {
+		it("passes when no companion is present", async () => {
+			const solRing = await cards.get("Sol Ring");
+			const selvala = await cards.get("Selvala, Heart of the Wilds");
+			const deck = makeDeck([
+				makeCard(solRing, "sideboard"),
+				makeCard(selvala, "mainboard"),
+			]);
+			const ctx = makeContext(deck, [solRing, selvala]);
 			const violations = companionRule.validate(ctx);
 			expect(violations).toHaveLength(0);
 		});

src/lib/deck-validation/rules/companion.ts

···
+import { getCardsInSection } from "@/lib/deck-types";
+import type { Card } from "@/lib/scryfall-types";
+import {
+	asRuleNumber,
+	type Rule,
+	type ValidationContext,
+	type Violation,
+	violation,
+} from "../types";
+
+/**
+ * Companion rule - validates deck meets companion's deck-building restriction
+ *
+ * Companions go in sideboard. If a card has the Companion keyword,
+ * the deck must satisfy its specific restriction.
+ *
+ * Rule 702.139: Companion is a keyword ability that imposes a deck-building
+ * restriction on cards in your starting deck.
+ */
+export const companionRule: Rule<"companion"> = {
+	id: "companion",
+	rule: asRuleNumber("702.139"),
+	category: "structure",
+	description: "Deck must meet companion's deck-building restriction",
+	validate(ctx: ValidationContext): Violation[] {
+		const { deck, cardLookup } = ctx;
+		const violations: Violation[] = [];
+
+		const sideboard = getCardsInSection(deck, "sideboard");
+
+		for (const entry of sideboard) {
+			const card = cardLookup(entry.scryfallId);
+			if (!card) continue;
+
+			const keywords = card.keywords?.map((k) => k.toLowerCase()) ?? [];
+			if (!keywords.includes("companion")) continue;
+
+			const companionViolations = validateCompanionRestriction(card, ctx);
+			violations.push(...companionViolations);
+		}
+
+		return violations;
+	},
+};
+
+function validateCompanionRestriction(
+	companion: Card,
+	ctx: ValidationContext,
+): Violation[] {
+	const name = companion.name.toLowerCase();
+
+	if (name.includes("lurrus")) {
+		return validateLurrus(companion, ctx);
+	}
+	if (name.includes("gyruda")) {
+		return validateGyruda(companion, ctx);
+	}
+	if (name.includes("obosh")) {
+		return validateObosh(companion, ctx);
+	}
+	if (name.includes("kaheera")) {
+		return validateKaheera(companion, ctx);
+	}
+	if (name.includes("umori")) {
+		return validateUmori(companion, ctx);
+	}
+	if (name.includes("jegantha")) {
+		return validateJegantha(companion, ctx);
+	}
+	if (name.includes("keruga")) {
+		return validateKeruga(companion, ctx);
+	}
+	if (name.includes("yorion")) {
+		return validateYorion(companion, ctx);
+	}
+	if (name.includes("zirda")) {
+		return validateZirda(companion, ctx);
+	}
+	if (name.includes("lutri")) {
+		return validateLutri(companion, ctx);
+	}
+
+	return [];
+}
+
+function validateLurrus(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (!isPermanent(card)) continue;
+
+		const mv = card.cmc ?? 0;
+		if (mv > 2) {
+			violations.push(
+				violation(
+					companionRule,
+					`Lurrus companion requires all permanents to have mana value 2 or less, but ${card.name} has mana value ${mv}`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateGyruda(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (isLand(card)) continue;
+
+		const mv = card.cmc ?? 0;
+		if (mv % 2 !== 0) {
+			violations.push(
+				violation(
+					companionRule,
+					`Gyruda companion requires all nonland cards to have even mana value, but ${card.name} has mana value ${mv}`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateObosh(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (isLand(card)) continue;
+
+		const mv = card.cmc ?? 0;
+		if (mv % 2 === 0) {
+			violations.push(
+				violation(
+					companionRule,
+					`Obosh companion requires all nonland cards to have odd mana value, but ${card.name} has mana value ${mv}`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateKaheera(
+	_companion: Card,
+	ctx: ValidationContext,
+): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	const allowedTypes = ["cat", "elemental", "nightmare", "dinosaur", "beast"];
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		const typeLine = getTypeLine(card).toLowerCase();
+		if (!typeLine.includes("creature")) continue;
+
+		const hasAllowedType = allowedTypes.some((t) => typeLine.includes(t));
+		if (!hasAllowedType) {
+			violations.push(
+				violation(
+					companionRule,
+					`Kaheera companion requires all creatures to be Cat, Elemental, Nightmare, Dinosaur, or Beast, but ${card.name} is not`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateUmori(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	const cardTypes = [
+		"creature",
+		"artifact",
+		"enchantment",
+		"planeswalker",
+		"instant",
+		"sorcery",
+	];
+	const typePresent = new Set<string>();
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (isLand(card)) continue;
+
+		const typeLine = getTypeLine(card).toLowerCase();
+		for (const t of cardTypes) {
+			if (typeLine.includes(t)) {
+				typePresent.add(t);
+			}
+		}
+	}
+
+	if (typePresent.size > 1) {
+		return [
+			violation(
+				companionRule,
+				`Umori companion requires all nonland cards to share a card type, but deck has multiple types: ${[...typePresent].join(", ")}`,
+				"error",
+			),
+		];
+	}
+
+	return [];
+}
+
+function validateJegantha(
+	_companion: Card,
+	ctx: ValidationContext,
+): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		const manaCost = card.mana_cost ?? "";
+		if (hasRepeatedManaSymbol(manaCost)) {
+			violations.push(
+				violation(
+					companionRule,
+					`Jegantha companion requires no card to have more than one of the same mana symbol, but ${card.name} has repeated symbols in ${manaCost}`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function hasRepeatedManaSymbol(manaCost: string): boolean {
+	const symbols = manaCost.match(/\{[^}]+\}/g) ?? [];
+	const counts = new Map<string, number>();
+
+	for (const sym of symbols) {
+		const normalized = sym.toLowerCase();
+		if (normalized === "{x}") continue;
+		const current = counts.get(normalized) ?? 0;
+		counts.set(normalized, current + 1);
+	}
+
+	for (const count of counts.values()) {
+		if (count > 1) return true;
+	}
+
+	return false;
+}
+
+function validateKeruga(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		const typeLine = getTypeLine(card).toLowerCase();
+		const isCreatureOrPlaneswalker =
+			typeLine.includes("creature") || typeLine.includes("planeswalker");
+
+		if (!isCreatureOrPlaneswalker) continue;
+
+		const mv = card.cmc ?? 0;
+		if (mv < 3) {
+			violations.push(
+				violation(
+					companionRule,
+					`Keruga companion requires all creatures and planeswalkers to have mana value 3 or greater, but ${card.name} has mana value ${mv}`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateYorion(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, config } = ctx;
+	const mainboard = getCardsInSection(deck, "mainboard");
+	const mainboardCount = mainboard.reduce((sum, c) => sum + c.quantity, 0);
+
+	const minDeckSize = config.minDeckSize ?? config.deckSize ?? 60;
+	const requiredSize = minDeckSize + 20;
+
+	if (mainboardCount < requiredSize) {
+		return [
+			violation(
+				companionRule,
+				`Yorion companion requires at least ${requiredSize} cards (20 more than minimum), but deck has ${mainboardCount}`,
+				"error",
+			),
+		];
+	}
+
+	return [];
+}
+
+function validateZirda(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const violations: Violation[] = [];
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (!isPermanent(card)) continue;
+
+		const oracleText = getOracleText(card).toLowerCase();
+		const hasActivatedAbility = /\{[^}]*\}.*:/.test(oracleText);
+
+		if (!hasActivatedAbility) {
+			violations.push(
+				violation(
+					companionRule,
+					`Zirda companion requires all permanents to have an activated ability, but ${card.name} does not`,
+					"error",
+					{
+						cardName: card.name,
+						oracleId: entry.oracleId,
+						section: "mainboard",
+					},
+				),
+			);
+		}
+	}
+
+	return violations;
+}
+
+function validateLutri(_companion: Card, ctx: ValidationContext): Violation[] {
+	const { deck, cardLookup } = ctx;
+	const mainboard = getCardsInSection(deck, "mainboard");
+
+	const namesSeen = new Set<string>();
+	const duplicates: string[] = [];
+
+	for (const entry of mainboard) {
+		const card = cardLookup(entry.scryfallId);
+		if (!card) continue;
+
+		if (isLand(card)) continue;
+
+		if (entry.quantity > 1) {
+			duplicates.push(card.name);
+			continue;
+		}
+
+		if (namesSeen.has(card.name)) {
+			duplicates.push(card.name);
+		}
+		namesSeen.add(card.name);
+	}
+
+	if (duplicates.length > 0) {
+		return [
+			violation(
+				companionRule,
+				`Lutri companion requires all nonland cards to have different names, but deck has duplicates: ${duplicates.slice(0, 3).join(", ")}${duplicates.length > 3 ? "..." : ""}`,
+				"error",
+			),
+		];
+	}
+
+	return [];
+}
+
+function isPermanent(card: Card): boolean {
+	const typeLine = getTypeLine(card).toLowerCase();
+	return (
+		typeLine.includes("creature") ||
+		typeLine.includes("artifact") ||
+		typeLine.includes("enchantment") ||
+		typeLine.includes("planeswalker") ||
+		typeLine.includes("land") ||
+		typeLine.includes("battle")
+	);
+}
+
+function isLand(card: Card): boolean {
+	const typeLine = getTypeLine(card).toLowerCase();
+	return typeLine.includes("land");
+}
+
+function getTypeLine(card: Card): string {
+	if (card.type_line) {
+		return card.type_line;
+	}
+	if (card.card_faces) {
+		return card.card_faces.map((face) => face.type_line ?? "").join(" // ");
+	}
+	return "";
+}
+
+function getOracleText(card: Card): string {
+	if (card.oracle_text) {
+		return card.oracle_text;
+	}
+	if (card.card_faces) {
+		return card.card_faces.map((face) => face.oracle_text ?? "").join("\n");
+	}
+	return "";
+}

src/lib/deck-validation/rules/index.ts

···
 	isValidCommanderType,
 	signatureSpellRule,
 } from "./commander";
-
+export { companionRule } from "./companion";
 export { commanderUncommonRule } from "./rarity";
 
 import {
···
 	signatureSpellRule,
 } from "./commander";
 
+import { companionRule } from "./companion";
 import { commanderUncommonRule } from "./rarity";
 
 /**
···
 	commanderUncommon: commanderUncommonRule,
 	commanderPlaneswalker: commanderPlaneswalkerRule,
 	signatureSpell: signatureSpellRule,
+
+	// Companion rule (sideboard)
+	companion: companionRule,
 } as const;
 
 export type RuleId = keyof typeof RULES;