add ub predicate

.claude/SEARCH.md

···
 **Promo types:**
 - `is:buyabox`, `is:prerelease`, `is:fnm`, `is:gameday`, `is:release`, `is:datestamped`, `is:promopacks`
 
+**Product lines:**
+- `is:ub`, `is:universesbeyond` - Universes Beyond cards (crossover products like LotR, Warhammer, etc.)
+
 **Land types:** (derived from oracle text patterns)
 - `is:fetchland` - Fetch lands (search + pay life)
 - `is:shockland` - Shock lands (pay 2 life)

src/lib/__tests__/test-cards.json

···
 	"$comment": "Maps card names to oracle IDs for test fixtures. Add cards here as needed for tests.",
 	"A-Lantern Bearer": "ba790609-7b48-4a96-a21f-5a0cfcf316a3",
 	"A-Llanowar Greenwidow": "57920afe-61b7-4db1-ad79-dca4f0bc281b",
+	"Aang, Airbending Master": "f3176779-74f7-4136-a701-438feeead7a0",
 	"Aardwolf's Advantage": "4c445455-5b91-4c22-8b3b-8cff4e97f00a",
 	"Abdel Adrian, Gorion's Ward": "cab092f9-b7ff-43b9-935f-310869a4daf8",
 	"Aboroth": "28f70f86-19a9-4811-bc10-423a05842d39",
···
 	"Tel-Jilad Chosen": "de6854d1-bdb0-4b9a-b442-08d4d90a538d",
 	"Temple of Mystery": "7e26f0b7-20e6-46d5-8130-d98c14d6aa29",
 	"The Eighth Doctor": "0956bc16-ff04-4e96-8059-ef62afa2405f",
+	"The Eleventh Doctor": "721e8249-ff1b-4c15-964b-4ba2a96beb75",
 	"The Eternity Elevator": "11323af4-b8b8-4ca9-932f-377c7fd77dea",
 	"Thran Dynamo": "a699c663-8131-4045-9265-a83e86609374",
 	"Thran Portal": "926ce6a2-7bdd-4380-ac65-bc902ba0c284",

src/lib/search/__tests__/is-predicates.test.ts

···
 		});
 	});
 
+	describe("universes beyond predicates", () => {
+		it("is:ub matches cards with universesbeyond promo_type", () => {
+			const ubCard = { promo_types: ["universesbeyond"] } as Card;
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(ubCard)).toBe(true);
+			}
+		});
+
+		it("is:ub matches cards with triangle security stamp", () => {
+			const triangleCard = { security_stamp: "triangle" } as Card;
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(triangleCard)).toBe(true);
+			}
+		});
+
+		it("is:ub matches cards with both indicators", () => {
+			const bothCard = {
+				promo_types: ["universesbeyond"],
+				security_stamp: "triangle",
+			} as Card;
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(bothCard)).toBe(true);
+			}
+		});
+
+		it("is:ub does NOT match regular cards", () => {
+			const normalCard = {
+				security_stamp: "oval",
+				promo_types: [] as string[],
+			} as Card;
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(normalCard)).toBe(false);
+			}
+		});
+
+		it("is:ub does NOT match acorn stamp cards", () => {
+			const acornCard = { security_stamp: "acorn" } as Card;
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(acornCard)).toBe(false);
+			}
+		});
+
+		it("is:universesbeyond is alias for is:ub", () => {
+			const ubCard = { promo_types: ["universesbeyond"] } as Card;
+			const shortResult = search("is:ub");
+			const longResult = search("is:universesbeyond");
+			expect(shortResult.ok && longResult.ok).toBe(true);
+			if (shortResult.ok && longResult.ok) {
+				expect(shortResult.value.match(ubCard)).toBe(
+					longResult.value.match(ubCard),
+				);
+			}
+		});
+
+		it("not:ub excludes Universes Beyond cards", () => {
+			const ubCard = { promo_types: ["universesbeyond"] } as Card;
+			const normalCard = { security_stamp: "oval" } as Card;
+			const result = search("not:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(ubCard)).toBe(false);
+				expect(result.value.match(normalCard)).toBe(true);
+			}
+		});
+
+		it("is:ub matches The Eleventh Doctor (Doctor Who - triangle stamp)", async () => {
+			const card = await cards.get("The Eleventh Doctor");
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(card)).toBe(true);
+			}
+		});
+
+		it("is:ub matches Aang, Airbending Master (Avatar - promo_types, no triangle)", async () => {
+			const card = await cards.get("Aang, Airbending Master");
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(card)).toBe(true);
+			}
+		});
+
+		it("is:ub does NOT match Lightning Bolt (regular Magic card)", async () => {
+			const card = await cards.get("Lightning Bolt");
+			const result = search("is:ub");
+			expect(result.ok).toBe(true);
+			if (result.ok) {
+				expect(result.value.match(card)).toBe(false);
+			}
+		});
+	});
+
 	describe("paupercommander predicates", () => {
 		it("is:paupercommander matches uncommon creatures with paper printing", async () => {
 			const card = await cards.get("Crackling Drake");

src/lib/search/describe.ts

···
 	gameday: "game day promos",
 	release: "release promos",
 	promopacks: "promo pack cards",
+
+	// Universes Beyond
+	ub: "Universes Beyond cards",
+	universesbeyond: "Universes Beyond cards",
 };
 
 function sortColors(colors: Set<string>): string[] {

src/lib/search/fields.ts

···
 	partner: hasPartnerMechanic,
 	// Can be a Pauper Commander (PDH) - uncommon creature/vehicle/spacecraft in paper/MTGO
 	paupercommander: canBePauperCommander,
-	pdhcommander: canBePauperCommander,
 
 	// Type-based predicates
 	permanent: (card) => {
···
 	showcase: (card) => card.frame_effects?.includes("showcase") ?? false,
 	extendedart: (card) => card.frame_effects?.includes("extendedart") ?? false,
 	borderless: (card) => card.border_color === "borderless",
-	fullart: (card) => card.full_art === true,
 	inverted: (card) => card.frame_effects?.includes("inverted") ?? false,
 	colorshifted: (card) => card.frame_effects?.includes("colorshifted") ?? false,
 	retro: (card) => card.frame === "1997" || card.frame === "1993",
···
 			oracle.includes("enters tapped unless you control two or more basic")
 		);
 	},
-	battleland: (card) => {
-		const oracle = card.oracle_text?.toLowerCase() ?? "";
-		const types = card.type_line?.toLowerCase() ?? "";
-		const landTypes = ["plains", "island", "swamp", "mountain", "forest"];
-		const matchCount = landTypes.filter((t) => types.includes(t)).length;
-		return (
-			matchCount >= 2 &&
-			oracle.includes("enters tapped unless you control two or more basic")
-		);
-	},
 	scryland: (card) => {
 		const oracle = card.oracle_text ?? "";
 		// Pattern: "This land enters tapped.\nWhen this land enters, scry 1. (reminder text)\n{T}: Add {W} or {U}."
···
 		const pattern =
 			/^\{T\}, Pay 1 life: Add \{[WUBRG]\} or \{[WUBRG]\}\.\n\{1\}, \{T\}, Sacrifice this land: Draw a card\.$/i;
 		return pattern.test(oracle);
-	},
-	creatureland: (card) => {
-		const oracle = card.oracle_text?.toLowerCase() ?? "";
-		const types = card.type_line?.toLowerCase() ?? "";
-		return types.includes("land") && oracle.includes("becomes a");
 	},
 
 	// Card archetypes
···
 
 	// Hires/quality
 	hires: (card) => card.highres_image === true,
+
+	// Universes Beyond (promo_types or triangle security stamp)
+	ub: (card) =>
+		card.promo_types?.includes("universesbeyond") ||
+		card.security_stamp === "triangle",
+};
+
+/**
+ * Map of is: predicate aliases to canonical names
+ */
+export const IS_PREDICATE_ALIASES: Record<string, string> = {
+	universesbeyond: "ub",
+	battleland: "tangoland",
+	creatureland: "manland",
+	fullart: "full",
+	pdhcommander: "paupercommander",
 };
 
 /**
  * Set of valid is: predicate names (for autocomplete)
  */
-export const IS_PREDICATE_NAMES = new Set(Object.keys(IS_PREDICATES));
+export const IS_PREDICATE_NAMES = new Set([
+	...Object.keys(IS_PREDICATES),
+	...Object.keys(IS_PREDICATE_ALIASES),
+]);
 
 /**
  * Compile is: predicate
···
 		return err({ message: "is: requires a text value", span });
 	}
 
-	const predicate = IS_PREDICATES[value.value.toLowerCase()];
+	const name = value.value.toLowerCase();
+	const canonical = IS_PREDICATE_ALIASES[name] ?? name;
+	const predicate = IS_PREDICATES[canonical];
 	if (!predicate) {
 		return err({
 			message: `'${value.value}' is not a valid is: predicate`,