add and handle more edge cases

src/lib/__tests__/test-cards.json

···
 	"Cormela, Glamour Thief": "3cd9bac9-0abc-43d8-9f84-94f965f7a2e0",
 	"Cryptolith Rite": "043f869d-b11c-4c0d-9591-2bf0df7bde55",
 	"Dark Ritual": "53f7c868-b03e-4fc2-8dcf-a75bbfa3272b",
+	"Delver of Secrets": "edd531b9-f615-4399-8c8c-1c5e18c4acbf",
 	"Dryad Arbor": "e996cd67-739c-40f4-b276-0042acf26c71",
 	"Elvish Mystic": "3f3b2c10-21f8-4e13-be83-4ef3fa36e123",
 	"Elvish Spirit Guide": "6b0e23cf-7d68-4329-86db-7adc26abd86b",
···
 	"Mana Vault": "736892cb-a34b-4bb9-b56c-e26e3db207a2",
 	"Misty Rainforest": "09dd85aa-47bc-4713-a9b9-8b52ff2285ed",
 	"Mox Diamond": "f3c5978a-70fa-431f-933b-b954bd0db0ea",
+	"Nicol Bolas, Planeswalker": "05e9b55e-6329-48ec-b7d7-24c6b9692244",
 	"Ornithopter": "a3a98bc9-caa0-49b7-951c-fe4e4f54e4ba",
 	"Phyrexian Tower": "1861e642-21d5-4232-89f3-b5557f2946c1",
 	"Priest of Gix": "d93f82ce-0eed-45cc-a7b1-50fd4cbb6152",

src/lib/search/__tests__/edge-cases.test.ts

···
 			}
 		});
 	});
+
+	describe("loyalty matching", () => {
+		it("matches planeswalker loyalty", async () => {
+			const bolas = await cards.get("Nicol Bolas, Planeswalker");
+			expect(bolas.loyalty).toBeDefined();
+
+			const result = search("loy>=5");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bolas)).toBe(true);
+			}
+		});
+
+		it("non-planeswalkers have no loyalty", async () => {
+			const bolt = await cards.get("Lightning Bolt");
+
+			const result = search("loy>0");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bolt)).toBe(false);
+			}
+		});
+	});
+
+	describe("multi-face cards", () => {
+		it("searches oracle text across faces", async () => {
+			const delver = await cards.get("Delver of Secrets");
+			// Delver transforms into Insectile Aberration
+
+			// Should match front face
+			const front = search('o:"Look at the top card"');
+			expect(front.ok).toBe(true);
+			if (front.ok) {
+				expect(front.value.match(delver)).toBe(true);
+			}
+		});
+
+		it("is:transform matches transform cards", async () => {
+			const delver = await cards.get("Delver of Secrets");
+			const bolt = await cards.get("Lightning Bolt");
+
+			const result = search("is:transform");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(delver)).toBe(true);
+				expect(result.value.match(bolt)).toBe(false);
+			}
+		});
+	});
+
+	describe("regex edge cases", () => {
+		it("regex at start of query works", async () => {
+			const bolt = await cards.get("Lightning Bolt");
+
+			const result = search("/^lightning/i");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bolt)).toBe(true);
+			}
+		});
+
+		it("regex after field works", async () => {
+			const bolt = await cards.get("Lightning Bolt");
+
+			const result = search("o:/\\d+ damage/");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bolt)).toBe(true);
+			}
+		});
+
+		it("invalid regex returns error", () => {
+			const result = search("/[invalid/");
+			expect(result.ok).toBe(false);
+			if (!result.ok) {
+				expect(result.error.message).toContain("Invalid regex");
+			}
+		});
+	});
+
+	describe("produces: mana production", () => {
+		it("matches cards that produce mana", async () => {
+			const solRing = await cards.get("Sol Ring");
+			expect(solRing.produced_mana).toContain("C");
+
+			const result = search("produces:c");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(solRing)).toBe(true);
+			}
+		});
+
+		it("non-mana-producers don't match", async () => {
+			const bolt = await cards.get("Lightning Bolt");
+
+			const result = search("produces:r");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bolt)).toBe(false);
+			}
+		});
+	});
 });

src/lib/search/colors.ts

···
 /**
  * Compare card colors against search colors using the given operator
  *
- * Special handling for colorless (C):
+ * Special handling for colorless (C) in colors/color_identity:
  * - "C" in search means "colorless" = empty color set
  * - Colorless cards have [] for colors/color_identity, not ["C"]
+ *
+ * For produced_mana, C is literal - set literalColorless=true
  */
 export function compareColors(
 	cardColors: string[] | undefined,
 	searchColors: Set<string>,
 	operator: ComparisonOp,
+	literalColorless = false,
 ): boolean {
 	const cardSet = new Set(cardColors ?? []);
 
-	// Searching for exactly colorless (only C in search)
-	const isColorlessSearch = searchColors.size === 1 && searchColors.has("C");
-	const cardIsColorless = cardSet.size === 0;
+	// For colors/color_identity, colorless means empty array
+	// For produced_mana, C is literal in the array
+	if (!literalColorless) {
+		const isColorlessSearch = searchColors.size === 1 && searchColors.has("C");
+		const cardIsColorless = cardSet.size === 0;
 
-	if (isColorlessSearch) {
-		switch (operator) {
-			case ":":
-			case ">=":
-			case "=":
-				return cardIsColorless;
-			case "!=":
-				return !cardIsColorless;
-			case "<=":
-				// id<=c means "can go in colorless deck" = only colorless cards
-				return cardIsColorless;
-			case "<":
-				// Strict subset of empty = impossible
-				return false;
-			case ">":
-				// Strict superset of empty = has any colors
-				return !cardIsColorless;
+		if (isColorlessSearch) {
+			switch (operator) {
+				case ":":
+				case ">=":
+				case "=":
+					return cardIsColorless;
+				case "!=":
+					return !cardIsColorless;
+				case "<=":
+					return cardIsColorless;
+				case "<":
+					return false;
+				case ">":
+					return !cardIsColorless;
+			}
 		}
+
+		// Remove C from search - it doesn't appear in colors/color_identity
+		const normalizedSearch = new Set(searchColors);
+		normalizedSearch.delete("C");
+		searchColors = normalizedSearch;
 	}
 
-	// Remove C from search - it doesn't appear in actual card data
-	const normalizedSearch = new Set(searchColors);
-	normalizedSearch.delete("C");
-
 	switch (operator) {
 		case ":":
 		case ">=":
-			return isSuperset(cardSet, normalizedSearch);
+			return isSuperset(cardSet, searchColors);
 
 		case "=":
-			return setsEqual(cardSet, normalizedSearch);
+			return setsEqual(cardSet, searchColors);
 
 		case "!=":
-			return !setsEqual(cardSet, normalizedSearch);
+			return !setsEqual(cardSet, searchColors);
 
 		case "<=":
-			return isSubset(cardSet, normalizedSearch);
+			return isSubset(cardSet, searchColors);
 
 		case "<":
-			return isStrictSubset(cardSet, normalizedSearch);
+			return isStrictSubset(cardSet, searchColors);
 
 		case ">":
-			return isStrictSuperset(cardSet, normalizedSearch);
+			return isStrictSuperset(cardSet, searchColors);
 	}
 }
 

src/lib/search/fields.ts

···
 
 	return (card) => {
 		if (!card.produced_mana) return false;
-		return compareColors(card.produced_mana, searchColors, operator);
+		// produced_mana has literal "C" for colorless, unlike colors/color_identity
+		return compareColors(card.produced_mana, searchColors, operator, true);
 	};
 }