handle set mapping for syntax search

src/lib/search/__tests__/integration.test.ts

···
 		});
 	});
 
+	describe("set: arena code normalization", () => {
+		const domCard = { set: "dom" } as Card;
+		const dd1Card = { set: "dd1" } as Card;
+		const evgCard = { set: "evg" } as Card;
+
+		it("set:dar finds Dominaria (dom) cards", () => {
+			// "dar" is Arena's code for Dominaria
+			const result = search("set:dar");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(domCard)).toBe(true);
+			}
+		});
+
+		it("set:dom still works directly", () => {
+			const result = search("set:dom");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(domCard)).toBe(true);
+			}
+		});
+
+		it("set:evg finds Anthology (evg), not dd1", () => {
+			// "evg" is shadowed - Arena uses it for dd1, but Scryfall has its own evg set
+			// We should NOT map it to dd1 in search to avoid hiding paper set
+			const result = search("set:evg");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(evgCard)).toBe(true);
+				expect(result.value.match(dd1Card)).toBe(false);
+			}
+		});
+
+		it("in:dar also normalizes arena codes", () => {
+			const result = search("in:dar");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(domCard)).toBe(true);
+			}
+		});
+	});
+
 	describe("complex queries", () => {
 		it("commander deckbuilding query", async () => {
 			const elves = await cards.get("Llanowar Elves");

src/lib/search/fields.ts

···
 	canBePauperCommander,
 	hasPartnerMechanic,
 } from "@/lib/deck-validation/card-utils";
+import { normalizeSetCodeForSearch } from "@/lib/set-symbols";
 import type { Card } from "../scryfall-types";
 import { compareColors } from "./colors";
 import type {
···
 
 		// Set/printing (discrete fields use exact match for ':')
 		case "set":
-			return ok(compileTextField((c) => c.set, operator, value, true));
+			return ok(compileSetField(operator, value));
 
 		case "settype":
 			return ok(compileTextField((c) => c.set_type, operator, value, true));
···
 }
 
 /**
+ * Compile set field matcher with Arena/MTGO code normalization
+ *
+ * Maps arena codes (dar→dom) to scryfall codes, but only for unambiguous mappings.
+ * Shadowed codes (evg, med) are left as-is to avoid hiding real paper sets.
+ */
+function compileSetField(
+	operator: ComparisonOp,
+	value: FieldValue,
+): CardPredicate {
+	if (value.kind === "regex") {
+		const pattern = value.pattern;
+		return (card) => (card.set ? pattern.test(card.set) : false);
+	}
+
+	if (value.kind !== "string") {
+		return () => false;
+	}
+
+	// normalizeSetCodeForSearch returns lowercase, but card.set may not be
+	const searchValue = normalizeSetCodeForSearch(value.value);
+
+	switch (operator) {
+		case ":":
+		case "=":
+			return (card) => card.set?.toLowerCase() === searchValue;
+		case "!=":
+			return (card) =>
+				card.set ? card.set.toLowerCase() !== searchValue : true;
+		default:
+			return (card) => card.set?.toLowerCase() === searchValue;
+	}
+}
+
+/**
  * Compile color field matcher
  */
 function compileColorField(
···
 	// Fall back to set code or language
 	// Set codes are typically 3-4 chars, languages are 2-3 chars
 	// Check both - if either matches, include the card
+	// Normalize set code for arena/mtgo compatibility (dar→dom, etc.)
+	const normalizedSetCode = normalizeSetCodeForSearch(searchValue);
 	return isNegated
 		? (card) =>
-				card.set?.toLowerCase() !== searchValue &&
+				card.set?.toLowerCase() !== normalizedSetCode &&
 				card.lang?.toLowerCase() !== searchValue
 		: (card) =>
-				card.set?.toLowerCase() === searchValue ||
+				card.set?.toLowerCase() === normalizedSetCode ||
 				card.lang?.toLowerCase() === searchValue;
 }