refactor lists to strongref decks

lexicons/com/deckbelcher/collection/list.json

···
     "deckItem": {
       "type": "object",
       "properties": {
-        "deckUri": {
-          "type": "string",
-          "format": "at-uri",
-          "description": "AT-URI of the deck record."
+        "ref": {
+          "type": "ref",
+          "ref": "com.atproto.repo.strongRef",
+          "description": "Reference to the deck record."
         },
         "addedAt": {
           "type": "string",
···
       },
       "description": "A deck saved to the list.",
       "required": [
-        "deckUri",
+        "ref",
         "addedAt"
       ]
     }

src/components/list/SaveToListDialog.tsx

···
 		const itemUri =
 			item.type === "card"
 				? toOracleUri(item.oracleId)
-				: (item.deckUri as `at://${string}`);
+				: (item.uri as `at://${string}`);
 		const queryKeys = getConstellationQueryKeys(itemUri, userDid);
 
 		const previousSaved = queryClient.getQueryData<boolean>(
···
 	const isSaved =
 		item.type === "card"
 			? hasCard(list, item.scryfallId)
-			: hasDeck(list, item.deckUri);
+			: hasDeck(list, item.uri);
 
 	const handleClick = () => {
 		const isAdding = !isSaved;

src/components/social/SocialStats.tsx

···
 }
 
 function getItemUri(item: SaveItem): SocialItemUri {
-	return item.type === "card" ? toOracleUri(item.oracleId) : item.deckUri;
+	return item.type === "card" ? toOracleUri(item.oracleId) : item.uri;
 }
 
 export function SocialStats({

src/lib/collection-list-queries.ts

···
 					items.push({
 						$type: "com.deckbelcher.collection.list#deckItem",
 						addedAt,
-						deckUri: initialItem.deckUri as ResourceUri,
+						ref: {
+							uri: initialItem.uri as ResourceUri,
+							cid: initialItem.cid,
+						},
 					});
 				}
 			}
···
 			const isSaved =
 				item.type === "card"
 					? hasCard(list, item.scryfallId)
-					: hasDeck(list, item.deckUri);
+					: hasDeck(list, item.uri);
 
 			const updatedList = isSaved
 				? item.type === "card"
 					? removeCardFromList(list, item.scryfallId)
-					: removeDeckFromList(list, item.deckUri)
+					: removeDeckFromList(list, item.uri)
 				: item.type === "card"
 					? addCardToList(list, item.scryfallId, item.oracleId)
-					: addDeckToList(list, item.deckUri);
+					: addDeckToList(list, item.uri, item.cid);
 
 			const result = await updateCollectionListRecord(agent, rkey, {
 				$type: "com.deckbelcher.collection.list",
···
 			const isSaved =
 				item.type === "card"
 					? hasCard(list, item.scryfallId)
-					: hasDeck(list, item.deckUri);
+					: hasDeck(list, item.uri);
 
 			// Compute updated list optimistically
 			const updatedList = isSaved
 				? item.type === "card"
 					? removeCardFromList(list, item.scryfallId)
-					: removeDeckFromList(list, item.deckUri)
+					: removeDeckFromList(list, item.uri)
 				: item.type === "card"
 					? addCardToList(list, item.scryfallId, item.oracleId)
-					: addDeckToList(list, item.deckUri);
+					: addDeckToList(list, item.uri, item.cid);
 
 			// Cancel in-flight queries
 			await queryClient.cancelQueries({
···
 			const itemUri =
 				item.type === "card"
 					? toOracleUri(item.oracleId)
-					: (item.deckUri as `at://${string}`);
+					: (item.uri as `at://${string}`);
 			const constellationKeys = getConstellationQueryKeys(itemUri, did);
 
 			await queryClient.cancelQueries({

src/lib/collection-list-types.ts

···
 /**
  * Item to save to a list (card or deck)
  * Shared by SaveToListDialog and SocialStats
+ * Deck items use strongRef (uri + cid) matching the lexicon
  */
 export type SaveItem =
 	| { type: "card"; scryfallId: ScryfallId; oracleId: OracleId }
-	| { type: "deck"; deckUri: DeckItemUri; cid: string };
+	| { type: "deck"; uri: DeckItemUri; cid: string };
 
 /**
  * App-side card item with flat typed IDs.
···
 	);
 }
 
-export function hasDeck(list: CollectionList, deckUri: string): boolean {
-	return list.items.some(
-		(item) => isDeckItem(item) && item.deckUri === deckUri,
-	);
+export function hasDeck(list: CollectionList, uri: string): boolean {
+	return list.items.some((item) => isDeckItem(item) && item.ref.uri === uri);
 }
 
 export function addCardToList(
···
 
 export function addDeckToList(
 	list: CollectionList,
-	deckUri: string,
+	uri: string,
+	cid: string,
 ): CollectionList {
-	if (hasDeck(list, deckUri)) {
+	if (hasDeck(list, uri)) {
 		return list;
 	}
 
 	const newItem: ListDeckItem = {
 		$type: "com.deckbelcher.collection.list#deckItem",
-		deckUri: deckUri as ResourceUri,
+		ref: {
+			uri: uri as ResourceUri,
+			cid,
+		},
 		addedAt: new Date().toISOString(),
 	};
 
···
 
 export function removeDeckFromList(
 	list: CollectionList,
-	deckUri: string,
+	uri: string,
 ): CollectionList {
 	return {
 		...list,
 		items: list.items.filter(
-			(item) => !(isDeckItem(item) && item.deckUri === deckUri),
+			(item) => !(isDeckItem(item) && item.ref.uri === uri),
 		),
 		updatedAt: new Date().toISOString(),
 	};

src/lib/constellation-client.ts

···
 export const COLLECTION_LIST_CARD_PATH =
 	".items[com.deckbelcher.collection.list#cardItem].ref.oracleUri";
 export const COLLECTION_LIST_DECK_PATH =
-	".items[com.deckbelcher.collection.list#deckItem].deckUri";
+	".items[com.deckbelcher.collection.list#deckItem].ref.uri";
 // Future: cards in decks (also uses oracleUri for aggregation)
 export const DECK_LIST_CARD_PATH = ".cards[].ref.oracleUri";
 

src/lib/lexicons/types/com/deckbelcher/collection/list.ts

···
 import type {} from "@atcute/lexicons";
 import * as v from "@atcute/lexicons/validations";
 import type {} from "@atcute/lexicons/ambient";
+import * as ComAtprotoRepoStrongRef from "../../atproto/repo/strongRef.js";
 import * as ComDeckbelcherDefs from "../defs.js";
 import * as ComDeckbelcherRichtext from "../richtext.js";
 
···
    */
   addedAt: /*#__PURE__*/ v.datetimeString(),
   /**
-   * AT-URI of the deck record.
+   * Reference to the deck record.
    */
-  deckUri: /*#__PURE__*/ v.resourceUriString(),
+  get ref() {
+    return ComAtprotoRepoStrongRef.mainSchema;
+  },
 });
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.tidString(),

src/lib/like-queries.ts

···
 
 			let subject: LikeSubject;
 			if (params.item.type === "deck") {
-				subject = buildRecordSubject(params.item.deckUri, params.item.cid);
+				subject = buildRecordSubject(params.item.uri, params.item.cid);
 			} else {
 				subject = buildCardSubject(
 					params.item.scryfallId,
···
 			const userDid = session?.info.sub;
 			const itemUri =
 				params.item.type === "deck"
-					? (params.item.deckUri as `at://${string}`)
+					? (params.item.uri as `at://${string}`)
 					: toOracleUri(params.item.oracleId);
 
 			const keys = getConstellationQueryKeys(itemUri, userDid);

src/routes/profile/$did/deck/$rkey/index.tsx

···
 				did={did}
 				rkey={rkey}
 				deck={deck}
+				deckCid={deckRecord.cid}
 				groupBy={groupBy}
 				sortBy={sortBy}
 				previewCard={previewCard}
···
 	did: string;
 	rkey: string;
 	deck: Deck;
+	deckCid: string;
 	groupBy: GroupBy;
 	sortBy: SortBy;
 	previewCard: ScryfallId;
···
 	did,
 	rkey,
 	deck,
+	deckCid,
 	groupBy,
 	sortBy,
 	previewCard,
···
 						<SocialStats
 							item={{
 								type: "deck",
-								deckUri: `at://${did}/com.deckbelcher.deck.list/${rkey}`,
-								cid: deckRecord.cid,
+								uri: `at://${did}/com.deckbelcher.deck.list/${rkey}`,
+								cid: deckCid,
 							}}
 							itemName={deck.name}
 						/>

src/routes/profile/$did/list/$rkey/index.tsx

···
 	const handleRemoveDeck = (item: ListDeckItem) => {
 		const saveItem: SaveItem = {
 			type: "deck",
-			deckUri: item.deckUri,
+			uri: item.ref.uri,
+			cid: item.ref.cid,
 		};
 		toggleMutation.mutate({ list, item: saveItem });
 	};
···
 								/>
 							) : isDeckItem(item) ? (
 								<DeckListItem
-									key={item.deckUri}
+									key={item.ref.uri}
 									item={item}
 									onRemove={isOwner ? handleRemoveDeck : undefined}
 								/>
···
 }
 
 function DeckListItem({ item, onRemove }: DeckListItemProps) {
-	const parts = item.deckUri.split("/");
+	const parts = item.ref.uri.split("/");
 	const deckDid = parts[2] as Did;
 	const deckRkey = parts[4] as Rkey;
 

typelex/collection-list.tsp

···
 
   /** A deck saved to the list. */
   model DeckItem {
-    /** AT-URI of the deck record. */
+    /** Reference to the deck record. */
     @required
-    deckUri: atUri;
+    ref: com.atproto.repo.strongRef.Main;
 
     /** Timestamp when this item was added to the list. */
     @required