Merge pull request #59 from cosmik-network/feature/personal-url-cards

Feature/personal url cards

docs/features/GUIDE.md

···
 src/shared/infrastructure/http/factories/UseCaseFactory.ts
 src/modules/cards/domain/Card.ts
 src/modules/cards/domain/events/CardAddedToLibraryEvent.ts
+src/modules/cards/infrastructure/http/routes/index.ts
 ```

lexicons.json

···
-{
-  "lexicons": ["com.atproto.repo.strongRef"]
-}

src/modules/atproto/infrastructure/__tests__/ATProtoCardPublisher.integration.test.ts

···
 import dotenv from 'dotenv';
 import { AppPasswordAgentService } from './AppPasswordAgentService';
 import { PublishedRecordId } from 'src/modules/cards/domain/value-objects/PublishedRecordId';
+import { EnvironmentConfigService } from 'src/shared/infrastructure/config/EnvironmentConfigService';
 
 // Load environment variables from .env.test
 dotenv.config({ path: '.env.test' });
···
   let publisher: ATProtoCardPublisher;
   let curatorId: CuratorId;
   let publishedCardIds: PublishedRecordId[] = [];
+  const envConfig: EnvironmentConfigService = new EnvironmentConfigService();
 
   beforeAll(async () => {
     if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD) {
···
       password: process.env.BSKY_APP_PASSWORD,
     });
 
-    publisher = new ATProtoCardPublisher(agentService);
+    publisher = new ATProtoCardPublisher(
+      agentService,
+      envConfig.getAtProtoConfig().collections.card,
+    );
     curatorId = CuratorId.create(process.env.BSKY_DID).unwrap();
   });
 
···
           .withUrl(parentUrl) // Optional: include the same URL as reference
           .buildOrThrow();
 
-        // Add note card to curator's library
         noteCard.addToLibrary(curatorId);
 
         // 3. Publish the note card
         const notePublishResult = await publisher.publishCardToLibrary(
           noteCard,
           curatorId,
+          parentUrlCard,
         );
         expect(notePublishResult.isOk()).toBe(true);
 
···
     }, 20000);
   });
 
-  describe('Card with Original Published Record ID', () => {
-    it('should publish a card that references an original published record', async () => {
+  describe('Note Card with Original Published Record ID', () => {
+    it('should publish a note card that references an original published record', async () => {
       // Skip test if credentials are not available
       if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD) {
         console.warn('Skipping test: BSKY credentials not found in .env.test');
         return;
       }
 
-      const testUrl = URL.create(
-        'https://example.com/original-article',
+      const referenceUrl = URL.create(
+        'https://example.com/referenced-article',
       ).unwrap();
 
-      // Create URL metadata
-      const metadata = UrlMetadata.create({
-        url: testUrl.value,
-        title: 'Original Article',
-        description: 'An original article that will be referenced',
-        author: 'Original Author',
-        siteName: 'Example.com',
-        type: 'article',
-        retrievedAt: new Date(),
-      }).unwrap();
-
-      // Create a card with an original published record ID (simulating a card that references another published card)
+      // Create a note card with an original published record ID (simulating a note that references another published card)
       const originalRecordId = {
         uri: 'at://did:plc:example/network.cosmik.card/original123',
         cid: 'bafyoriginal123',
       };
 
-      const cardWithOriginal = new CardBuilder()
-        .withCuratorId(curatorId.value)
-        .withUrlCard(testUrl, metadata)
-        .withUrl(testUrl)
-        .withOriginalPublishedRecordId(originalRecordId)
+      const curatorId2 = CuratorId.create('did:plc:defaultCurator2').unwrap();
+      const noteCardWithOriginal = new CardBuilder()
+        .withCuratorId(curatorId2.value)
+        .withNoteCard('This is my note about the referenced article')
+        .withUrl(referenceUrl) // Optional URL reference
+        .withPublishedRecordId(originalRecordId)
         .buildOrThrow();
 
       // Add card to curator's library first
-      cardWithOriginal.addToLibrary(curatorId);
+      noteCardWithOriginal.addToLibrary(curatorId2);
+      noteCardWithOriginal.markCardInLibraryAsPublished(
+        curatorId2,
+        PublishedRecordId.create(originalRecordId),
+      );
+      noteCardWithOriginal.addToLibrary(curatorId);
 
       // 1. Publish the card
       const publishResult = await publisher.publishCardToLibrary(
-        cardWithOriginal,
+        noteCardWithOriginal,
         curatorId,
       );
       expect(publishResult.isOk()).toBe(true);
···
         publishedCardIds.push(publishedRecordId);
 
         console.log(
-          `Published card with original record ID: ${publishedRecordId.getValue().uri}`,
+          `Published note card with original record ID: ${publishedRecordId.getValue().uri}`,
         );
 
         // Verify the card has the original published record ID
-        expect(cardWithOriginal.originalPublishedRecordId).toBeDefined();
-        expect(cardWithOriginal.originalPublishedRecordId!.getValue().uri).toBe(
+        expect(noteCardWithOriginal.publishedRecordId).toBeDefined();
+        expect(noteCardWithOriginal.publishedRecordId!.getValue().uri).toBe(
           originalRecordId.uri,
         );
-        expect(cardWithOriginal.originalPublishedRecordId!.getValue().cid).toBe(
+        expect(noteCardWithOriginal.publishedRecordId!.getValue().cid).toBe(
           originalRecordId.cid,
         );
 
+        // Verify it's a note card with optional URL
+        expect(noteCardWithOriginal.isNoteCard).toBe(true);
+        expect(noteCardWithOriginal.url).toBe(referenceUrl);
+
         // Mark card as published in library
-        cardWithOriginal.markCardInLibraryAsPublished(
+        noteCardWithOriginal.markCardInLibraryAsPublished(
           curatorId,
           publishedRecordId,
         );
-        expect(cardWithOriginal.isInLibrary(curatorId)).toBe(true);
+        expect(noteCardWithOriginal.isInLibrary(curatorId)).toBe(true);
 
         // 2. Unpublish the card
         if (UNPUBLISH) {
···
           );
           expect(unpublishResult.isOk()).toBe(true);
 
-          console.log('Successfully unpublished card with original record ID');
+          console.log(
+            'Successfully unpublished note card with original record ID',
+          );
 
           // Remove from cleanup list since we've already unpublished it
           publishedCardIds = publishedCardIds.filter(
···
         password: 'invalid-password',
       });
 
-      const invalidPublisher = new ATProtoCardPublisher(invalidAgentService);
+      const invalidPublisher = new ATProtoCardPublisher(
+        invalidAgentService,
+        envConfig.getAtProtoConfig().collections.card,
+      );
 
       const invalidCuratorId = CuratorId.create('did:plc:invalid').unwrap();
       const testCard = new CardBuilder()

src/modules/atproto/infrastructure/__tests__/ATProtoCollectionPublisher.integration.test.ts

···
 import { PublishedRecordId } from 'src/modules/cards/domain/value-objects/PublishedRecordId';
 import { CollectionBuilder } from 'src/modules/cards/tests/utils/builders/CollectionBuilder';
 import { CardBuilder } from 'src/modules/cards/tests/utils/builders/CardBuilder';
-import {
-  Collection,
-  CollectionAccessType,
-} from 'src/modules/cards/domain/Collection';
-import { Card } from 'src/modules/cards/domain/Card';
+import { CollectionAccessType } from 'src/modules/cards/domain/Collection';
 import { URL } from 'src/modules/cards/domain/value-objects/URL';
 import { UrlMetadata } from 'src/modules/cards/domain/value-objects/UrlMetadata';
 import { CuratorId } from 'src/modules/cards/domain/value-objects/CuratorId';
 import dotenv from 'dotenv';
 import { AppPasswordAgentService } from './AppPasswordAgentService';
+import { EnvironmentConfigService } from 'src/shared/infrastructure/config/EnvironmentConfigService';
 
 // Load environment variables from .env.test
 dotenv.config({ path: '.env.test' });
 
+// Set to false to skip unpublishing (useful for debugging published records)
+const UNPUBLISH = false;
+
 describe('ATProtoCollectionPublisher', () => {
   let collectionPublisher: ATProtoCollectionPublisher;
   let cardPublisher: FakeCardPublisher;
   let curatorId: CuratorId;
   let publishedCollectionIds: PublishedRecordId[] = [];
   let publishedLinkIds: PublishedRecordId[] = [];
+  const envConfig: EnvironmentConfigService = new EnvironmentConfigService();
 
   beforeAll(async () => {
     if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD) {
···
       password: process.env.BSKY_APP_PASSWORD,
     });
 
-    collectionPublisher = new ATProtoCollectionPublisher(agentService);
+    collectionPublisher = new ATProtoCollectionPublisher(
+      agentService,
+      envConfig.getAtProtoConfig().collections.collection,
+      envConfig.getAtProtoConfig().collections.collectionLink,
+    );
     cardPublisher = new FakeCardPublisher();
     curatorId = CuratorId.create(process.env.BSKY_DID).unwrap();
   });
 
   afterAll(async () => {
-    // Skip cleanup if credentials are not available
-    if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD) {
+    // Skip cleanup if credentials are not available or UNPUBLISH is false
+    if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD || !UNPUBLISH) {
+      if (!UNPUBLISH) {
+        console.log('Skipping cleanup: UNPUBLISH is set to false');
+      }
       return;
     }
 
···
         }
 
         // 3. Unpublish the collection
-        const unpublishResult =
-          await collectionPublisher.unpublish(collectionRecordId);
-        expect(unpublishResult.isOk()).toBe(true);
+        if (UNPUBLISH) {
+          const unpublishResult =
+            await collectionPublisher.unpublish(collectionRecordId);
+          expect(unpublishResult.isOk()).toBe(true);
 
-        console.log('Successfully unpublished empty collection');
+          console.log('Successfully unpublished empty collection');
 
-        // Remove from cleanup list since we've already unpublished it
-        publishedCollectionIds = publishedCollectionIds.filter(
-          (id) => id !== collectionRecordId,
-        );
+          // Remove from cleanup list since we've already unpublished it
+          publishedCollectionIds = publishedCollectionIds.filter(
+            (id) => id !== collectionRecordId,
+          );
+        } else {
+          console.log('Skipping unpublish: UNPUBLISH is set to false');
+        }
       }
     }, 15000);
 
···
         .withCuratorId(curatorId.value)
         .withUrlCard(testUrl1, metadata1)
         .withUrl(testUrl1)
-        .withOriginalPublishedRecordId({
+        .withPublishedRecordId({
           uri: 'at://did:plc:original/network.cosmik.card/original1',
           cid: 'bafyoriginal1',
         })
···
         .withCuratorId(curatorId.value)
         .withUrlCard(testUrl2, metadata2)
         .withUrl(testUrl2)
-        .withOriginalPublishedRecordId({
+        .withPublishedRecordId({
           uri: 'at://did:plc:original/network.cosmik.card/original2',
           cid: 'bafyoriginal2',
         })
···
           .withCuratorId(curatorId.value)
           .withUrlCard(testUrl3, metadata3)
           .withUrl(testUrl3)
-          .withOriginalPublishedRecordId({
+          .withPublishedRecordId({
             uri: 'at://did:plc:original/network.cosmik.card/original3',
             cid: 'bafyoriginal3',
           })
···
         );
 
         // 6. Unpublish the collection
-        const unpublishResult =
-          await collectionPublisher.unpublish(collectionRecordId);
-        expect(unpublishResult.isOk()).toBe(true);
+        if (UNPUBLISH) {
+          const unpublishResult =
+            await collectionPublisher.unpublish(collectionRecordId);
+          expect(unpublishResult.isOk()).toBe(true);
 
-        console.log('Successfully unpublished collection with cards');
+          console.log('Successfully unpublished collection with cards');
 
-        // Remove from cleanup list since we've already unpublished it
-        publishedCollectionIds = publishedCollectionIds.filter(
-          (id) => id !== collectionRecordId,
+          // Remove from cleanup list since we've already unpublished it
+          publishedCollectionIds = publishedCollectionIds.filter(
+            (id) => id !== collectionRecordId,
+          );
+        } else {
+          console.log('Skipping unpublish: UNPUBLISH is set to false');
+        }
+      }
+    }, 30000);
+
+    it('should publish a collection with a card shared between users', async () => {
+      // Skip test if credentials are not available
+      if (!process.env.BSKY_DID || !process.env.BSKY_APP_PASSWORD) {
+        console.warn('Skipping test: BSKY credentials not found in .env.test');
+        return;
+      }
+
+      // Create two different users (we'll simulate userB with the same credentials for testing)
+      const userA = CuratorId.create('did:plc:userA').unwrap();
+      const userB = curatorId; // Use our test credentials as userB
+
+      // 1. User A creates and publishes a note card to their library
+      const originalNote = new CardBuilder()
+        .withCuratorId(userA.value)
+        .withNoteCard('This is an original note created by User A')
+        .withPublishedRecordId({
+          uri: 'at://did:plc:userA/network.cosmik.card/original-note',
+          cid: 'bafyuserAnote123',
+        })
+        .buildOrThrow();
+
+      // Simulate User A adding to their own library and publishing
+      originalNote.addToLibrary(userA);
+      const userALibraryRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:userA/network.cosmik.card/userA-library-note',
+        cid: 'bafyuserAlib123',
+      });
+      originalNote.markCardInLibraryAsPublished(userA, userALibraryRecordId);
+
+      console.log(
+        `Simulated User A publishing note: ${originalNote.publishedRecordId?.getValue().uri}`,
+      );
+
+      // 2. User B adds the same card to their library
+      const addToLibraryResult = originalNote.addToLibrary(userB);
+      expect(addToLibraryResult.isOk()).toBe(true);
+
+      // User B publishes the card to their library (this creates a new record in User B's repo)
+      const userBPublishResult = await cardPublisher.publishCardToLibrary(
+        originalNote,
+        userB,
+      );
+      expect(userBPublishResult.isOk()).toBe(true);
+      const userBLibraryRecordId = userBPublishResult.unwrap();
+      originalNote.markCardInLibraryAsPublished(userB, userBLibraryRecordId);
+
+      console.log(
+        `User B published note to their library: ${userBLibraryRecordId.getValue().uri}`,
+      );
+
+      // 3. User B creates a collection
+      const userBCollection = new CollectionBuilder()
+        .withAuthorId(userB.value)
+        .withName('User B Collection with Shared Card')
+        .withDescription(
+          'Collection containing a card originally created by User A',
+        )
+        .withAccessType(CollectionAccessType.OPEN)
+        .buildOrThrow();
+
+      // 4. User B adds the card to their collection
+      const addCardResult = userBCollection.addCard(originalNote.cardId, userB);
+      expect(addCardResult.isOk()).toBe(true);
+
+      // 5. Publish User B's collection
+      const collectionPublishResult =
+        await collectionPublisher.publish(userBCollection);
+      expect(collectionPublishResult.isOk()).toBe(true);
+
+      if (collectionPublishResult.isOk()) {
+        const collectionRecordId = collectionPublishResult.value;
+        publishedCollectionIds.push(collectionRecordId);
+        userBCollection.markAsPublished(collectionRecordId);
+
+        console.log(
+          `Published User B's collection: ${collectionRecordId.getValue().uri}`,
         );
+
+        // 6. Publish the collection link (this should reference both User B's copy and User A's original)
+        const linkPublishResult =
+          await collectionPublisher.publishCardAddedToCollection(
+            originalNote,
+            userBCollection,
+            userB,
+          );
+        expect(linkPublishResult.isOk()).toBe(true);
+
+        if (linkPublishResult.isOk()) {
+          const linkRecordId = linkPublishResult.value;
+          publishedLinkIds.push(linkRecordId);
+          userBCollection.markCardLinkAsPublished(
+            originalNote.cardId,
+            linkRecordId,
+          );
+
+          console.log(
+            `Published collection link with cross-user card reference: ${linkRecordId.getValue().uri}`,
+          );
+
+          // Verify the card has different library memberships
+          expect(originalNote.libraryMembershipCount).toBe(2);
+          expect(originalNote.isInLibrary(userA)).toBe(true);
+          expect(originalNote.isInLibrary(userB)).toBe(true);
+
+          // Verify User B's library membership has a different published record ID than the original
+          const userBMembership = originalNote.getLibraryInfo(userB);
+          expect(userBMembership).toBeDefined();
+          expect(userBMembership!.publishedRecordId).toBeDefined();
+          expect(userBMembership!.publishedRecordId!.uri).not.toBe(
+            originalNote.publishedRecordId!.uri,
+          );
+
+          console.log(
+            `Verified cross-user card sharing: Original=${originalNote.publishedRecordId!.uri}, UserB=${userBMembership!.publishedRecordId!.uri}`,
+          );
+        }
+
+        // 7. Clean up
+        if (UNPUBLISH) {
+          const unpublishResult =
+            await collectionPublisher.unpublish(collectionRecordId);
+          expect(unpublishResult.isOk()).toBe(true);
+
+          console.log('Successfully unpublished collection with shared card');
+
+          publishedCollectionIds = publishedCollectionIds.filter(
+            (id) => id !== collectionRecordId,
+          );
+        } else {
+          console.log('Skipping unpublish: UNPUBLISH is set to false');
+        }
       }
     }, 30000);
   });
···
         expect(collection.collaboratorIds[0]?.value).toBe(collaboratorDid);
 
         // 2. Unpublish the collection
-        const unpublishResult =
-          await collectionPublisher.unpublish(collectionRecordId);
-        expect(unpublishResult.isOk()).toBe(true);
+        if (UNPUBLISH) {
+          const unpublishResult =
+            await collectionPublisher.unpublish(collectionRecordId);
+          expect(unpublishResult.isOk()).toBe(true);
 
-        console.log('Successfully unpublished closed collection');
+          console.log('Successfully unpublished closed collection');
 
-        // Remove from cleanup list since we've already unpublished it
-        publishedCollectionIds = publishedCollectionIds.filter(
-          (id) => id !== collectionRecordId,
-        );
+          // Remove from cleanup list since we've already unpublished it
+          publishedCollectionIds = publishedCollectionIds.filter(
+            (id) => id !== collectionRecordId,
+          );
+        } else {
+          console.log('Skipping unpublish: UNPUBLISH is set to false');
+        }
       }
     }, 15000);
   });
···
 
       const invalidPublisher = new ATProtoCollectionPublisher(
         invalidAgentService,
+        envConfig.getAtProtoConfig().collections.collection,
+        envConfig.getAtProtoConfig().collections.collectionLink,
       );
 
       const testCollection = new CollectionBuilder()
···
         }
 
         // Clean up
-        const unpublishResult =
-          await collectionPublisher.unpublish(collectionRecordId);
-        expect(unpublishResult.isOk()).toBe(true);
-        publishedCollectionIds = publishedCollectionIds.filter(
-          (id) => id !== collectionRecordId,
-        );
+        if (UNPUBLISH) {
+          const unpublishResult =
+            await collectionPublisher.unpublish(collectionRecordId);
+          expect(unpublishResult.isOk()).toBe(true);
+          publishedCollectionIds = publishedCollectionIds.filter(
+            (id) => id !== collectionRecordId,
+          );
+        } else {
+          console.log('Skipping unpublish: UNPUBLISH is set to false');
+        }
       }
     }, 15000);
   });

src/modules/atproto/infrastructure/lexicon/lexicons.ts

···
 import { type $Typed, is$typed, maybe$typed } from './util.js';
 
 export const schemaDict = {
-  NetworkCosmikAnnotation: {
-    lexicon: 1,
-    id: 'network.cosmik.annotation',
-    description: 'A single record type for all annotations.',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A record representing an annotation on a resource.',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['url', 'field', 'value'],
-          properties: {
-            url: {
-              type: 'string',
-              format: 'uri',
-              description:
-                'The primary URL identifying the annotated resource.',
-            },
-            additionalIdentifiers: {
-              type: 'array',
-              items: {
-                type: 'ref',
-                ref: 'lex:network.cosmik.defs#identifier',
-              },
-              description: 'Optional additional identifiers for the resource.',
-            },
-            field: {
-              type: 'ref',
-              description:
-                'A strong reference to the specific annotation field record being used.',
-              ref: 'lex:com.atproto.repo.strongRef',
-            },
-            fromTemplates: {
-              type: 'array',
-              items: {
-                type: 'ref',
-                description:
-                  'Optional strong reference to the template record used.',
-                ref: 'lex:com.atproto.repo.strongRef',
-              },
-            },
-            note: {
-              type: 'string',
-              description:
-                'An optional user-provided note about the annotation.',
-            },
-            value: {
-              type: 'union',
-              description:
-                'The specific value of the annotation, determined by the field type.',
-              refs: [
-                'lex:network.cosmik.annotation#dyadValue',
-                'lex:network.cosmik.annotation#triadValue',
-                'lex:network.cosmik.annotation#ratingValue',
-                'lex:network.cosmik.annotation#singleSelectValue',
-                'lex:network.cosmik.annotation#multiSelectValue',
-              ],
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Timestamp when this annotation was created (usually set by PDS).',
-            },
-          },
-        },
-      },
-      dyadValue: {
-        type: 'object',
-        description: 'Value structure for a dyad annotation.',
-        required: ['value'],
-        properties: {
-          value: {
-            type: 'integer',
-            description: 'Value representing the relationship between sides',
-            minimum: 0,
-            maximum: 100,
-          },
-        },
-      },
-      triadValue: {
-        type: 'object',
-        description: 'Value structure for a triad annotation.',
-        required: ['vertexA', 'vertexB', 'vertexC'],
-        properties: {
-          vertexA: {
-            type: 'integer',
-            description: 'Value for vertex A',
-            minimum: 0,
-            maximum: 1000,
-          },
-          vertexB: {
-            type: 'integer',
-            description: 'Value for vertex B',
-            minimum: 0,
-            maximum: 1000,
-          },
-          vertexC: {
-            type: 'integer',
-            description: 'Value for vertex C',
-            minimum: 0,
-            maximum: 1000,
-          },
-          sum: {
-            type: 'integer',
-            description: 'Sum of the values for the vertices',
-            const: 1000,
-          },
-        },
-      },
-      ratingValue: {
-        type: 'object',
-        description: 'Value structure for a rating annotation.',
-        required: ['rating'],
-        properties: {
-          rating: {
-            type: 'integer',
-            description: 'The star rating value',
-            minimum: 1,
-            maximum: 10,
-          },
-        },
-      },
-      singleSelectValue: {
-        type: 'object',
-        description: 'Value structure for a single-select annotation.',
-        required: ['option'],
-        properties: {
-          option: {
-            type: 'string',
-            description: 'The selected option',
-          },
-        },
-      },
-      multiSelectValue: {
-        type: 'object',
-        description: 'Value structure for a multi-select annotation.',
-        required: ['options'],
-        properties: {
-          options: {
-            type: 'array',
-            description: 'The selected options',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-      },
-    },
-  },
-  NetworkCosmikAnnotationField: {
-    lexicon: 1,
-    id: 'network.cosmik.annotationField',
-    description: 'A single record type for all annotation fields.',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A record defining an annotation field.',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['name', 'description', 'definition'],
-          properties: {
-            name: {
-              type: 'string',
-              description: 'Name of the annotation field',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the annotation field',
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description: 'Timestamp when this field was created',
-            },
-            definition: {
-              type: 'union',
-              description:
-                'The specific definition of the field, determining its type and constraints.',
-              refs: [
-                'lex:network.cosmik.annotationField#dyadFieldDef',
-                'lex:network.cosmik.annotationField#triadFieldDef',
-                'lex:network.cosmik.annotationField#ratingFieldDef',
-                'lex:network.cosmik.annotationField#singleSelectFieldDef',
-                'lex:network.cosmik.annotationField#multiSelectFieldDef',
-              ],
-            },
-          },
-        },
-      },
-      dyadFieldDef: {
-        type: 'object',
-        description: 'Definition structure for a dyad field.',
-        required: ['sideA', 'sideB'],
-        properties: {
-          sideA: {
-            type: 'string',
-            description: 'Label for side A of the dyad',
-          },
-          sideB: {
-            type: 'string',
-            description: 'Label for side B of the dyad',
-          },
-        },
-      },
-      triadFieldDef: {
-        type: 'object',
-        description: 'Definition structure for a triad field.',
-        required: ['vertexA', 'vertexB', 'vertexC'],
-        properties: {
-          vertexA: {
-            type: 'string',
-            description: 'Label for vertex A of the triad',
-          },
-          vertexB: {
-            type: 'string',
-            description: 'Label for vertex B of the triad',
-          },
-          vertexC: {
-            type: 'string',
-            description: 'Label for vertex C of the triad',
-          },
-        },
-      },
-      ratingFieldDef: {
-        type: 'object',
-        description: 'Definition structure for a rating field.',
-        required: ['numberOfStars'],
-        properties: {
-          numberOfStars: {
-            type: 'integer',
-            description: 'Maximum number of stars for the rating',
-            const: 5,
-          },
-        },
-      },
-      singleSelectFieldDef: {
-        type: 'object',
-        description: 'Definition structure for a single-select field.',
-        required: ['options'],
-        properties: {
-          options: {
-            type: 'array',
-            description: 'Available options for selection',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-      },
-      multiSelectFieldDef: {
-        type: 'object',
-        description: 'Definition structure for a multi-select field.',
-        required: ['options'],
-        properties: {
-          options: {
-            type: 'array',
-            description: 'Available options for selection',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-      },
-    },
-  },
-  NetworkCosmikAnnotationTemplate: {
-    lexicon: 1,
-    id: 'network.cosmik.annotationTemplate',
-    description: 'Annotation templates for grouping annotation fields',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A record of an annotation template',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['name', 'description', 'annotationFields'],
-          properties: {
-            name: {
-              type: 'string',
-              description: 'Name of the template',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the template',
-            },
-            annotationFields: {
-              type: 'array',
-              description:
-                'List of strong references to network.cosmik.annotationField records included in this template.',
-              items: {
-                type: 'ref',
-                ref: 'lex:network.cosmik.annotationTemplate#annotationFieldRef',
-              },
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description: 'Timestamp when this template was created',
-            },
-          },
-        },
-      },
-      annotationFieldRef: {
-        type: 'object',
-        description:
-          'A reference to an annotation field. Defines if the field is required in the template.',
-        required: ['subject'],
-        properties: {
-          subject: {
-            type: 'ref',
-            ref: 'lex:com.atproto.repo.strongRef',
-          },
-          required: {
-            type: 'boolean',
-          },
-        },
-      },
-    },
-  },
   NetworkCosmikCard: {
     lexicon: 1,
     id: 'network.cosmik.card',
···
       urlMetadata: {
         type: 'object',
         description: 'Metadata about a URL.',
-        required: ['url'],
         properties: {
-          url: {
-            type: 'string',
-            format: 'uri',
-            description: 'The URL',
-          },
           title: {
             type: 'string',
             description: 'Title of the page',
···
         key: 'tid',
         record: {
           type: 'object',
-          required: ['collection', 'card', 'addedBy'],
+          required: ['collection', 'card', 'addedBy', 'addedAt'],
           properties: {
             collection: {
               type: 'ref',
···
             },
             card: {
               type: 'ref',
-              description: 'Strong reference to the card record.',
+              description:
+                'Strong reference to the card record in the users library.',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            originalCard: {
+              type: 'ref',
+              description:
+                'Strong reference to the original card record (may be in another library).',
               ref: 'lex:com.atproto.repo.strongRef',
             },
             addedBy: {
···
 }
 
 export const ids = {
-  NetworkCosmikAnnotation: 'network.cosmik.annotation',
-  NetworkCosmikAnnotationField: 'network.cosmik.annotationField',
-  NetworkCosmikAnnotationTemplate: 'network.cosmik.annotationTemplate',
   NetworkCosmikCard: 'network.cosmik.card',
   NetworkCosmikCollection: 'network.cosmik.collection',
   NetworkCosmikCollectionLink: 'network.cosmik.collectionLink',

src/modules/atproto/infrastructure/lexicon/types/network/cosmik/annotation.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon';
-import { CID } from 'multiformats/cid';
-import { validate as _validate } from '../../../lexicons';
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../util';
-import type * as NetworkCosmikDefs from './defs.js';
-import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js';
-
-const is$typed = _is$typed,
-  validate = _validate;
-const id = 'network.cosmik.annotation';
-
-export interface Record {
-  $type: 'network.cosmik.annotation';
-  /** The primary URL identifying the annotated resource. */
-  url: string;
-  /** Optional additional identifiers for the resource. */
-  additionalIdentifiers?: NetworkCosmikDefs.Identifier[];
-  field: ComAtprotoRepoStrongRef.Main;
-  fromTemplates?: ComAtprotoRepoStrongRef.Main[];
-  /** An optional user-provided note about the annotation. */
-  note?: string;
-  value:
-    | $Typed<DyadValue>
-    | $Typed<TriadValue>
-    | $Typed<RatingValue>
-    | $Typed<SingleSelectValue>
-    | $Typed<MultiSelectValue>
-    | { $type: string };
-  /** Timestamp when this annotation was created (usually set by PDS). */
-  createdAt?: string;
-  [k: string]: unknown;
-}
-
-const hashRecord = 'main';
-
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord);
-}
-
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true);
-}
-
-/** Value structure for a dyad annotation. */
-export interface DyadValue {
-  $type?: 'network.cosmik.annotation#dyadValue';
-  /** Value representing the relationship between sides */
-  value: number;
-}
-
-const hashDyadValue = 'dyadValue';
-
-export function isDyadValue<V>(v: V) {
-  return is$typed(v, id, hashDyadValue);
-}
-
-export function validateDyadValue<V>(v: V) {
-  return validate<DyadValue & V>(v, id, hashDyadValue);
-}
-
-/** Value structure for a triad annotation. */
-export interface TriadValue {
-  $type?: 'network.cosmik.annotation#triadValue';
-  /** Value for vertex A */
-  vertexA: number;
-  /** Value for vertex B */
-  vertexB: number;
-  /** Value for vertex C */
-  vertexC: number;
-  /** Sum of the values for the vertices */
-  sum?: 1000;
-}
-
-const hashTriadValue = 'triadValue';
-
-export function isTriadValue<V>(v: V) {
-  return is$typed(v, id, hashTriadValue);
-}
-
-export function validateTriadValue<V>(v: V) {
-  return validate<TriadValue & V>(v, id, hashTriadValue);
-}
-
-/** Value structure for a rating annotation. */
-export interface RatingValue {
-  $type?: 'network.cosmik.annotation#ratingValue';
-  /** The star rating value */
-  rating: number;
-}
-
-const hashRatingValue = 'ratingValue';
-
-export function isRatingValue<V>(v: V) {
-  return is$typed(v, id, hashRatingValue);
-}
-
-export function validateRatingValue<V>(v: V) {
-  return validate<RatingValue & V>(v, id, hashRatingValue);
-}
-
-/** Value structure for a single-select annotation. */
-export interface SingleSelectValue {
-  $type?: 'network.cosmik.annotation#singleSelectValue';
-  /** The selected option */
-  option: string;
-}
-
-const hashSingleSelectValue = 'singleSelectValue';
-
-export function isSingleSelectValue<V>(v: V) {
-  return is$typed(v, id, hashSingleSelectValue);
-}
-
-export function validateSingleSelectValue<V>(v: V) {
-  return validate<SingleSelectValue & V>(v, id, hashSingleSelectValue);
-}
-
-/** Value structure for a multi-select annotation. */
-export interface MultiSelectValue {
-  $type?: 'network.cosmik.annotation#multiSelectValue';
-  /** The selected options */
-  options: string[];
-}
-
-const hashMultiSelectValue = 'multiSelectValue';
-
-export function isMultiSelectValue<V>(v: V) {
-  return is$typed(v, id, hashMultiSelectValue);
-}
-
-export function validateMultiSelectValue<V>(v: V) {
-  return validate<MultiSelectValue & V>(v, id, hashMultiSelectValue);
-}

src/modules/atproto/infrastructure/lexicon/types/network/cosmik/annotationField.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon';
-import { CID } from 'multiformats/cid';
-import { validate as _validate } from '../../../lexicons';
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../util';
-
-const is$typed = _is$typed,
-  validate = _validate;
-const id = 'network.cosmik.annotationField';
-
-export interface Record {
-  $type: 'network.cosmik.annotationField';
-  /** Name of the annotation field */
-  name: string;
-  /** Description of the annotation field */
-  description: string;
-  /** Timestamp when this field was created */
-  createdAt?: string;
-  definition:
-    | $Typed<DyadFieldDef>
-    | $Typed<TriadFieldDef>
-    | $Typed<RatingFieldDef>
-    | $Typed<SingleSelectFieldDef>
-    | $Typed<MultiSelectFieldDef>
-    | { $type: string };
-  [k: string]: unknown;
-}
-
-const hashRecord = 'main';
-
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord);
-}
-
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true);
-}
-
-/** Definition structure for a dyad field. */
-export interface DyadFieldDef {
-  $type?: 'network.cosmik.annotationField#dyadFieldDef';
-  /** Label for side A of the dyad */
-  sideA: string;
-  /** Label for side B of the dyad */
-  sideB: string;
-}
-
-const hashDyadFieldDef = 'dyadFieldDef';
-
-export function isDyadFieldDef<V>(v: V) {
-  return is$typed(v, id, hashDyadFieldDef);
-}
-
-export function validateDyadFieldDef<V>(v: V) {
-  return validate<DyadFieldDef & V>(v, id, hashDyadFieldDef);
-}
-
-/** Definition structure for a triad field. */
-export interface TriadFieldDef {
-  $type?: 'network.cosmik.annotationField#triadFieldDef';
-  /** Label for vertex A of the triad */
-  vertexA: string;
-  /** Label for vertex B of the triad */
-  vertexB: string;
-  /** Label for vertex C of the triad */
-  vertexC: string;
-}
-
-const hashTriadFieldDef = 'triadFieldDef';
-
-export function isTriadFieldDef<V>(v: V) {
-  return is$typed(v, id, hashTriadFieldDef);
-}
-
-export function validateTriadFieldDef<V>(v: V) {
-  return validate<TriadFieldDef & V>(v, id, hashTriadFieldDef);
-}
-
-/** Definition structure for a rating field. */
-export interface RatingFieldDef {
-  $type?: 'network.cosmik.annotationField#ratingFieldDef';
-  /** Maximum number of stars for the rating */
-  numberOfStars: 5;
-}
-
-const hashRatingFieldDef = 'ratingFieldDef';
-
-export function isRatingFieldDef<V>(v: V) {
-  return is$typed(v, id, hashRatingFieldDef);
-}
-
-export function validateRatingFieldDef<V>(v: V) {
-  return validate<RatingFieldDef & V>(v, id, hashRatingFieldDef);
-}
-
-/** Definition structure for a single-select field. */
-export interface SingleSelectFieldDef {
-  $type?: 'network.cosmik.annotationField#singleSelectFieldDef';
-  /** Available options for selection */
-  options: string[];
-}
-
-const hashSingleSelectFieldDef = 'singleSelectFieldDef';
-
-export function isSingleSelectFieldDef<V>(v: V) {
-  return is$typed(v, id, hashSingleSelectFieldDef);
-}
-
-export function validateSingleSelectFieldDef<V>(v: V) {
-  return validate<SingleSelectFieldDef & V>(v, id, hashSingleSelectFieldDef);
-}
-
-/** Definition structure for a multi-select field. */
-export interface MultiSelectFieldDef {
-  $type?: 'network.cosmik.annotationField#multiSelectFieldDef';
-  /** Available options for selection */
-  options: string[];
-}
-
-const hashMultiSelectFieldDef = 'multiSelectFieldDef';
-
-export function isMultiSelectFieldDef<V>(v: V) {
-  return is$typed(v, id, hashMultiSelectFieldDef);
-}
-
-export function validateMultiSelectFieldDef<V>(v: V) {
-  return validate<MultiSelectFieldDef & V>(v, id, hashMultiSelectFieldDef);
-}

src/modules/atproto/infrastructure/lexicon/types/network/cosmik/annotationTemplate.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon';
-import { CID } from 'multiformats/cid';
-import { validate as _validate } from '../../../lexicons';
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../util';
-import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js';
-
-const is$typed = _is$typed,
-  validate = _validate;
-const id = 'network.cosmik.annotationTemplate';
-
-export interface Record {
-  $type: 'network.cosmik.annotationTemplate';
-  /** Name of the template */
-  name: string;
-  /** Description of the template */
-  description: string;
-  /** List of strong references to network.cosmik.annotationField records included in this template. */
-  annotationFields: AnnotationFieldRef[];
-  /** Timestamp when this template was created */
-  createdAt?: string;
-  [k: string]: unknown;
-}
-
-const hashRecord = 'main';
-
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord);
-}
-
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true);
-}
-
-/** A reference to an annotation field. Defines if the field is required in the template. */
-export interface AnnotationFieldRef {
-  $type?: 'network.cosmik.annotationTemplate#annotationFieldRef';
-  subject: ComAtprotoRepoStrongRef.Main;
-  required?: boolean;
-}
-
-const hashAnnotationFieldRef = 'annotationFieldRef';
-
-export function isAnnotationFieldRef<V>(v: V) {
-  return is$typed(v, id, hashAnnotationFieldRef);
-}
-
-export function validateAnnotationFieldRef<V>(v: V) {
-  return validate<AnnotationFieldRef & V>(v, id, hashAnnotationFieldRef);
-}

src/modules/atproto/infrastructure/lexicon/types/network/cosmik/card.ts

···
 /** Metadata about a URL. */
 export interface UrlMetadata {
   $type?: 'network.cosmik.card#urlMetadata';
-  /** The URL */
-  url: string;
   /** Title of the page */
   title?: string;
   /** Description of the page */

src/modules/atproto/infrastructure/lexicon/types/network/cosmik/collectionLink.ts

···
   $type: 'network.cosmik.collectionLink';
   collection: ComAtprotoRepoStrongRef.Main;
   card: ComAtprotoRepoStrongRef.Main;
+  originalCard?: ComAtprotoRepoStrongRef.Main;
   /** DID of the user who added the card to the collection */
   addedBy: string;
   /** Timestamp when the card was added to the collection. */
-  addedAt?: string;
+  addedAt: string;
   /** Timestamp when this link record was created (usually set by PDS). */
   createdAt?: string;
   [k: string]: unknown;

src/modules/atproto/infrastructure/lexicons/annotation.json

···
-{
-  "lexicon": 1,
-  "id": "network.cosmik.annotation",
-  "description": "A single record type for all annotations.",
-  "defs": {
-    "main": {
-      "type": "record",
-      "description": "A record representing an annotation on a resource.",
-      "key": "tid",
-      "record": {
-        "type": "object",
-        "required": ["url", "field", "value"],
-        "properties": {
-          "url": {
-            "type": "string",
-            "format": "uri",
-            "description": "The primary URL identifying the annotated resource."
-          },
-          "additionalIdentifiers": {
-            "type": "array",
-            "items": {
-              "type": "ref",
-              "ref": "network.cosmik.defs#identifier"
-            },
-            "description": "Optional additional identifiers for the resource."
-          },
-          "field": {
-            "type": "ref",
-            "description": "A strong reference to the specific annotation field record being used.",
-            "ref": "com.atproto.repo.strongRef"
-          },
-          "fromTemplates": {
-            "type": "array",
-            "items": {
-              "type": "ref",
-              "description": "Optional strong reference to the template record used.",
-              "ref": "com.atproto.repo.strongRef"
-            }
-          },
-          "note": {
-            "type": "string",
-            "description": "An optional user-provided note about the annotation."
-          },
-          "value": {
-            "type": "union",
-            "description": "The specific value of the annotation, determined by the field type.",
-            "refs": [
-              "#dyadValue",
-              "#triadValue",
-              "#ratingValue",
-              "#singleSelectValue",
-              "#multiSelectValue"
-            ]
-          },
-          "createdAt": {
-            "type": "string",
-            "format": "datetime",
-            "description": "Timestamp when this annotation was created (usually set by PDS)."
-          }
-        }
-      }
-    },
-    "dyadValue": {
-      "type": "object",
-      "description": "Value structure for a dyad annotation.",
-      "required": ["value"],
-      "properties": {
-        "value": {
-          "type": "integer",
-          "description": "Value representing the relationship between sides",
-          "minimum": 0,
-          "maximum": 100
-        }
-      }
-    },
-    "triadValue": {
-      "type": "object",
-      "description": "Value structure for a triad annotation.",
-      "required": ["vertexA", "vertexB", "vertexC"],
-      "properties": {
-        "vertexA": {
-          "type": "integer",
-          "description": "Value for vertex A",
-          "minimum": 0,
-          "maximum": 1000
-        },
-        "vertexB": {
-          "type": "integer",
-          "description": "Value for vertex B",
-          "minimum": 0,
-          "maximum": 1000
-        },
-        "vertexC": {
-          "type": "integer",
-          "description": "Value for vertex C",
-          "minimum": 0,
-          "maximum": 1000
-        },
-        "sum": {
-          "type": "integer",
-          "description": "Sum of the values for the vertices",
-          "const": 1000
-        }
-      }
-    },
-    "ratingValue": {
-      "type": "object",
-      "description": "Value structure for a rating annotation.",
-      "required": ["rating"],
-      "properties": {
-        "rating": {
-          "type": "integer",
-          "description": "The star rating value",
-          "minimum": 1,
-          "maximum": 10
-        }
-      }
-    },
-    "singleSelectValue": {
-      "type": "object",
-      "description": "Value structure for a single-select annotation.",
-      "required": ["option"],
-      "properties": {
-        "option": { "type": "string", "description": "The selected option" }
-      }
-    },
-    "multiSelectValue": {
-      "type": "object",
-      "description": "Value structure for a multi-select annotation.",
-      "required": ["options"],
-      "properties": {
-        "options": {
-          "type": "array",
-          "description": "The selected options",
-          "items": { "type": "string" }
-        }
-      }
-    }
-  }
-}

src/modules/atproto/infrastructure/lexicons/annotationField.json

···
-{
-  "lexicon": 1,
-  "id": "network.cosmik.annotationField",
-  "description": "A single record type for all annotation fields.",
-  "defs": {
-    "main": {
-      "type": "record",
-      "description": "A record defining an annotation field.",
-      "key": "tid",
-      "record": {
-        "type": "object",
-        "required": ["name", "description", "definition"],
-        "properties": {
-          "name": {
-            "type": "string",
-            "description": "Name of the annotation field"
-          },
-          "description": {
-            "type": "string",
-            "description": "Description of the annotation field"
-          },
-          "createdAt": {
-            "type": "string",
-            "format": "datetime",
-            "description": "Timestamp when this field was created"
-          },
-          "definition": {
-            "type": "union",
-            "description": "The specific definition of the field, determining its type and constraints.",
-            "refs": [
-              "#dyadFieldDef",
-              "#triadFieldDef",
-              "#ratingFieldDef",
-              "#singleSelectFieldDef",
-              "#multiSelectFieldDef"
-            ]
-          }
-        }
-      }
-    },
-    "dyadFieldDef": {
-      "type": "object",
-      "description": "Definition structure for a dyad field.",
-      "required": ["sideA", "sideB"],
-      "properties": {
-        "sideA": {
-          "type": "string",
-          "description": "Label for side A of the dyad"
-        },
-        "sideB": {
-          "type": "string",
-          "description": "Label for side B of the dyad"
-        }
-      }
-    },
-    "triadFieldDef": {
-      "type": "object",
-      "description": "Definition structure for a triad field.",
-      "required": ["vertexA", "vertexB", "vertexC"],
-      "properties": {
-        "vertexA": {
-          "type": "string",
-          "description": "Label for vertex A of the triad"
-        },
-        "vertexB": {
-          "type": "string",
-          "description": "Label for vertex B of the triad"
-        },
-        "vertexC": {
-          "type": "string",
-          "description": "Label for vertex C of the triad"
-        }
-      }
-    },
-    "ratingFieldDef": {
-      "type": "object",
-      "description": "Definition structure for a rating field.",
-      "required": ["numberOfStars"],
-      "properties": {
-        "numberOfStars": {
-          "type": "integer",
-          "description": "Maximum number of stars for the rating",
-          "const": 5
-        }
-      }
-    },
-    "singleSelectFieldDef": {
-      "type": "object",
-      "description": "Definition structure for a single-select field.",
-      "required": ["options"],
-      "properties": {
-        "options": {
-          "type": "array",
-          "description": "Available options for selection",
-          "items": { "type": "string" }
-        }
-      }
-    },
-    "multiSelectFieldDef": {
-      "type": "object",
-      "description": "Definition structure for a multi-select field.",
-      "required": ["options"],
-      "properties": {
-        "options": {
-          "type": "array",
-          "description": "Available options for selection",
-          "items": { "type": "string" }
-        }
-      }
-    }
-  }
-}

src/modules/atproto/infrastructure/lexicons/annotationTemplate.json

···
-{
-  "lexicon": 1,
-  "id": "network.cosmik.annotationTemplate",
-  "description": "Annotation templates for grouping annotation fields",
-  "defs": {
-    "main": {
-      "type": "record",
-      "description": "A record of an annotation template",
-      "key": "tid",
-      "record": {
-        "type": "object",
-        "required": ["name", "description", "annotationFields"],
-        "properties": {
-          "name": {
-            "type": "string",
-            "description": "Name of the template"
-          },
-          "description": {
-            "type": "string",
-            "description": "Description of the template"
-          },
-          "annotationFields": {
-            "type": "array",
-            "description": "List of strong references to network.cosmik.annotationField records included in this template.",
-            "items": {
-              "type": "ref",
-              "ref": "#annotationFieldRef"
-            }
-          },
-          "createdAt": {
-            "type": "string",
-            "format": "datetime",
-            "description": "Timestamp when this template was created"
-          }
-        }
-      }
-    },
-    "annotationFieldRef": {
-      "type": "object",
-      "description": "A reference to an annotation field. Defines if the field is required in the template.",
-      "required": ["subject"],
-      "properties": {
-        "subject": {
-          "type": "ref",
-          "ref": "com.atproto.repo.strongRef"
-        },
-        "required": {
-          "type": "boolean"
-        }
-      }
-    }
-  }
-}

src/modules/atproto/infrastructure/lexicons/card.json

···
     "urlMetadata": {
       "type": "object",
       "description": "Metadata about a URL.",
-      "required": ["url"],
       "properties": {
-        "url": {
-          "type": "string",
-          "format": "uri",
-          "description": "The URL"
-        },
         "title": {
           "type": "string",
           "description": "Title of the page"

src/modules/atproto/infrastructure/lexicons/collectionLink.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": [
-          "collection",
-          "card",
-          "originalCard",
-          "addedBy",
-          "addedAt"
-        ],
+        "required": ["collection", "card", "addedBy", "addedAt"],
         "properties": {
           "collection": {
             "type": "ref",

src/modules/atproto/infrastructure/mappers/CardMapper.ts

···
 } from '../lexicon/types/network/cosmik/card';
 import { StrongRef } from '../../domain';
 import { UrlMetadata as UrlMetadataVO } from 'src/modules/cards/domain/value-objects/UrlMetadata';
+import { CuratorId } from 'src/modules/cards/domain/value-objects/CuratorId';
 
 type CardRecordDTO = Record;
 
 export class CardMapper {
-  static toCreateRecordDTO(card: Card): CardRecordDTO {
+  static toCreateRecordDTO(
+    card: Card,
+    curatorId: CuratorId,
+    parentCard?: Card,
+  ): CardRecordDTO {
     const record: CardRecordDTO = {
       $type: 'network.cosmik.card',
       type: card.type.value,
···
       record.url = card.url.value;
     }
 
-    // Add optional original card reference
-    if (card.originalPublishedRecordId) {
-      const strongRef = new StrongRef(
-        card.originalPublishedRecordId.getValue(),
-      );
+    if (card.publishedRecordId && !curatorId.equals(card.curatorId)) {
+      const strongRef = new StrongRef(card.publishedRecordId.getValue());
       record.originalCard = {
+        uri: strongRef.getValue().uri,
+        cid: strongRef.getValue().cid,
+      };
+    }
+
+    if (card.parentCardId && parentCard && parentCard.publishedRecordId) {
+      const strongRef = new StrongRef(parentCard.publishedRecordId.getValue());
+      record.parentCard = {
         uri: strongRef.getValue().uri,
         cid: strongRef.getValue().cid,
       };
···
   private static mapUrlMetadata(metadata: UrlMetadataVO): $Typed<UrlMetadata> {
     return {
       $type: 'network.cosmik.card#urlMetadata',
-      url: metadata.url,
       title: metadata.title,
       description: metadata.description,
       author: metadata.author,

src/modules/atproto/infrastructure/mappers/CollectionLinkMapper.ts

···
     link: CardLink,
     collectionRecord: PublishedRecordIdProps,
     cardRecord: PublishedRecordIdProps,
-    originalCardRecord: PublishedRecordIdProps,
+    originalCardRecord?: PublishedRecordIdProps,
   ): CollectionLinkRecordDTO {
     return {
       $type: 'network.cosmik.collectionLink',
···
         uri: cardRecord.uri,
         cid: cardRecord.cid,
       },
-      originalCard: {
-        uri: originalCardRecord.uri,
-        cid: originalCardRecord.cid,
-      },
+      originalCard: originalCardRecord
+        ? {
+            uri: originalCardRecord.uri,
+            cid: originalCardRecord.cid,
+          }
+        : undefined,
       addedBy: link.addedBy.value,
       addedAt: link.addedAt.toISOString(),
       createdAt: new Date().toISOString(),

src/modules/atproto/infrastructure/publishers/ATProtoCardPublisher.ts

···
 import { DID } from '../../domain/DID';
 import { PublishedRecordId } from 'src/modules/cards/domain/value-objects/PublishedRecordId';
 export class ATProtoCardPublisher implements ICardPublisher {
-  private readonly COLLECTION = 'network.cosmik.card';
-
-  constructor(private readonly agentService: IAgentService) {}
+  constructor(
+    private readonly agentService: IAgentService,
+    private readonly cardCollection: string,
+  ) {}
 
   /**
    * Publishes a Card to the curator's library in the AT Protocol
···
   async publishCardToLibrary(
     card: Card,
     curatorId: CuratorId,
+    parentCard?: Card,
   ): Promise<Result<PublishedRecordId, UseCaseError>> {
     try {
-      const record = CardMapper.toCreateRecordDTO(card);
+      let record = CardMapper.toCreateRecordDTO(card, curatorId, parentCard);
+      record.$type = this.cardCollection as any;
+
       const curatorDidResult = DID.create(curatorId.value);
 
       if (curatorDidResult.isErr()) {
···
 
         await agent.com.atproto.repo.putRecord({
           repo: curatorDid.value,
-          collection: this.COLLECTION,
+          collection: this.cardCollection,
           rkey: rkey,
           record,
         });
···
         // Create new record
         const createResult = await agent.com.atproto.repo.createRecord({
           repo: curatorDid.value,
-          collection: this.COLLECTION,
+          collection: this.cardCollection,
           record,
         });
 
···
 
       await agent.com.atproto.repo.deleteRecord({
         repo,
-        collection: this.COLLECTION,
+        collection: this.cardCollection,
         rkey,
       });
 

src/modules/atproto/infrastructure/publishers/ATProtoCollectionPublisher.ts

···
 import { Card } from 'src/modules/cards/domain/Card';
 import { Result, ok, err } from 'src/shared/core/Result';
 import { UseCaseError } from 'src/shared/core/UseCaseError';
-import { PublishedRecordId } from 'src/modules/cards/domain/value-objects/PublishedRecordId';
+import {
+  PublishedRecordId,
+  PublishedRecordIdProps,
+} from 'src/modules/cards/domain/value-objects/PublishedRecordId';
 import { CuratorId } from 'src/modules/cards/domain/value-objects/CuratorId';
 import { CollectionMapper } from '../mappers/CollectionMapper';
 import { CollectionLinkMapper } from '../mappers/CollectionLinkMapper';
···
 import { DID } from '../../domain/DID';
 
 export class ATProtoCollectionPublisher implements ICollectionPublisher {
-  private readonly COLLECTION_COLLECTION = 'network.cosmik.collection';
-  private readonly COLLECTION_LINK_COLLECTION = 'network.cosmik.collectionLink';
-
-  constructor(private readonly agentService: IAgentService) {}
+  constructor(
+    private readonly agentService: IAgentService,
+    private readonly collectionCollection: string,
+    private readonly collectionLinkCollection: string,
+  ) {}
 
   /**
    * Publishes a Collection record only (not the card links)
···
         // Update existing collection record
         const collectionRecordDTO =
           CollectionMapper.toCreateRecordDTO(collection);
+        collectionRecordDTO.$type = this.collectionCollection as any;
 
         const publishedRecordId = collection.publishedRecordId.getValue();
         const strongRef = new StrongRef(publishedRecordId);
···
 
         await agent.com.atproto.repo.putRecord({
           repo: curatorDid.value,
-          collection: this.COLLECTION_COLLECTION,
+          collection: this.collectionCollection,
           rkey: rkey,
           record: collectionRecordDTO,
         });
···
         // Create new collection record
         const collectionRecordDTO =
           CollectionMapper.toCreateRecordDTO(collection);
+        collectionRecordDTO.$type = this.collectionCollection as any;
 
         const createResult = await agent.com.atproto.repo.createRecord({
           repo: curatorDid.value,
-          collection: this.COLLECTION_COLLECTION,
+          collection: this.collectionCollection,
           record: collectionRecordDTO,
         });
 
···
       }
 
       // Get the original published record ID
-      if (!card.originalPublishedRecordId) {
-        return err(new Error('Card must have an original published record ID'));
+      if (!card.publishedRecordId) {
+        return err(new Error('Card must have a published record ID'));
       }
 
       // Find the card link in the collection
···
         return err(new Error('Card is not linked to this collection'));
       }
 
+      let originalCardRecordId: PublishedRecordIdProps | undefined;
+      if (
+        libraryMembership.publishedRecordId.uri !== card.publishedRecordId.uri
+      ) {
+        originalCardRecordId = card.publishedRecordId.getValue();
+      }
+
       const linkRecordDTO = CollectionLinkMapper.toCreateRecordDTO(
         cardLink,
         collection.publishedRecordId.getValue(),
         libraryMembership.publishedRecordId.getValue(),
-        card.originalPublishedRecordId.getValue(),
+        originalCardRecordId,
       );
+      linkRecordDTO.$type = this.collectionLinkCollection as any;
 
       const createResult = await agent.com.atproto.repo.createRecord({
         repo: curatorDid.value,
-        collection: this.COLLECTION_LINK_COLLECTION,
+        collection: this.collectionLinkCollection,
         record: linkRecordDTO,
       });
 
···
 
       await agent.com.atproto.repo.deleteRecord({
         repo,
-        collection: this.COLLECTION_LINK_COLLECTION,
+        collection: this.collectionLinkCollection,
         rkey,
       });
 
···
       // Delete the collection record
       await agent.com.atproto.repo.deleteRecord({
         repo,
-        collection: this.COLLECTION_COLLECTION,
+        collection: this.collectionCollection,
         rkey,
       });
 

src/modules/cards/application/ports/ICardPublisher.ts

···
   publishCardToLibrary(
     card: Card,
     curatorId: CuratorId,
+    parentCard?: Card,
   ): Promise<Result<PublishedRecordId, UseCaseError>>;
 
   unpublishCardFromLibrary(

src/modules/cards/application/useCases/commands/AddUrlToLibraryUseCase.ts

···
 
       // Check if URL card already exists
       const existingUrlCardResult =
-        await this.cardRepository.findUrlCardByUrl(url);
+        await this.cardRepository.findUsersUrlCardByUrl(url, curatorId);
       if (existingUrlCardResult.isErr()) {
         return err(
           AppError.UnexpectedError.create(existingUrlCardResult.error),

src/modules/cards/application/useCases/commands/RemoveCardFromLibraryUseCase.ts

···
         return err(new ValidationError(removeFromLibraryResult.error.message));
       }
 
+      const updatedCard = removeFromLibraryResult.value;
+      if (
+        updatedCard.libraryCount == 0 &&
+        updatedCard.curatorId.equals(curatorId)
+      ) {
+        // If no curators have this card in their library and the curator is the owner, delete the card
+        const deleteResult = await this.cardRepository.delete(card.cardId);
+        if (deleteResult.isErr()) {
+          return err(AppError.UnexpectedError.create(deleteResult.error));
+        }
+      }
+
       return ok({
         cardId: card.cardId.getStringValue(),
       });

src/modules/cards/application/useCases/commands/UpdateNoteCardUseCase.ts

···
         );
       }
 
-      if (!noteContent.authorId.equals(curatorId)) {
+      if (!card.curatorId.equals(curatorId)) {
         return err(
           new ValidationError('Only the author can update this note card'),
         );
···
       // Create new card content with updated note
       const updatedCardContentResult = CardContent.createNoteContent(
         request.note,
-        curatorId,
       );
       if (updatedCardContentResult.isErr()) {
         return err(new ValidationError(updatedCardContentResult.error.message));

src/modules/cards/application/useCases/queries/GetCollectionPageByAtUriUseCase.ts

···
   CardSortField,
   SortOrder,
 } from 'src/modules/cards/domain/ICardQueryRepository';
-import { REPOSITORY_COLLECTION_IDS } from 'src/modules/atproto/infrastructure/services/RepositoryCollectionIds';
 
 export interface GetCollectionPageByAtUriQuery {
   handle: string;
···
     private identityResolutionService: IIdentityResolutionService,
     private atUriResolutionService: IAtUriResolutionService,
     private getCollectionPageUseCase: GetCollectionPageUseCase,
+    private collectionString: string,
   ) {}
 
   async execute(
···
     // Construct the AT URI using the resolved DID
     const atUriResult = ATUri.fromParts(
       didResult.value,
-      REPOSITORY_COLLECTION_IDS.COLLECTIONS,
+      this.collectionString,
       query.recordKey,
     );
     if (atUriResult.isErr()) {

src/modules/cards/application/useCases/queries/GetUrlMetadataUseCase.ts

···
     imageUrl?: string;
     type?: string;
   };
-  existingCardId?: string;
 }
 
 export class ValidationError extends Error {
···
     const url = urlResult.value;
 
     try {
-      // Check if a card already exists for this URL
-      const existingCardResult =
-        await this.cardRepository.findUrlCardByUrl(url);
-      if (existingCardResult.isErr()) {
-        return err(
-          new Error(
-            `Failed to check for existing card: ${existingCardResult.error instanceof Error ? existingCardResult.error.message : 'Unknown error'}`,
-          ),
-        );
-      }
-
-      const existingCard = existingCardResult.value;
-      const existingCardId = existingCard?.id?.toString();
-
       // Fetch metadata from external service
       const metadataResult = await this.metadataService.fetchMetadata(url);
       if (metadataResult.isErr()) {
···
           imageUrl: metadata.imageUrl,
           type: metadata.type,
         },
-        existingCardId,
       });
     } catch (error) {
       return err(

src/modules/cards/application/useCases/queries/GetUrlStatusForMyLibraryUseCase.ts

···
+import { Result, ok, err } from '../../../../../shared/core/Result';
+import { BaseUseCase } from '../../../../../shared/core/UseCase';
+import { UseCaseError } from '../../../../../shared/core/UseCaseError';
+import { AppError } from '../../../../../shared/core/AppError';
+import { IEventPublisher } from '../../../../../shared/application/events/IEventPublisher';
+import { ICardRepository } from '../../../domain/ICardRepository';
+import { ICollectionQueryRepository } from '../../../domain/ICollectionQueryRepository';
+import { CuratorId } from '../../../domain/value-objects/CuratorId';
+import { URL } from '../../../domain/value-objects/URL';
+
+export interface GetUrlStatusForMyLibraryQuery {
+  url: string;
+  curatorId: string;
+}
+
+export interface CollectionInfo {
+  id: string;
+  uri?: string;
+  name: string;
+  description?: string;
+}
+
+export interface GetUrlStatusForMyLibraryResult {
+  cardId?: string;
+  collections?: CollectionInfo[];
+}
+
+export class ValidationError extends UseCaseError {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class GetUrlStatusForMyLibraryUseCase extends BaseUseCase<
+  GetUrlStatusForMyLibraryQuery,
+  Result<
+    GetUrlStatusForMyLibraryResult,
+    ValidationError | AppError.UnexpectedError
+  >
+> {
+  constructor(
+    private cardRepository: ICardRepository,
+    private collectionQueryRepository: ICollectionQueryRepository,
+    eventPublisher: IEventPublisher,
+  ) {
+    super(eventPublisher);
+  }
+
+  async execute(
+    query: GetUrlStatusForMyLibraryQuery,
+  ): Promise<
+    Result<
+      GetUrlStatusForMyLibraryResult,
+      ValidationError | AppError.UnexpectedError
+    >
+  > {
+    try {
+      // Validate and create CuratorId
+      const curatorIdResult = CuratorId.create(query.curatorId);
+      if (curatorIdResult.isErr()) {
+        return err(
+          new ValidationError(
+            `Invalid curator ID: ${curatorIdResult.error.message}`,
+          ),
+        );
+      }
+      const curatorId = curatorIdResult.value;
+
+      // Validate URL
+      const urlResult = URL.create(query.url);
+      if (urlResult.isErr()) {
+        return err(
+          new ValidationError(`Invalid URL: ${urlResult.error.message}`),
+        );
+      }
+      const url = urlResult.value;
+
+      // Check if user has a URL card with this URL
+      const existingCardResult =
+        await this.cardRepository.findUsersUrlCardByUrl(url, curatorId);
+      if (existingCardResult.isErr()) {
+        return err(AppError.UnexpectedError.create(existingCardResult.error));
+      }
+
+      const card = existingCardResult.value;
+      const result: GetUrlStatusForMyLibraryResult = {};
+
+      if (card) {
+        result.cardId = card.cardId.getStringValue();
+
+        // Get collections containing this card for the user
+        try {
+          const collections =
+            await this.collectionQueryRepository.getCollectionsContainingCardForUser(
+              card.cardId.getStringValue(),
+              curatorId.value,
+            );
+
+          result.collections = collections.map((collection) => ({
+            id: collection.id,
+            uri: collection.uri,
+            name: collection.name,
+            description: collection.description,
+          }));
+        } catch (error) {
+          return err(AppError.UnexpectedError.create(error));
+        }
+      }
+
+      return ok(result);
+    } catch (error) {
+      return err(AppError.UnexpectedError.create(error));
+    }
+  }
+}

src/modules/cards/domain/Card.ts

···
 import { URL } from './value-objects/URL';
 import { CardAddedToLibraryEvent } from './events/CardAddedToLibraryEvent';
 
+export const CARD_ERROR_MESSAGES = {
+  CARD_TYPE_CONTENT_MISMATCH: 'Card type must match content type',
+  URL_CARD_CANNOT_HAVE_PARENT: 'URL cards cannot have parent cards',
+  URL_CARD_MUST_HAVE_URL: 'URL cards must have a url property',
+  URL_CARD_SINGLE_LIBRARY_ONLY: 'URL cards can only be in one library',
+  URL_CARD_CREATOR_LIBRARY_ONLY:
+    'URL cards can only be in the library of the creator',
+  LIBRARY_COUNT_MISMATCH:
+    'Library count does not match library memberships length',
+  CANNOT_CHANGE_CONTENT_TYPE: 'Cannot change card content to different type',
+  ALREADY_IN_LIBRARY: "Card is already in user's library",
+  NOT_IN_LIBRARY: "Card is not in user's library",
+} as const;
+
 export class CardValidationError extends Error {
   constructor(message: string) {
     super(message);
···
 }
 
 interface CardProps {
+  curatorId: CuratorId;
   type: CardType;
   content: CardContent;
   url?: URL;
   parentCardId?: CardId; // For NOTE and HIGHLIGHT cards that reference other cards
   libraryMemberships: CardInLibraryLink[]; // Set of users who have this card in their library
   libraryCount: number; // Cached count of library memberships
-  originalPublishedRecordId?: PublishedRecordId; // The first published record ID for this card
+  publishedRecordId?: PublishedRecordId; // The first published record ID for this card
   createdAt: Date;
   updatedAt: Date;
 }
···
 export class Card extends AggregateRoot<CardProps> {
   get cardId(): CardId {
     return CardId.create(this._id).unwrap();
+  }
+
+  get curatorId(): CuratorId {
+    return this.props.curatorId;
   }
 
   get type(): CardType {
···
     return this.props.libraryCount;
   }
 
-  get originalPublishedRecordId(): PublishedRecordId | undefined {
-    return this.props.originalPublishedRecordId;
+  get publishedRecordId(): PublishedRecordId | undefined {
+    return this.props.publishedRecordId;
   }
 
   // Type-specific convenience getters
···
   ): Result<Card, CardValidationError> {
     // Validate content type matches card type
     if (props.type.value !== props.content.type) {
-      return err(new CardValidationError('Card type must match content type'));
+      return err(
+        new CardValidationError(CARD_ERROR_MESSAGES.CARD_TYPE_CONTENT_MISMATCH),
+      );
     }
 
     // Validate parent/source card relationships
···
       updatedAt: props.updatedAt || now,
     };
 
-    return ok(new Card(cardProps, id));
+    const card = new Card(cardProps, id);
+    return ok(card);
   }
 
   private static validateCardRelationships(
···
   ): Result<void, CardValidationError> {
     // URL cards should not have parent cards
     if (props.type.value === CardTypeEnum.URL && props.parentCardId) {
-      return err(new CardValidationError('URL cards cannot have parent cards'));
+      return err(
+        new CardValidationError(
+          CARD_ERROR_MESSAGES.URL_CARD_CANNOT_HAVE_PARENT,
+        ),
+      );
     }
 
     // URL cards must have a URL property
     if (props.type.value === CardTypeEnum.URL && !props.url) {
-      return err(new CardValidationError('URL cards must have a url property'));
+      return err(
+        new CardValidationError(CARD_ERROR_MESSAGES.URL_CARD_MUST_HAVE_URL),
+      );
+    }
+
+    // URL cards can only be in one library
+    const libraryMemberships = props.libraryMemberships || [];
+    if (
+      props.type.value === CardTypeEnum.URL &&
+      libraryMemberships.length > 1
+    ) {
+      return err(
+        new CardValidationError(
+          CARD_ERROR_MESSAGES.URL_CARD_SINGLE_LIBRARY_ONLY,
+        ),
+      );
+    }
+
+    // URL cards can only have library memberships for the creator
+    if (
+      props.type.value === CardTypeEnum.URL &&
+      libraryMemberships.length > 0
+    ) {
+      const hasNonCreatorMembership = libraryMemberships.some(
+        (membership) => !membership.curatorId.equals(props.curatorId),
+      );
+      if (hasNonCreatorMembership) {
+        return err(
+          new CardValidationError(
+            CARD_ERROR_MESSAGES.URL_CARD_CREATOR_LIBRARY_ONLY,
+          ),
+        );
+      }
     }
 
     // Validate libraryCount matches libraryMemberships length when both are provided
-    const libraryMemberships = props.libraryMemberships || [];
     if (
       props.libraryCount !== undefined &&
       props.libraryCount !== libraryMemberships.length
     ) {
       return err(
         new CardValidationError(
-          `Library count (${props.libraryCount}) does not match library memberships length (${libraryMemberships.length})`,
+          `${CARD_ERROR_MESSAGES.LIBRARY_COUNT_MISMATCH} (${props.libraryCount} vs ${libraryMemberships.length})`,
         ),
       );
     }
···
   ): Result<void, CardValidationError> {
     if (this.props.type.value !== newContent.type) {
       return err(
-        new CardValidationError('Cannot change card content to different type'),
+        new CardValidationError(CARD_ERROR_MESSAGES.CANNOT_CHANGE_CONTENT_TYPE),
       );
     }
 
···
         link.curatorId.equals(userId),
       )
     ) {
-      return err(new CardValidationError("Card is already in user's library"));
+      return err(
+        new CardValidationError(CARD_ERROR_MESSAGES.ALREADY_IN_LIBRARY),
+      );
+    }
+
+    // URL cards can only be in one library
+    if (this.isUrlCard && this.props.libraryMemberships.length > 0) {
+      return err(
+        new CardValidationError(
+          CARD_ERROR_MESSAGES.URL_CARD_SINGLE_LIBRARY_ONLY,
+        ),
+      );
     }
 
     this.props.libraryMemberships.push({
···
         link.curatorId.equals(userId),
       )
     ) {
-      return err(new CardValidationError("Card is not in user's library"));
+      return err(new CardValidationError(CARD_ERROR_MESSAGES.NOT_IN_LIBRARY));
     }
 
     this.props.libraryMemberships = this.props.libraryMemberships.filter(
···
     );
   }
 
+  public markAsPublished(publishedRecordId: PublishedRecordId): void {
+    this.props.publishedRecordId = publishedRecordId;
+    this.props.updatedAt = new Date();
+    this.markCardInLibraryAsPublished(this.props.curatorId, publishedRecordId);
+  }
+
   public markCardInLibraryAsPublished(
     userId: CuratorId,
     publishedRecordId: PublishedRecordId,
···
       link.curatorId.equals(userId),
     );
     if (!membership) {
-      return err(new CardValidationError("Card is not in user's library"));
+      return err(new CardValidationError(CARD_ERROR_MESSAGES.NOT_IN_LIBRARY));
     }
 
     membership.publishedRecordId = publishedRecordId;
 
-    // Set the original published record ID if it hasn't been set yet
-    if (!this.props.originalPublishedRecordId) {
-      this.props.originalPublishedRecordId = publishedRecordId;
+    if (!this.props.publishedRecordId) {
+      this.props.publishedRecordId = publishedRecordId;
     }
 
     this.props.updatedAt = new Date();

src/modules/cards/domain/CardFactory.ts

···
 
       // Create the card
       return Card.create({
+        curatorId,
         type: cardType,
         content,
         url,
···
         return this.createUrlContent(cardInput);
 
       case CardTypeEnum.NOTE:
-        return this.createNoteContent(cardInput, curatorId);
+        return this.createNoteContent(cardInput);
 
       default:
         return err(new CardValidationError('Invalid card type'));
···
 
   private static createNoteContent(
     input: INoteCardInput,
-    curatorId: CuratorId,
   ): Result<CardContent, CardValidationError> {
-    return CardContent.createNoteContent(input.text, curatorId);
+    return CardContent.createNoteContent(input.text);
   }
 
   // Type guards

src/modules/cards/domain/ICardRepository.ts

···
 import { Result } from '../../../shared/core/Result';
 import { Card } from './Card';
 import { CardId } from './value-objects/CardId';
+import { CuratorId } from './value-objects/CuratorId';
 import { URL } from './value-objects/URL';
 
 export interface ICardRepository {
   findById(id: CardId): Promise<Result<Card | null>>;
   save(card: Card): Promise<Result<void>>;
   delete(cardId: CardId): Promise<Result<void>>;
-  findUrlCardByUrl(url: URL): Promise<Result<Card | null>>;
+  findUsersUrlCardByUrl(
+    url: URL,
+    curatorId: CuratorId,
+  ): Promise<Result<Card | null>>;
 }

src/modules/cards/domain/ICollectionQueryRepository.ts

···
   authorId: string; // Just the curator ID, not enriched data
 }
 
+// View data for collections containing a specific card
+export interface CollectionContainingCardDTO {
+  id: string;
+  uri?: string;
+  name: string;
+  description?: string;
+}
+
 export interface ICollectionQueryRepository {
   findByCreator(
     curatorId: string,
     options: CollectionQueryOptions,
   ): Promise<PaginatedQueryResult<CollectionQueryResultDTO>>;
+
+  getCollectionsContainingCardForUser(
+    cardId: string,
+    curatorId: string,
+  ): Promise<CollectionContainingCardDTO[]>;
 }

src/modules/cards/domain/services/CardLibraryService.ts

···
         // Card is already in library, nothing to do
         return ok(card);
       }
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        return err(
+          new CardLibraryValidationError(
+            `Failed to add card to library: ${addToLibResult.error.message}`,
+          ),
+        );
+      }
+      let parentCard: Card | undefined = undefined;
+
+      if (card.parentCardId) {
+        // Ensure parent card is in the curator's library
+        const parentCardResult = await this.cardRepository.findById(
+          card.parentCardId,
+        );
+        if (parentCardResult.isErr()) {
+          return err(
+            new CardLibraryValidationError(
+              `Failed to fetch parent card: ${parentCardResult.error.message}`,
+            ),
+          );
+        }
+        const parentCardValue = parentCardResult.value;
+
+        if (!parentCardValue) {
+          return err(new CardLibraryValidationError(`Parent card not found`));
+        }
+        parentCard = parentCardValue;
+      }
 
       // Publish card to library
       const publishResult = await this.cardPublisher.publishCardToLibrary(
         card,
         curatorId,
+        parentCard,
       );
       if (publishResult.isErr()) {
         return err(
···
       }
 
       // Mark card as published in library
-      card.addToLibrary(curatorId);
-      card.markCardInLibraryAsPublished(curatorId, publishResult.value);
+      const markCardAsPublishedResult = card.markCardInLibraryAsPublished(
+        curatorId,
+        publishResult.value,
+      );
+      if (markCardAsPublishedResult.isErr()) {
+        return err(
+          new CardLibraryValidationError(
+            `Failed to mark card as published in library: ${markCardAsPublishedResult.error.message}`,
+          ),
+        );
+      }
 
       // Save updated card
       const saveResult = await this.cardRepository.save(card);

src/modules/cards/domain/value-objects/CardContent.ts

···
 
   public static createNoteContent(
     text: string,
-    curatorId: CuratorId,
   ): Result<CardContent, CardContentValidationError> {
     // Use provided curatorId or create a dummy one for backward compatibility
-    const authorId = curatorId;
-    const noteContentResult = NoteCardContent.create(authorId, text);
+    const noteContentResult = NoteCardContent.create(text);
     if (noteContentResult.isErr()) {
       return err(
         new CardContentValidationError(noteContentResult.error.message),

src/modules/cards/domain/value-objects/content/NoteCardContent.ts

···
 interface NoteCardContentProps {
   type: CardTypeEnum.NOTE;
   text: string;
-  authorId: CuratorId;
 }
 
 export class NoteCardContent extends ValueObject<NoteCardContentProps> {
···
     return this.props.text;
   }
 
-  get authorId(): CuratorId {
-    return this.props.authorId;
-  }
-
   private constructor(props: NoteCardContentProps) {
     super(props);
   }
 
   public static create(
-    authorId: CuratorId,
     text: string,
   ): Result<NoteCardContent, NoteCardContentValidationError> {
     if (!text || text.trim().length === 0) {
···
       new NoteCardContent({
         type: CardTypeEnum.NOTE,
         text: text.trim(),
-        authorId,
       }),
     );
   }

src/modules/cards/infrastructure/http/controllers/GetUrlStatusForMyLibraryController.ts

···
+import { Controller } from '../../../../../shared/infrastructure/http/Controller';
+import { Response } from 'express';
+import { GetUrlStatusForMyLibraryUseCase } from '../../../application/useCases/queries/GetUrlStatusForMyLibraryUseCase';
+import { AuthenticatedRequest } from '../../../../../shared/infrastructure/http/middleware/AuthMiddleware';
+
+export class GetUrlStatusForMyLibraryController extends Controller {
+  constructor(
+    private getUrlStatusForMyLibraryUseCase: GetUrlStatusForMyLibraryUseCase,
+  ) {
+    super();
+  }
+
+  async executeImpl(req: AuthenticatedRequest, res: Response): Promise<any> {
+    try {
+      const { url } = req.query;
+      const curatorId = req.did;
+
+      if (!curatorId) {
+        return this.unauthorized(res);
+      }
+
+      if (!url || typeof url !== 'string') {
+        return this.badRequest(res, 'URL query parameter is required');
+      }
+
+      const result = await this.getUrlStatusForMyLibraryUseCase.execute({
+        url,
+        curatorId,
+      });
+
+      if (result.isErr()) {
+        return this.fail(res, result.error);
+      }
+
+      return this.ok(res, result.value);
+    } catch (error: any) {
+      return this.fail(res, error);
+    }
+  }
+}

src/modules/cards/infrastructure/http/routes/cardRoutes.ts

···
 import { GetLibrariesForCardController } from '../controllers/GetLibrariesForCardController';
 import { GetMyUrlCardsController } from '../controllers/GetMyUrlCardsController';
 import { GetUserUrlCardsController } from '../controllers/GetUserUrlCardsController';
+import { GetUrlStatusForMyLibraryController } from '../controllers/GetUrlStatusForMyLibraryController';
 import { AuthMiddleware } from 'src/shared/infrastructure/http/middleware';
 
 export function createCardRoutes(
···
   getLibrariesForCardController: GetLibrariesForCardController,
   getMyUrlCardsController: GetMyUrlCardsController,
   getUserUrlCardsController: GetUserUrlCardsController,
+  getUrlStatusForMyLibraryController: GetUrlStatusForMyLibraryController,
 ): Router {
   const router = Router();
 
···
   // GET /api/cards/my - Get my URL cards
   router.get('/my', authMiddleware.ensureAuthenticated(), (req, res) =>
     getMyUrlCardsController.execute(req, res),
+  );
+
+  // GET /api/cards/library/status - Get URL status for my library
+  router.get(
+    '/library/status',
+    authMiddleware.ensureAuthenticated(),
+    (req, res) => getUrlStatusForMyLibraryController.execute(req, res),
   );
 
   // GET /api/cards/user/:identifier - Get user's URL cards by identifier

src/modules/cards/infrastructure/http/routes/index.ts

···
 import { GetLibrariesForCardController } from '../controllers/GetLibrariesForCardController';
 import { GetMyUrlCardsController } from '../controllers/GetMyUrlCardsController';
 import { GetUserUrlCardsController } from '../controllers/GetUserUrlCardsController';
+import { GetUrlStatusForMyLibraryController } from '../controllers/GetUrlStatusForMyLibraryController';
 import { CreateCollectionController } from '../controllers/CreateCollectionController';
 import { UpdateCollectionController } from '../controllers/UpdateCollectionController';
 import { DeleteCollectionController } from '../controllers/DeleteCollectionController';
···
   getLibrariesForCardController: GetLibrariesForCardController,
   getMyUrlCardsController: GetMyUrlCardsController,
   getUserUrlCardsController: GetUserUrlCardsController,
+  getUrlStatusForMyLibraryController: GetUrlStatusForMyLibraryController,
   // Collection controllers
   createCollectionController: CreateCollectionController,
   updateCollectionController: UpdateCollectionController,
···
       getLibrariesForCardController,
       getMyUrlCardsController,
       getUserUrlCardsController,
+      getUrlStatusForMyLibraryController,
     ),
   );
 

src/modules/cards/infrastructure/repositories/DrizzleCardRepository.ts

···
 import { CardDTO, CardMapper } from './mappers/CardMapper';
 import { Result, ok, err } from '../../../../shared/core/Result';
 import { URL } from '../../domain/value-objects/URL';
+import { CuratorId } from '../../domain/value-objects/CuratorId';
 
 export class DrizzleCardRepository implements ICardRepository {
   constructor(private db: PostgresJsDatabase) {}
···
         )
         .where(eq(libraryMemberships.cardId, cardId));
 
-      // Get original published record if it exists
-      let originalPublishedRecord = null;
-      if (result.originalPublishedRecordId) {
-        const originalRecordResult = await this.db
+      // Get published record if it exists
+      let publishedRecord = null;
+      if (result.publishedRecordId) {
+        const publishedRecordResult = await this.db
           .select({
             uri: publishedRecords.uri,
             cid: publishedRecords.cid,
           })
           .from(publishedRecords)
-          .where(eq(publishedRecords.id, result.originalPublishedRecordId))
+          .where(eq(publishedRecords.id, result.publishedRecordId))
           .limit(1);
 
-        if (originalRecordResult.length > 0) {
-          originalPublishedRecord = originalRecordResult[0];
+        if (publishedRecordResult.length > 0) {
+          publishedRecord = publishedRecordResult[0];
         }
       }
 
       const cardDTO: CardDTO = {
         id: result.id,
+        curatorId: result.authorId,
         type: result.type,
         contentData: result.contentData,
         url: result.url || undefined,
         parentCardId: result.parentCardId || undefined,
-        originalPublishedRecordId: originalPublishedRecord
+        publishedRecordId: publishedRecord
           ? {
-              uri: originalPublishedRecord.uri,
-              cid: originalPublishedRecord.cid,
+              uri: publishedRecord.uri,
+              cid: publishedRecord.cid,
             }
           : undefined,
         libraryCount: result.libraryCount ?? 0,
···
       const {
         card: cardData,
         libraryMemberships: membershipData,
-        originalPublishedRecord,
+        publishedRecord,
         membershipPublishedRecords,
       } = CardMapper.toPersistence(card);
 
       await this.db.transaction(async (tx) => {
-        // Handle original published record if it exists
-        let originalPublishedRecordId: string | undefined = undefined;
+        // Handle published record if it exists
+        let publishedRecordId: string | undefined = undefined;
 
-        if (originalPublishedRecord) {
-          const originalRecordResult = await tx
+        if (publishedRecord) {
+          const publishedRecordResult = await tx
             .insert(publishedRecords)
             .values({
-              id: originalPublishedRecord.id,
-              uri: originalPublishedRecord.uri,
-              cid: originalPublishedRecord.cid,
-              recordedAt: originalPublishedRecord.recordedAt || new Date(),
+              id: publishedRecord.id,
+              uri: publishedRecord.uri,
+              cid: publishedRecord.cid,
+              recordedAt: publishedRecord.recordedAt || new Date(),
             })
             .onConflictDoNothing({
               target: [publishedRecords.uri, publishedRecords.cid],
             })
             .returning({ id: publishedRecords.id });
 
-          if (originalRecordResult.length === 0) {
+          if (publishedRecordResult.length === 0) {
             const existingRecord = await tx
               .select()
               .from(publishedRecords)
               .where(
                 and(
-                  eq(publishedRecords.uri, originalPublishedRecord.uri),
-                  eq(publishedRecords.cid, originalPublishedRecord.cid),
+                  eq(publishedRecords.uri, publishedRecord.uri),
+                  eq(publishedRecords.cid, publishedRecord.cid),
                 ),
               )
               .limit(1);
 
             if (existingRecord.length > 0) {
-              originalPublishedRecordId = existingRecord[0]!.id;
+              publishedRecordId = existingRecord[0]!.id;
             }
           } else {
-            originalPublishedRecordId = originalRecordResult[0]!.id;
+            publishedRecordId = publishedRecordResult[0]!.id;
           }
         }
 
···
           .insert(cards)
           .values({
             ...cardData,
-            originalPublishedRecordId: originalPublishedRecordId,
+            publishedRecordId: publishedRecordId,
           })
           .onConflictDoUpdate({
             target: cards.id,
             set: {
+              authorId: cardData.authorId,
               type: cardData.type,
               contentData: cardData.contentData,
               url: cardData.url,
               parentCardId: cardData.parentCardId,
-              originalPublishedRecordId: originalPublishedRecordId,
+              publishedRecordId: publishedRecordId,
               libraryCount: cardData.libraryCount,
               updatedAt: cardData.updatedAt,
             },
···
     }
   }
 
-  async findUrlCardByUrl(url: URL): Promise<Result<Card | null>> {
+  async findUsersUrlCardByUrl(
+    url: URL,
+    curatorId: CuratorId,
+  ): Promise<Result<Card | null>> {
     try {
       const urlValue = url.value;
 
       const cardResult = await this.db
         .select()
         .from(cards)
-        .where(and(eq(cards.url, urlValue), eq(cards.type, 'URL')))
+        .where(
+          and(
+            eq(cards.url, urlValue),
+            eq(cards.type, 'URL'),
+            eq(cards.authorId, curatorId.value),
+          ),
+        )
         .limit(1);
 
       if (cardResult.length === 0) {
···
         )
         .where(eq(libraryMemberships.cardId, result.id));
 
-      // Get original published record if it exists
-      let originalPublishedRecord = null;
-      if (result.originalPublishedRecordId) {
-        const originalRecordResult = await this.db
+      // Get published record if it exists
+      let publishedRecord = null;
+      if (result.publishedRecordId) {
+        const publishedRecordResult = await this.db
           .select({
             uri: publishedRecords.uri,
             cid: publishedRecords.cid,
           })
           .from(publishedRecords)
-          .where(eq(publishedRecords.id, result.originalPublishedRecordId))
+          .where(eq(publishedRecords.id, result.publishedRecordId))
           .limit(1);
 
-        if (originalRecordResult.length > 0) {
-          originalPublishedRecord = originalRecordResult[0];
+        if (publishedRecordResult.length > 0) {
+          publishedRecord = publishedRecordResult[0];
         }
       }
 
       const cardDTO: CardDTO = {
         id: result.id,
+        curatorId: result.authorId,
         type: result.type,
         contentData: result.contentData,
         url: result.url || undefined,
         parentCardId: result.parentCardId || undefined,
-        originalPublishedRecordId: originalPublishedRecord
+        publishedRecordId: publishedRecord
           ? {
-              uri: originalPublishedRecord.uri,
-              cid: originalPublishedRecord.cid,
+              uri: publishedRecord.uri,
+              cid: publishedRecord.cid,
             }
           : undefined,
         libraryCount: result.libraryCount ?? 0,

src/modules/cards/infrastructure/repositories/DrizzleCollectionQueryRepository.ts

···
-import { eq, desc, asc, count, sql, or, ilike } from 'drizzle-orm';
+import { eq, desc, asc, count, sql, or, ilike, and } from 'drizzle-orm';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import {
   ICollectionQueryRepository,
···
   CollectionQueryResultDTO,
   CollectionSortField,
   SortOrder,
+  CollectionContainingCardDTO,
 } from '../../domain/ICollectionQueryRepository';
-import { collections } from './schema/collection.sql';
+import { collections, collectionCards } from './schema/collection.sql';
 import { publishedRecords } from './schema/publishedRecord.sql';
 import { CollectionMapper } from './mappers/CollectionMapper';
 
···
       };
     } catch (error) {
       console.error('Error in findByCreator:', error);
+      throw error;
+    }
+  }
+
+  async getCollectionsContainingCardForUser(
+    cardId: string,
+    curatorId: string,
+  ): Promise<CollectionContainingCardDTO[]> {
+    try {
+      // Find collections authored by this curator that contain this card
+      const collectionResults = await this.db
+        .select({
+          id: collections.id,
+          name: collections.name,
+          description: collections.description,
+          uri: publishedRecords.uri,
+        })
+        .from(collections)
+        .leftJoin(
+          publishedRecords,
+          eq(collections.publishedRecordId, publishedRecords.id),
+        )
+        .innerJoin(
+          collectionCards,
+          eq(collections.id, collectionCards.collectionId),
+        )
+        .where(
+          and(
+            eq(collections.authorId, curatorId),
+            eq(collectionCards.cardId, cardId),
+          ),
+        )
+        .orderBy(asc(collections.name));
+
+      return collectionResults.map((result) => ({
+        id: result.id,
+        uri: result.uri || undefined,
+        name: result.name,
+        description: result.description || undefined,
+      }));
+    } catch (error) {
+      console.error('Error in getCollectionsContainingCardForUser:', error);
       throw error;
     }
   }

src/modules/cards/infrastructure/repositories/mappers/CardMapper.ts

···
 
 interface NoteContentData {
   text: string;
-  authorId: string;
 }
 
 type CardContentData = UrlContentData | NoteContentData;
 
+// Persistence layer types
+export interface CardPersistenceData {
+  card: {
+    id: string;
+    authorId: string;
+    type: string;
+    contentData: CardContentData;
+    url?: string;
+    parentCardId?: string;
+    libraryCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+  };
+  libraryMemberships: Array<{
+    cardId: string;
+    userId: string;
+    addedAt: Date;
+    publishedRecordId?: string;
+  }>;
+  publishedRecord?: {
+    id: string;
+    uri: string;
+    cid: string;
+    recordedAt?: Date;
+  };
+  membershipPublishedRecords?: Array<{
+    id: string;
+    uri: string;
+    cid: string;
+    recordedAt?: Date;
+  }>;
+}
+
 // Raw data for URL card queries
 export interface RawUrlCardData {
   id: string;
···
 // Database representation of a card
 export interface CardDTO {
   id: string;
+  curatorId: string;
   type: string;
   contentData: CardContentData; // Type-safe JSON data for the content
   url?: string;
   parentCardId?: string;
-  originalPublishedRecordId?: {
+  publishedRecordId?: {
     uri: string;
     cid: string;
   };
···
 export class CardMapper {
   public static toDomain(dto: CardDTO): Result<Card> {
     try {
+      const curatorIdOrError = CuratorId.create(dto.curatorId);
+      if (curatorIdOrError.isErr()) return err(curatorIdOrError.error);
+
       const cardTypeOrError = CardType.create(dto.type as CardTypeEnum);
       if (cardTypeOrError.isErr()) return err(cardTypeOrError.error);
 
···
         parentCardId = parentCardIdOrError.value;
       }
 
-      // Create optional original published record ID
-      let originalPublishedRecordId: PublishedRecordId | undefined;
-      if (dto.originalPublishedRecordId) {
-        originalPublishedRecordId = PublishedRecordId.create({
-          uri: dto.originalPublishedRecordId.uri,
-          cid: dto.originalPublishedRecordId.cid,
+      // Create optional published record ID
+      let publishedRecordId: PublishedRecordId | undefined;
+      if (dto.publishedRecordId) {
+        publishedRecordId = PublishedRecordId.create({
+          uri: dto.publishedRecordId.uri,
+          cid: dto.publishedRecordId.cid,
         });
       }
       const libraryMemberships = dto.libraryMemberships.map((membership) => {
···
       // Create the card
       const cardOrError = Card.create(
         {
+          curatorId: curatorIdOrError.value,
           type: cardTypeOrError.value,
           content: contentOrError.value,
           url,
           parentCardId,
-          originalPublishedRecordId,
+          publishedRecordId,
           libraryMemberships,
           libraryCount: dto.libraryCount,
           createdAt: dto.createdAt,
···
 
         case CardTypeEnum.NOTE: {
           const noteData = data as NoteContentData;
-          const authorIdResult = CuratorId.create(noteData.authorId);
-          if (authorIdResult.isErr()) return err(authorIdResult.error);
-          return CardContent.createNoteContent(
-            noteData.text,
-            authorIdResult.value,
-          );
+          return CardContent.createNoteContent(noteData.text);
         }
 
         default:
···
     }
   }
 
-  public static toPersistence(card: Card): {
-    card: {
-      id: string;
-      type: string;
-      contentData: CardContentData;
-      url?: string;
-      parentCardId?: string;
-      libraryCount: number;
-      createdAt: Date;
-      updatedAt: Date;
-    };
-    libraryMemberships: Array<{
-      cardId: string;
-      userId: string;
-      addedAt: Date;
-      publishedRecordId?: string;
-    }>;
-    originalPublishedRecord?: {
-      id: string;
-      uri: string;
-      cid: string;
-      recordedAt?: Date;
-    };
-    membershipPublishedRecords?: Array<{
-      id: string;
-      uri: string;
-      cid: string;
-      recordedAt?: Date;
-    }>;
-  } {
+  public static toPersistence(card: Card): CardPersistenceData {
     const content = card.content;
     let contentData: CardContentData;
 
···
       } as UrlContentData;
     } else if (content.type === CardTypeEnum.NOTE) {
       const noteContent = content.noteContent!;
-      // For note content, we need to get the author ID from the content
-      // Since NoteCardContent now has authorId, we need to access it
       contentData = {
         text: noteContent.text,
-        authorId: (noteContent as any).props.authorId.value, // Access the authorId from props
       } as NoteContentData;
     } else {
       throw new Error(`Unknown card type: ${content.type}`);
     }
 
     // Collect all published records that need to be created
-    const originalPublishedRecord = card.originalPublishedRecordId
+    const publishedRecord = card.publishedRecordId
       ? {
           id: uuid(),
-          uri: card.originalPublishedRecordId.uri,
-          cid: card.originalPublishedRecordId.cid,
+          uri: card.publishedRecordId.uri,
+          cid: card.publishedRecordId.cid,
         }
       : undefined;
 
···
     return {
       card: {
         id: card.cardId.getStringValue(),
+        authorId: card.curatorId.value,
         type: card.type.value,
         contentData,
         url: card.url?.value,
···
         updatedAt: card.updatedAt,
       },
       libraryMemberships,
-      originalPublishedRecord,
+      publishedRecord,
       membershipPublishedRecords:
         membershipPublishedRecords.length > 0
           ? membershipPublishedRecords

src/modules/cards/infrastructure/repositories/schema/card.sql.ts

···
   jsonb,
   uuid,
   integer,
+  index,
   type PgTableWithColumns,
 } from 'drizzle-orm/pg-core';
 import { publishedRecords } from './publishedRecord.sql';
 
-export const cards: PgTableWithColumns<any> = pgTable('cards', {
-  id: uuid('id').primaryKey(),
-  type: text('type').notNull(), // URL, NOTE, HIGHLIGHT
-  contentData: jsonb('content_data').notNull(),
-  url: text('url'), // Optional URL field for all card types
-  parentCardId: uuid('parent_card_id').references(() => cards.id),
-  originalPublishedRecordId: uuid('original_published_record_id').references(
-    () => publishedRecords.id,
-  ),
-  libraryCount: integer('library_count').notNull().default(0),
-  createdAt: timestamp('created_at').notNull().defaultNow(),
-  updatedAt: timestamp('updated_at').notNull().defaultNow(),
-});
+export const cards: PgTableWithColumns<any> = pgTable(
+  'cards',
+  {
+    id: uuid('id').primaryKey(),
+    authorId: text('author_id').notNull(),
+    type: text('type').notNull(), // URL, NOTE, HIGHLIGHT
+    contentData: jsonb('content_data').notNull(),
+    url: text('url'), // Optional URL field for all card types
+    parentCardId: uuid('parent_card_id').references(() => cards.id),
+    publishedRecordId: uuid('published_record_id').references(
+      () => publishedRecords.id,
+    ),
+    libraryCount: integer('library_count').notNull().default(0),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => {
+    return {
+      // Critical for findUsersUrlCardByUrl queries
+      authorUrlIdx: index('cards_author_url_idx').on(table.authorId, table.url),
+
+      // For general card queries by author
+      authorIdIdx: index('cards_author_id_idx').on(table.authorId),
+    };
+  },
+);

src/modules/cards/infrastructure/repositories/schema/collection.sql.ts

···
   uuid,
   boolean,
   integer,
+  index,
 } from 'drizzle-orm/pg-core';
 import { publishedRecords } from './publishedRecord.sql';
 import { cards } from './card.sql';
 
-export const collections = pgTable('collections', {
-  id: uuid('id').primaryKey(),
-  authorId: text('author_id').notNull(),
-  name: text('name').notNull(),
-  description: text('description'),
-  accessType: text('access_type').notNull(), // OPEN, CLOSED
-  cardCount: integer('card_count').notNull().default(0),
-  createdAt: timestamp('created_at').notNull().defaultNow(),
-  updatedAt: timestamp('updated_at').notNull().defaultNow(),
-  publishedRecordId: uuid('published_record_id').references(
-    () => publishedRecords.id,
-  ),
-});
+export const collections = pgTable(
+  'collections',
+  {
+    id: uuid('id').primaryKey(),
+    authorId: text('author_id').notNull(),
+    name: text('name').notNull(),
+    description: text('description'),
+    accessType: text('access_type').notNull(), // OPEN, CLOSED
+    cardCount: integer('card_count').notNull().default(0),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+    publishedRecordId: uuid('published_record_id').references(
+      () => publishedRecords.id,
+    ),
+  },
+  (table) => {
+    return {
+      // Critical for all collection queries by user
+      authorIdIdx: index('collections_author_id_idx').on(table.authorId),
+
+      // For paginated collection listings (most common sort)
+      authorUpdatedAtIdx: index('collections_author_updated_at_idx').on(
+        table.authorId,
+        table.updatedAt,
+      ),
+    };
+  },
+);
 
 // Join table for collection collaborators
 export const collectionCollaborators = pgTable('collection_collaborators', {
···
 });
 
 // Join table for cards in collections
-export const collectionCards = pgTable('collection_cards', {
-  id: uuid('id').primaryKey(),
-  collectionId: uuid('collection_id')
-    .notNull()
-    .references(() => collections.id, { onDelete: 'cascade' }),
-  cardId: uuid('card_id')
-    .notNull()
-    .references(() => cards.id, { onDelete: 'cascade' }),
-  addedBy: text('added_by').notNull(),
-  addedAt: timestamp('added_at').notNull().defaultNow(),
-  publishedRecordId: uuid('published_record_id').references(
-    () => publishedRecords.id,
-  ),
-});
+export const collectionCards = pgTable(
+  'collection_cards',
+  {
+    id: uuid('id').primaryKey(),
+    collectionId: uuid('collection_id')
+      .notNull()
+      .references(() => collections.id, { onDelete: 'cascade' }),
+    cardId: uuid('card_id')
+      .notNull()
+      .references(() => cards.id, { onDelete: 'cascade' }),
+    addedBy: text('added_by').notNull(),
+    addedAt: timestamp('added_at').notNull().defaultNow(),
+    publishedRecordId: uuid('published_record_id').references(
+      () => publishedRecords.id,
+    ),
+  },
+  (table) => {
+    return {
+      // Critical for getCollectionsContainingCardForUser queries
+      cardIdIdx: index('collection_cards_card_id_idx').on(table.cardId),
+      collectionIdIdx: index('collection_cards_collection_id_idx').on(
+        table.collectionId,
+      ),
+    };
+  },
+);

src/modules/cards/tests/application/AddCardToLibraryUseCase.test.ts

···
 import { CollectionBuilder } from '../utils/builders/CollectionBuilder';
 import { CardBuilder } from '../utils/builders/CardBuilder';
 import { CardTypeEnum } from '../../domain/value-objects/CardType';
+import { CARD_ERROR_MESSAGES } from '../../domain/Card';
 
 describe('AddCardToLibraryUseCase', () => {
   let useCase: AddCardToLibraryUseCase;
···
   let cardLibraryService: CardLibraryService;
   let cardCollectionService: CardCollectionService;
   let curatorId: CuratorId;
+  let curatorId2: CuratorId;
 
   beforeEach(() => {
     cardRepository = new InMemoryCardRepository();
···
     );
 
     curatorId = CuratorId.create('did:plc:testcurator').unwrap();
+    curatorId2 = CuratorId.create('did:plc:testcurator2').unwrap();
   });
 
   afterEach(() => {
···
   });
 
   describe('Basic card addition to library', () => {
-    it('should add an existing card to library', async () => {
+    it('should not allow adding an existing url card to library', async () => {
       // Create and save a card first
       const card = new CardBuilder()
         .withCuratorId(curatorId.value)
···
         throw new Error(`Failed to create card: ${card.message}`);
       }
 
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        throw new Error(
+          `Failed to add card to library: ${addToLibResult.error.message}`,
+        );
+      }
+
       await cardRepository.save(card);
 
       const request = {
         cardId: card.cardId.getStringValue(),
-        curatorId: curatorId.value,
+        curatorId: curatorId2.value,
       };
 
       const result = await useCase.execute(request);
 
-      expect(result.isOk()).toBe(true);
-      const response = result.unwrap();
-      expect(response.cardId).toBe(card.cardId.getStringValue());
-
-      // Verify card was published to library
-      const publishedCards = cardPublisher.getPublishedCards();
-      expect(publishedCards).toHaveLength(1);
-      expect(publishedCards[0]?.cardId.getStringValue()).toBe(
-        card.cardId.getStringValue(),
+      if (result.isOk()) {
+        throw new Error('Expected use case to fail, but it succeeded');
+      }
+      expect(result.isErr()).toBe(true);
+      expect(result.error.message).toContain(
+        CARD_ERROR_MESSAGES.URL_CARD_SINGLE_LIBRARY_ONLY,
       );
     });
 

src/modules/cards/tests/application/AddUrlToLibraryUseCase.test.ts

···
       );
       expect(urlCards).toHaveLength(1); // Only one URL card
     });
+
+    it('should create new URL card when another user has URL card with same URL', async () => {
+      const url = 'https://example.com/shared';
+      const otherCuratorId = CuratorId.create('did:plc:othercurator').unwrap();
+
+      // First user creates URL card
+      const firstRequest = {
+        url,
+        curatorId: otherCuratorId.value,
+      };
+
+      const firstResult = await useCase.execute(firstRequest);
+      expect(firstResult.isOk()).toBe(true);
+      const firstResponse = firstResult.unwrap();
+
+      // Second user (different curator) should create their own URL card
+      const secondRequest = {
+        url,
+        curatorId: curatorId.value,
+      };
+
+      const secondResult = await useCase.execute(secondRequest);
+      expect(secondResult.isOk()).toBe(true);
+      const secondResponse = secondResult.unwrap();
+
+      // Should have different URL card IDs
+      expect(secondResponse.urlCardId).not.toBe(firstResponse.urlCardId);
+
+      // Should have two separate URL cards
+      const savedCards = cardRepository.getAllCards();
+      expect(savedCards).toHaveLength(2);
+
+      const urlCards = savedCards.filter(
+        (card) => card.content.type === CardTypeEnum.URL,
+      );
+      expect(urlCards).toHaveLength(2); // Two separate URL cards
+
+      // Verify each card belongs to the correct curator
+      const firstUserCard = urlCards.find((card) =>
+        card.props.curatorId.equals(otherCuratorId),
+      );
+      const secondUserCard = urlCards.find((card) =>
+        card.props.curatorId.equals(curatorId),
+      );
+
+      expect(firstUserCard).toBeDefined();
+      expect(secondUserCard).toBeDefined();
+    });
+
+    it('should create new URL card when no one has URL card with that URL yet', async () => {
+      const url = 'https://example.com/brand-new';
+
+      // Verify no cards exist initially
+      expect(cardRepository.getAllCards()).toHaveLength(0);
+
+      const request = {
+        url,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(request);
+
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+      expect(response.urlCardId).toBeDefined();
+
+      // Verify new URL card was created
+      const savedCards = cardRepository.getAllCards();
+      expect(savedCards).toHaveLength(1);
+
+      const urlCard = savedCards[0];
+      expect(urlCard?.content.type).toBe(CardTypeEnum.URL);
+      expect(urlCard?.props.curatorId.equals(curatorId)).toBe(true);
+    });
   });
 
   describe('Collection handling', () => {

src/modules/cards/tests/application/GetCollectionPageUseCase.test.ts

···
       ).unwrap();
 
       const card1Result = Card.create({
+        curatorId: curatorId,
         type: cardType1,
         content: cardContent1,
         url: url1,
···
       ).unwrap();
 
       const card2Result = Card.create({
+        curatorId: curatorId,
         type: cardType2,
         content: cardContent2,
         url: url2,
···
       ).unwrap();
 
       const cardResult = Card.create({
+        curatorId: curatorId,
         type: cardType,
         content: cardContent,
         url: url,
···
 
       // Create a note card that references the same URL
       const noteCardResult = Card.create({
+        curatorId: curatorId,
         type: CardType.create(CardTypeEnum.NOTE).unwrap(),
         content: CardContent.createNoteContent(
           'This is my note about the article',
-          curatorId,
         ).unwrap(),
         parentCardId: card.cardId,
         url: url,
···
         ).unwrap();
 
         const cardResult = Card.create({
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
       // Create URL cards with different properties for sorting
       const now = new Date();
 
-      // Create Alpha card
+      // Create Alpha card (oldest created, middle updated)
       const alphaMetadata = UrlMetadata.create({
         url: 'https://example.com/alpha',
         title: 'Alpha Article',
···
       ).unwrap();
 
       const alphaCardResult = Card.create({
+        curatorId: curatorId,
         type: alphaCardType,
         content: alphaCardContent,
         url: alphaUrl,
···
           { curatorId: curatorId, addedAt: new Date(now.getTime() - 5000) },
         ],
         libraryCount: 1,
-        createdAt: new Date(now.getTime() - 2000),
-        updatedAt: new Date(now.getTime() - 1000),
+        createdAt: new Date(now.getTime() - 3000), // oldest
+        updatedAt: new Date(now.getTime() - 1000), // middle
       });
 
       if (alphaCardResult.isErr()) {
···
 
       await cardRepo.save(alphaCardResult.value);
 
-      // Create Beta card
+      // Create Beta card (middle created, oldest updated)
       const betaMetadata = UrlMetadata.create({
         url: 'https://example.com/beta',
         title: 'Beta Article',
···
       ).unwrap();
 
       const betaCardResult = Card.create({
+        curatorId: curatorId,
         type: betaCardType,
         content: betaCardContent,
         url: betaUrl,
         libraryMemberships: [
           { curatorId: curatorId, addedAt: new Date(now.getTime() - 5000) },
-          {
-            curatorId: CuratorId.create('did:plc:anothercurator').unwrap(),
-            addedAt: new Date(now.getTime() - 2000),
-          },
-          {
-            curatorId: CuratorId.create('did:plc:thirdcurator').unwrap(),
-            addedAt: new Date(now.getTime() - 1000),
-          },
         ],
-        libraryCount: 3,
-        createdAt: new Date(now.getTime() - 1000),
-        updatedAt: new Date(now.getTime() - 2000),
+        libraryCount: 1,
+        createdAt: new Date(now.getTime() - 2000), // middle
+        updatedAt: new Date(now.getTime() - 3000), // oldest
       });
 
       if (betaCardResult.isErr()) {
···
 
       await cardRepo.save(betaCardResult.value);
 
-      // Create Gamma card
+      // Create Gamma card (newest created, newest updated)
       const gammaMetadata = UrlMetadata.create({
         url: 'https://example.com/gamma',
         title: 'Gamma Article',
···
       ).unwrap();
 
       const gammaCardResult = Card.create({
+        curatorId: curatorId,
         type: gammaCardType,
         content: gammaCardContent,
         url: gammaUrl,
         libraryMemberships: [
           { curatorId: curatorId, addedAt: new Date(now.getTime() - 3000) },
-          {
-            curatorId: CuratorId.create('did:plc:anothercurator').unwrap(),
-            addedAt: new Date(now.getTime() - 1000),
-          },
         ],
-        libraryCount: 2,
-        createdAt: new Date(now.getTime()),
-        updatedAt: new Date(now.getTime()),
+        libraryCount: 1,
+        createdAt: new Date(now.getTime() - 1000), // newest
+        updatedAt: new Date(now.getTime()), // newest
       });
 
       if (gammaCardResult.isErr()) {
···
       await collectionRepo.save(collection);
     });
 
-    it('should sort by library count descending', async () => {
+    it('should sort by updated date descending', async () => {
       const query = {
         collectionId: collectionId.getStringValue(),
-        sortBy: CardSortField.LIBRARY_COUNT,
+        sortBy: CardSortField.UPDATED_AT,
         sortOrder: SortOrder.DESC,
       };
 
···
 
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
-      expect(response.urlCards).toHaveLength(3);
-      expect(response.urlCards[0]?.libraryCount).toBe(3); // beta
-      expect(response.urlCards[1]?.libraryCount).toBe(2); // gamma
-      expect(response.urlCards[2]?.libraryCount).toBe(1); // alpha
-      expect(response.sorting.sortBy).toBe(CardSortField.LIBRARY_COUNT);
-      expect(response.sorting.sortOrder).toBe(SortOrder.DESC);
+      expect(response.urlCards[0]?.cardContent.title).toBe('Gamma Article'); // newest updated
+      expect(response.urlCards[1]?.cardContent.title).toBe('Alpha Article'); // middle updated
+      expect(response.urlCards[2]?.cardContent.title).toBe('Beta Article'); // oldest updated
     });
 
-    it('should sort by library count ascending', async () => {
+    it('should sort by created date ascending', async () => {
       const query = {
         collectionId: collectionId.getStringValue(),
-        sortBy: CardSortField.LIBRARY_COUNT,
+        sortBy: CardSortField.CREATED_AT,
         sortOrder: SortOrder.ASC,
       };
 
···
 
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
-      expect(response.urlCards[0]?.libraryCount).toBe(1); // alpha
-      expect(response.urlCards[1]?.libraryCount).toBe(2); // gamma
-      expect(response.urlCards[2]?.libraryCount).toBe(3); // beta
+      expect(response.urlCards[0]?.cardContent.title).toBe('Alpha Article'); // oldest created
+      expect(response.urlCards[1]?.cardContent.title).toBe('Beta Article'); // middle created
+      expect(response.urlCards[2]?.cardContent.title).toBe('Gamma Article'); // newest created
     });
 
-    it('should sort by updated date descending', async () => {
+    it('should sort by library count (all URL cards have same count)', async () => {
       const query = {
         collectionId: collectionId.getStringValue(),
-        sortBy: CardSortField.UPDATED_AT,
+        sortBy: CardSortField.LIBRARY_COUNT,
         sortOrder: SortOrder.DESC,
       };
 
···
 
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
-      expect(response.urlCards[0]?.cardContent.title).toBe('Gamma Article'); // most recent
-      expect(response.urlCards[1]?.cardContent.title).toBe('Alpha Article');
-      expect(response.urlCards[2]?.cardContent.title).toBe('Beta Article'); // oldest
-    });
-
-    it('should sort by created date ascending', async () => {
-      const query = {
-        collectionId: collectionId.getStringValue(),
-        sortBy: CardSortField.CREATED_AT,
-        sortOrder: SortOrder.ASC,
-      };
-
-      const result = await useCase.execute(query);
-
-      expect(result.isOk()).toBe(true);
-      const response = result.unwrap();
-      expect(response.urlCards[0]?.cardContent.title).toBe('Alpha Article'); // oldest
-      expect(response.urlCards[1]?.cardContent.title).toBe('Beta Article');
-      expect(response.urlCards[2]?.cardContent.title).toBe('Gamma Article'); // newest
+      expect(response.urlCards).toHaveLength(3);
+      // All URL cards have library count of 1 (only creator's library)
+      expect(response.urlCards[0]?.libraryCount).toBe(1);
+      expect(response.urlCards[1]?.libraryCount).toBe(1);
+      expect(response.urlCards[2]?.libraryCount).toBe(1);
+      expect(response.sorting.sortBy).toBe(CardSortField.LIBRARY_COUNT);
+      expect(response.sorting.sortOrder).toBe(SortOrder.DESC);
     });
 
     it('should use default sorting when not specified', async () => {
···
       const cardContent = CardContent.createUrlContent(url).unwrap();
 
       const cardResult = Card.create({
+        curatorId: curatorId,
         type: cardType,
         content: cardContent,
         url: url,

src/modules/cards/tests/application/GetMyUrlCardsUseCase.test.ts

···
 
       const cardResult1 = Card.create(
         {
+          curatorId: curatorId,
           type: cardType1,
           content: cardContent1,
           url: url1,
···
 
       const cardResult2 = Card.create(
         {
+          curatorId: curatorId,
           type: cardType2,
           content: cardContent2,
           url: url2,
           libraryMemberships: [
             { curatorId: curatorId, addedAt: new Date('2023-01-02') },
-            {
-              curatorId: CuratorId.create('did:plc:othercurator').unwrap(),
-              addedAt: new Date('2023-01-03'),
-            },
           ],
+          libraryCount: 1,
           createdAt: new Date('2023-01-02'),
           updatedAt: new Date('2023-01-02'),
         },
···
 
       expect(secondCard).toBeDefined();
       expect(secondCard?.cardContent.title).toBe('Second Article');
-      expect(secondCard?.libraryCount).toBe(2);
+      expect(secondCard?.libraryCount).toBe(1);
     });
 
     it('should include collections and notes in URL cards', async () => {
···
       // Create card
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
 
       const myCardResult = Card.create(
         {
+          curatorId: curatorId,
           type: myCardType,
           content: myCardContent,
           url: myUrl,
···
 
       const otherCardResult = Card.create(
         {
+          curatorId: otherCuratorId,
           type: otherCardType,
           content: otherCardContent,
           url: otherUrl,
···
 
         const cardResult = Card.create(
           {
+            curatorId: curatorId,
             type: cardType,
             content: cardContent,
             url: url,
···
 
       const alphaCardResult = Card.create(
         {
+          curatorId: curatorId,
           type: alphaCardType,
           content: alphaCardContent,
           url: alphaUrl,
···
 
       const betaCardResult = Card.create(
         {
+          curatorId: curatorId,
           type: betaCardType,
           content: betaCardContent,
           url: betaUrl,
           libraryMemberships: [
             { curatorId: curatorId, addedAt: new Date(now.getTime() - 1000) },
-            {
-              curatorId: CuratorId.create('did:plc:othercurator').unwrap(),
-              addedAt: new Date(now.getTime() - 500),
-            },
-            {
-              curatorId: CuratorId.create('did:plc:thirdcurator').unwrap(),
-              addedAt: new Date(now.getTime() - 300),
-            },
           ],
-          libraryCount: 3,
+          libraryCount: 1,
           createdAt: new Date(now.getTime() - 1000),
           updatedAt: new Date(now.getTime() - 2000),
         },
···
 
       const gammaCardResult = Card.create(
         {
+          curatorId: curatorId,
           type: gammaCardType,
           content: gammaCardContent,
           url: gammaUrl,
           libraryMemberships: [
             { curatorId: curatorId, addedAt: new Date(now.getTime()) },
-            {
-              curatorId: CuratorId.create('did:plc:anothercurator').unwrap(),
-              addedAt: new Date(now.getTime() - 100),
-            },
           ],
-          libraryCount: 2,
+          libraryCount: 1,
           createdAt: new Date(now.getTime()),
           updatedAt: new Date(now.getTime()),
         },
···
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
       expect(response.cards).toHaveLength(3);
-      expect(response.cards[0]?.libraryCount).toBe(3); // beta
-      expect(response.cards[1]?.libraryCount).toBe(2); // gamma
-      expect(response.cards[2]?.libraryCount).toBe(1); // alpha
+      // All URL cards now have libraryCount of 1, so order will be by secondary sort (likely creation time)
+      expect(response.cards[0]?.libraryCount).toBe(1); // gamma (newest)
+      expect(response.cards[1]?.libraryCount).toBe(1); // beta
+      expect(response.cards[2]?.libraryCount).toBe(1); // alpha (oldest)
       expect(response.sorting.sortBy).toBe(CardSortField.LIBRARY_COUNT);
       expect(response.sorting.sortOrder).toBe(SortOrder.DESC);
     });
···
 
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
-      expect(response.cards[0]?.libraryCount).toBe(1); // alpha
-      expect(response.cards[1]?.libraryCount).toBe(2); // gamma
-      expect(response.cards[2]?.libraryCount).toBe(3); // beta
+      // All URL cards now have libraryCount of 1, so order will be by secondary sort (likely creation time)
+      expect(response.cards[0]?.libraryCount).toBe(1); // alpha (oldest)
+      expect(response.cards[1]?.libraryCount).toBe(1); // beta
+      expect(response.cards[2]?.libraryCount).toBe(1); // gamma (newest)
     });
 
     it('should sort by updated date descending', async () => {
···
 
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
 
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,

src/modules/cards/tests/application/GetUrlCardViewUseCase.test.ts

···
 import { InMemoryCollectionRepository } from '../utils/InMemoryCollectionRepository';
 import { FakeProfileService } from '../utils/FakeProfileService';
 import { CuratorId } from '../../domain/value-objects/CuratorId';
-import { CardId } from '../../domain/value-objects/CardId';
 import { Card } from '../../domain/Card';
 import { CardType, CardTypeEnum } from '../../domain/value-objects/CardType';
 import { CardContent } from '../../domain/value-objects/CardContent';
···
       // Create card with library memberships
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
           libraryMemberships: [
             { curatorId: curatorId, addedAt: new Date('2023-01-01') },
-            { curatorId: otherCuratorId, addedAt: new Date('2023-01-01') },
           ],
-          libraryCount: 2,
+          libraryCount: 1,
           createdAt: new Date('2023-01-01'),
           updatedAt: new Date('2023-01-01'),
         },
···
 
       // now create a note card that references this URL card
       const noteCardResult = Card.create({
+        curatorId: curatorId,
         type: CardType.create(CardTypeEnum.NOTE).unwrap(),
         content: CardContent.createNoteContent(
           'This is my note about the article',
-          curatorId,
         ).unwrap(),
         parentCardId: card.cardId,
         url: url,
···
       expect(response.cardContent.thumbnailUrl).toBe(
         'https://example.com/thumb1.jpg',
       );
-      expect(response.libraryCount).toBe(2);
+      expect(response.libraryCount).toBe(1);
 
       // Verify collections
       expect(response.collections).toHaveLength(1);
···
       expect(response.note?.text).toBe('This is my note about the article');
 
       // Verify enriched library data
-      expect(response.libraries).toHaveLength(2);
+      expect(response.libraries).toHaveLength(1);
 
       const testCuratorLib = response.libraries.find(
         (lib) => lib.userId === curatorId.value,
···
       expect(testCuratorLib?.name).toBe('Test Curator');
       expect(testCuratorLib?.handle).toBe('testcurator');
       expect(testCuratorLib?.avatarUrl).toBe('https://example.com/avatar1.jpg');
-
-      const otherCuratorLib = response.libraries.find(
-        (lib) => lib.userId === otherCuratorId.value,
-      );
-      expect(otherCuratorLib).toBeDefined();
-      expect(otherCuratorLib?.name).toBe('Other Curator');
-      expect(otherCuratorLib?.handle).toBe('othercurator');
-      expect(otherCuratorLib?.avatarUrl).toBe(
-        'https://example.com/avatar2.jpg',
-      );
     });
 
     it('should return URL card view with no libraries', async () => {
···
       // Create card with no library memberships
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
       // Create card with minimal data
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
       // Create card
       const cardResult = Card.create(
         {
+          curatorId: minimalCuratorId,
           type: cardType,
           content: cardContent,
           url: url,
···
       // Create card
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,
···
       // Create card with unknown user in library
       const cardResult = Card.create(
         {
+          curatorId: unknownCuratorId,
           type: cardType,
           content: cardContent,
           url: url,
···
         urlMetadata,
       ).unwrap();
 
-      // Create card with multiple library memberships
+      // Create card with single library membership (URL cards can only be in creator's library)
       const cardResult = Card.create(
         {
+          curatorId: curatorIds[0]!,
           type: cardType,
           content: cardContent,
           url: url,
-          libraryMemberships: curatorIds.map((curatorId) => ({
-            curatorId: curatorId,
-            addedAt: new Date(),
-          })),
-          libraryCount: 5,
+          libraryMemberships: [
+            {
+              curatorId: curatorIds[0]!,
+              addedAt: new Date(),
+            },
+          ],
+          libraryCount: 1,
           createdAt: new Date(),
           updatedAt: new Date(),
         },
···
 
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
-      expect(response.libraries).toHaveLength(5);
+      expect(response.libraries).toHaveLength(1);
 
-      // Verify all users are included with correct profile data
-      userIds.forEach((userId, index) => {
-        const userLib = response.libraries.find((lib) => lib.userId === userId);
-        expect(userLib).toBeDefined();
-        expect(userLib?.name).toBe(`User ${index + 1}`);
-        expect(userLib?.handle).toBe(`user${index + 1}`);
-        expect(userLib?.avatarUrl).toBe(
-          `https://example.com/avatar${index + 1}.jpg`,
-        );
-      });
+      // Verify the creator is included with correct profile data
+      const creatorLib = response.libraries.find(
+        (lib) => lib.userId === userIds[0],
+      );
+      expect(creatorLib).toBeDefined();
+      expect(creatorLib?.name).toBe('User 1');
+      expect(creatorLib?.handle).toBe('user1');
+      expect(creatorLib?.avatarUrl).toBe('https://example.com/avatar1.jpg');
     });
 
     it('should handle card with many collections', async () => {
···
       // Create card
       const cardResult = Card.create(
         {
+          curatorId: curatorId,
           type: cardType,
           content: cardContent,
           url: url,

src/modules/cards/tests/application/GetUrlStatusForMyLibraryUseCase.test.ts

···
+import { GetUrlStatusForMyLibraryUseCase } from '../../application/useCases/queries/GetUrlStatusForMyLibraryUseCase';
+import { InMemoryCardRepository } from '../utils/InMemoryCardRepository';
+import { InMemoryCollectionRepository } from '../utils/InMemoryCollectionRepository';
+import { InMemoryCollectionQueryRepository } from '../utils/InMemoryCollectionQueryRepository';
+import { FakeCardPublisher } from '../utils/FakeCardPublisher';
+import { FakeCollectionPublisher } from '../utils/FakeCollectionPublisher';
+import { FakeEventPublisher } from '../utils/FakeEventPublisher';
+import { CuratorId } from '../../domain/value-objects/CuratorId';
+import { CardBuilder } from '../utils/builders/CardBuilder';
+import { CollectionBuilder } from '../utils/builders/CollectionBuilder';
+import { CardTypeEnum } from '../../domain/value-objects/CardType';
+import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId';
+import { URL } from '../../domain/value-objects/URL';
+import { err } from 'src/shared/core/Result';
+
+describe('GetUrlStatusForMyLibraryUseCase', () => {
+  let useCase: GetUrlStatusForMyLibraryUseCase;
+  let cardRepository: InMemoryCardRepository;
+  let collectionRepository: InMemoryCollectionRepository;
+  let collectionQueryRepository: InMemoryCollectionQueryRepository;
+  let cardPublisher: FakeCardPublisher;
+  let collectionPublisher: FakeCollectionPublisher;
+  let eventPublisher: FakeEventPublisher;
+  let curatorId: CuratorId;
+  let otherCuratorId: CuratorId;
+
+  beforeEach(() => {
+    cardRepository = new InMemoryCardRepository();
+    collectionRepository = new InMemoryCollectionRepository();
+    collectionQueryRepository = new InMemoryCollectionQueryRepository(
+      collectionRepository,
+    );
+    cardPublisher = new FakeCardPublisher();
+    collectionPublisher = new FakeCollectionPublisher();
+    eventPublisher = new FakeEventPublisher();
+
+    useCase = new GetUrlStatusForMyLibraryUseCase(
+      cardRepository,
+      collectionQueryRepository,
+      eventPublisher,
+    );
+
+    curatorId = CuratorId.create('did:plc:testcurator').unwrap();
+    otherCuratorId = CuratorId.create('did:plc:othercurator').unwrap();
+  });
+
+  afterEach(() => {
+    cardRepository.clear();
+    collectionRepository.clear();
+    collectionQueryRepository.clear();
+    cardPublisher.clear();
+    collectionPublisher.clear();
+    eventPublisher.clear();
+  });
+
+  describe('URL card in collections', () => {
+    it('should return card ID and collections when user has URL card in multiple collections', async () => {
+      const testUrl = 'https://example.com/test-article';
+
+      // Create a URL card
+      const url = URL.create(testUrl).unwrap();
+      const card = new CardBuilder()
+        .withCuratorId(curatorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card instanceof Error) {
+        throw new Error(`Failed to create card: ${card.message}`);
+      }
+
+      // Add card to library
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        throw new Error(
+          `Failed to add card to library: ${addToLibResult.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card);
+
+      // Publish the card to simulate it being published
+      cardPublisher.publishCardToLibrary(card, curatorId);
+
+      // Create first collection
+      const collection1 = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('Tech Articles')
+        .withDescription('Collection of technology articles')
+        .build();
+
+      if (collection1 instanceof Error) {
+        throw new Error(`Failed to create collection1: ${collection1.message}`);
+      }
+
+      // Create second collection
+      const collection2 = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('Reading List')
+        .withDescription('My personal reading list')
+        .build();
+
+      if (collection2 instanceof Error) {
+        throw new Error(`Failed to create collection2: ${collection2.message}`);
+      }
+
+      // Add card to both collections
+      const addToCollection1Result = collection1.addCard(
+        card.cardId,
+        curatorId,
+      );
+      if (addToCollection1Result.isErr()) {
+        throw new Error(
+          `Failed to add card to collection1: ${addToCollection1Result.error.message}`,
+        );
+      }
+
+      const addToCollection2Result = collection2.addCard(
+        card.cardId,
+        curatorId,
+      );
+      if (addToCollection2Result.isErr()) {
+        throw new Error(
+          `Failed to add card to collection2: ${addToCollection2Result.error.message}`,
+        );
+      }
+
+      // Mark collections as published
+      const collection1PublishedRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection1',
+        cid: 'bafyreicollection1cid',
+      });
+
+      const collection2PublishedRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection2',
+        cid: 'bafyreicollection2cid',
+      });
+
+      collection1.markAsPublished(collection1PublishedRecordId);
+      collection2.markAsPublished(collection2PublishedRecordId);
+
+      // Mark card links as published in collections
+      const cardLinkPublishedRecordId1 = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection1/link1',
+        cid: 'bafyreilink1cid',
+      });
+
+      const cardLinkPublishedRecordId2 = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection2/link2',
+        cid: 'bafyreilink2cid',
+      });
+
+      collection1.markCardLinkAsPublished(
+        card.cardId,
+        cardLinkPublishedRecordId1,
+      );
+      collection2.markCardLinkAsPublished(
+        card.cardId,
+        cardLinkPublishedRecordId2,
+      );
+
+      // Save collections
+      await collectionRepository.save(collection1);
+      await collectionRepository.save(collection2);
+
+      // Publish collections and links
+      collectionPublisher.publish(collection1);
+      collectionPublisher.publish(collection2);
+      collectionPublisher.publishCardAddedToCollection(
+        card,
+        collection1,
+        curatorId,
+      );
+      collectionPublisher.publishCardAddedToCollection(
+        card,
+        collection2,
+        curatorId,
+      );
+
+      // Execute the use case
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      // Verify the result
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+
+      expect(response.cardId).toBe(card.cardId.getStringValue());
+      expect(response.collections).toHaveLength(2);
+
+      // Verify collection details
+      const techArticlesCollection = response.collections?.find(
+        (c) => c.name === 'Tech Articles',
+      );
+      const readingListCollection = response.collections?.find(
+        (c) => c.name === 'Reading List',
+      );
+
+      expect(techArticlesCollection).toBeDefined();
+      expect(techArticlesCollection?.id).toBe(
+        collection1.collectionId.getStringValue(),
+      );
+      expect(techArticlesCollection?.uri).toBe(
+        'at://did:plc:testcurator/network.cosmik.collection/collection1',
+      );
+      expect(techArticlesCollection?.name).toBe('Tech Articles');
+      expect(techArticlesCollection?.description).toBe(
+        'Collection of technology articles',
+      );
+
+      expect(readingListCollection).toBeDefined();
+      expect(readingListCollection?.id).toBe(
+        collection2.collectionId.getStringValue(),
+      );
+      expect(readingListCollection?.uri).toBe(
+        'at://did:plc:testcurator/network.cosmik.collection/collection2',
+      );
+      expect(readingListCollection?.name).toBe('Reading List');
+      expect(readingListCollection?.description).toBe(
+        'My personal reading list',
+      );
+    });
+
+    it('should return card ID and empty collections when user has URL card but not in any collections', async () => {
+      const testUrl = 'https://example.com/standalone-article';
+
+      // Create a URL card
+      const url = URL.create(testUrl).unwrap();
+      const card = new CardBuilder()
+        .withCuratorId(curatorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card instanceof Error) {
+        throw new Error(`Failed to create card: ${card.message}`);
+      }
+
+      // Add card to library
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        throw new Error(
+          `Failed to add card to library: ${addToLibResult.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card);
+
+      // Publish the card
+      cardPublisher.publishCardToLibrary(card, curatorId);
+
+      // Execute the use case
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      // Verify the result
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+
+      expect(response.cardId).toBe(card.cardId.getStringValue());
+      expect(response.collections).toHaveLength(0);
+    });
+
+    it('should return empty result when user does not have URL card for the URL', async () => {
+      const testUrl = 'https://example.com/nonexistent-article';
+
+      // Execute the use case without creating any cards
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      // Verify the result
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+
+      expect(response.cardId).toBeUndefined();
+      expect(response.collections).toBeUndefined();
+    });
+
+    it('should not return collections from other users even if they have the same URL', async () => {
+      const testUrl = 'https://example.com/shared-article';
+
+      // Create URL card for first user
+      const url = URL.create(testUrl).unwrap();
+      const card1 = new CardBuilder()
+        .withCuratorId(curatorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card1 instanceof Error) {
+        throw new Error(`Failed to create card1: ${card1.message}`);
+      }
+
+      const addToLibResult1 = card1.addToLibrary(curatorId);
+      if (addToLibResult1.isErr()) {
+        throw new Error(
+          `Failed to add card1 to library: ${addToLibResult1.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card1);
+
+      // Create URL card for second user (different card, same URL)
+      const card2 = new CardBuilder()
+        .withCuratorId(otherCuratorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card2 instanceof Error) {
+        throw new Error(`Failed to create card2: ${card2.message}`);
+      }
+
+      const addToLibResult2 = card2.addToLibrary(otherCuratorId);
+      if (addToLibResult2.isErr()) {
+        throw new Error(
+          `Failed to add card2 to library: ${addToLibResult2.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card2);
+
+      // Create collection for second user and add their card
+      const otherUserCollection = new CollectionBuilder()
+        .withAuthorId(otherCuratorId.value)
+        .withName('Other User Collection')
+        .build();
+
+      if (otherUserCollection instanceof Error) {
+        throw new Error(
+          `Failed to create other user collection: ${otherUserCollection.message}`,
+        );
+      }
+
+      const addToOtherCollectionResult = otherUserCollection.addCard(
+        card2.cardId,
+        otherCuratorId,
+      );
+      if (addToOtherCollectionResult.isErr()) {
+        throw new Error(
+          `Failed to add card2 to other collection: ${addToOtherCollectionResult.error.message}`,
+        );
+      }
+
+      await collectionRepository.save(otherUserCollection);
+
+      // Execute the use case for first user
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      // Verify the result - should only see first user's card, no collections
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+
+      expect(response.cardId).toBe(card1.cardId.getStringValue());
+      expect(response.collections).toHaveLength(0); // No collections for first user
+    });
+
+    it('should only return collections owned by the requesting user', async () => {
+      const testUrl = 'https://example.com/multi-user-article';
+
+      // Create URL card for the user
+      const url = URL.create(testUrl).unwrap();
+      const card = new CardBuilder()
+        .withCuratorId(curatorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card instanceof Error) {
+        throw new Error(`Failed to create card: ${card.message}`);
+      }
+
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        throw new Error(
+          `Failed to add card to library: ${addToLibResult.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card);
+
+      // Create user's own collection
+      const userCollection = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('My Collection')
+        .build();
+
+      if (userCollection instanceof Error) {
+        throw new Error(
+          `Failed to create user collection: ${userCollection.message}`,
+        );
+      }
+
+      const addToUserCollectionResult = userCollection.addCard(
+        card.cardId,
+        curatorId,
+      );
+      if (addToUserCollectionResult.isErr()) {
+        throw new Error(
+          `Failed to add card to user collection: ${addToUserCollectionResult.error.message}`,
+        );
+      }
+
+      await collectionRepository.save(userCollection);
+
+      // Create another user's collection (this should not appear in results)
+      const otherUserCollection = new CollectionBuilder()
+        .withAuthorId(otherCuratorId.value)
+        .withName('Other User Collection')
+        .build();
+
+      if (otherUserCollection instanceof Error) {
+        throw new Error(
+          `Failed to create other user collection: ${otherUserCollection.message}`,
+        );
+      }
+
+      // Note: We don't add the card to the other user's collection since they can't add
+      // another user's card to their collection in this domain model
+
+      await collectionRepository.save(otherUserCollection);
+
+      // Execute the use case
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      // Verify the result - should only see user's own collection
+      expect(result.isOk()).toBe(true);
+      const response = result.unwrap();
+
+      expect(response.cardId).toBe(card.cardId.getStringValue());
+      expect(response.collections).toHaveLength(1);
+      expect(response.collections?.[0]?.name).toBe('My Collection');
+      expect(response.collections?.[0]?.id).toBe(
+        userCollection.collectionId.getStringValue(),
+      );
+    });
+  });
+
+  describe('Validation', () => {
+    it('should fail with invalid URL', async () => {
+      const query = {
+        url: 'not-a-valid-url',
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(query);
+
+      expect(result.isErr()).toBe(true);
+      if (result.isErr()) {
+        expect(result.error.message).toContain('Invalid URL');
+      }
+    });
+
+    it('should fail with invalid curator ID', async () => {
+      const query = {
+        url: 'https://example.com/valid-url',
+        curatorId: 'invalid-curator-id',
+      };
+
+      const result = await useCase.execute(query);
+
+      expect(result.isErr()).toBe(true);
+      if (result.isErr()) {
+        expect(result.error.message).toContain('Invalid curator ID');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle repository errors gracefully', async () => {
+      // Create a mock repository that returns an error Result
+      const errorCardRepository = {
+        findUsersUrlCardByUrl: jest
+          .fn()
+          .mockResolvedValue(err(new Error('Database error'))),
+        save: jest.fn(),
+        findById: jest.fn(),
+        delete: jest.fn(),
+        findByUrl: jest.fn(),
+        findByCuratorId: jest.fn(),
+        findByParentCardId: jest.fn(),
+      };
+
+      const errorUseCase = new GetUrlStatusForMyLibraryUseCase(
+        errorCardRepository,
+        collectionQueryRepository,
+        eventPublisher,
+      );
+
+      const query = {
+        url: 'https://example.com/test-url',
+        curatorId: curatorId.value,
+      };
+
+      const result = await errorUseCase.execute(query);
+
+      expect(result.isErr()).toBe(true);
+      if (result.isErr()) {
+        expect(result.error.message).toContain('Database error');
+      }
+    });
+
+    it('should handle collection query repository errors gracefully', async () => {
+      const testUrl = 'https://example.com/error-test';
+
+      // Create a URL card
+      const url = URL.create(testUrl).unwrap();
+      const card = new CardBuilder()
+        .withCuratorId(curatorId.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .build();
+
+      if (card instanceof Error) {
+        throw new Error(`Failed to create card: ${card.message}`);
+      }
+
+      const addToLibResult = card.addToLibrary(curatorId);
+      if (addToLibResult.isErr()) {
+        throw new Error(
+          `Failed to add card to library: ${addToLibResult.error.message}`,
+        );
+      }
+
+      await cardRepository.save(card);
+
+      // Create a mock collection query repository that throws an error
+      const errorCollectionQueryRepository = {
+        findByCreator: jest.fn(),
+        getCollectionsContainingCardForUser: jest
+          .fn()
+          .mockRejectedValue(new Error('Collection query error')),
+      };
+
+      const errorUseCase = new GetUrlStatusForMyLibraryUseCase(
+        cardRepository,
+        errorCollectionQueryRepository,
+        eventPublisher,
+      );
+
+      const query = {
+        url: testUrl,
+        curatorId: curatorId.value,
+      };
+
+      const result = await errorUseCase.execute(query);
+
+      expect(result.isErr()).toBe(true);
+      if (result.isErr()) {
+        expect(result.error.message).toContain('Collection query error');
+      }
+    });
+  });
+});

src/modules/cards/tests/application/RemoveCardFromLibraryUseCase.test.ts

···
     cardPublisher.clear();
   });
 
-  const createCard = async (type: CardTypeEnum = CardTypeEnum.URL) => {
-    const card = new CardBuilder().withType(type).build();
+  const createCard = async (
+    type: CardTypeEnum = CardTypeEnum.URL,
+    creatorId: CuratorId = curatorId,
+  ) => {
+    const card = new CardBuilder()
+      .withType(type)
+      .withCuratorId(creatorId.value)
+      .build();
 
     if (card instanceof Error) {
       throw new Error(`Failed to create card: ${card.message}`);
···
   };
 
   const addCardToLibrary = async (card: any, curatorId: CuratorId) => {
+    // For URL cards, can only add to creator's library
+    if (card.isUrlCard && !card.curatorId.equals(curatorId)) {
+      throw new Error("URL cards can only be added to creator's library");
+    }
+
     const addResult = await cardLibraryService.addCardToLibrary(
       card,
       curatorId,
···
       const response = result.unwrap();
       expect(response.cardId).toBe(card.cardId.getStringValue());
 
-      // Verify card was removed from library
+      // Verify card was removed from library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
 
       // Verify unpublish operation occurred
       const unpublishedCards = cardPublisher.getUnpublishedCards();
       expect(unpublishedCards).toHaveLength(1);
     });
 
-    it("should remove card from one user's library without affecting others", async () => {
+    it("should remove URL card from creator's library", async () => {
       const card = await createCard();
 
-      // Add card to both users' libraries
+      // Add card to creator's library only (URL cards can only be in creator's library)
       await addCardToLibrary(card, curatorId);
-      await addCardToLibrary(card, otherCuratorId);
 
       const request = {
         cardId: card.cardId.getStringValue(),
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card was removed from curatorId's library but not otherCuratorId's
+      // Verify card was removed from creator's library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
-      expect(updatedCard.isInLibrary(otherCuratorId)).toBe(true);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
 
-      // Verify only one unpublish operation occurred
+      // Verify unpublish operation occurred
       const unpublishedCards = cardPublisher.getUnpublishedCards();
       expect(unpublishedCards).toHaveLength(1);
     });
 
     it('should handle different card types', async () => {
-      const urlCard = await createCard(CardTypeEnum.URL);
-      const noteCard = await createCard(CardTypeEnum.NOTE);
+      // Create URL card with curatorId as creator
+      const urlCard = await createCard(CardTypeEnum.URL, curatorId);
+      // Create note card with curatorId as creator
+      const noteCard = await createCard(CardTypeEnum.NOTE, curatorId);
 
       await addCardToLibrary(urlCard, curatorId);
       await addCardToLibrary(noteCard, curatorId);
···
       const noteResult = await useCase.execute(noteRequest);
       expect(noteResult.isOk()).toBe(true);
 
-      // Verify both cards were removed
+      // Verify both cards were removed from library and deleted (since they're no longer in any libraries and curator is owner)
       const updatedUrlCardResult = await cardRepository.findById(
         urlCard.cardId,
       );
···
         noteCard.cardId,
       );
 
-      const updatedUrlCard = updatedUrlCardResult.unwrap()!;
-      const updatedNoteCard = updatedNoteCardResult.unwrap()!;
+      const updatedUrlCard = updatedUrlCardResult.unwrap();
+      const updatedNoteCard = updatedNoteCardResult.unwrap();
 
-      expect(updatedUrlCard.isInLibrary(curatorId)).toBe(false);
-      expect(updatedNoteCard.isInLibrary(curatorId)).toBe(false);
+      expect(updatedUrlCard).toBeNull();
+      expect(updatedNoteCard).toBeNull();
     });
   });
 
···
       const finalUnpublishCount = cardPublisher.getUnpublishedCards().length;
       expect(finalUnpublishCount).toBe(initialUnpublishCount);
 
-      // Verify card was still removed from library
+      // Verify card was still removed from library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
     });
   });
 
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card was removed from library
+      // Verify card was removed from library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
 
       // Verify card was removed from all collections
       const finalCollection1Result = await collectionRepository.findById(
···
       expect(unpublishedCollectionLinks).toHaveLength(3);
     });
 
-    it('should only remove card from curator collections, not other curator collections', async () => {
+    it('should remove URL card from creator collections only', async () => {
       const card = await createCard();
       await addCardToLibrary(card, curatorId);
-      await addCardToLibrary(card, otherCuratorId);
 
-      // Create collections for both curators
+      // Create collections for the creator only (URL cards can only be in creator's library)
       const curatorCollection = await createCollection(
         curatorId,
         'Curator Collection',
       );
-      const otherCuratorCollection = await createCollection(
-        otherCuratorId,
-        'Other Curator Collection',
-      );
 
-      // Add card to both collections
+      // Add card to creator's collection
       await addCardToCollection(card, curatorCollection, curatorId);
-      await addCardToCollection(card, otherCuratorCollection, otherCuratorId);
 
-      // Remove card from first curator's library
+      // Remove card from creator's library
       const request = {
         cardId: card.cardId.getStringValue(),
         curatorId: curatorId.value,
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card was removed from curator's collection but not other curator's collection
+      // Verify card was removed from curator's collection
       const curatorCollectionResult = await collectionRepository.findById(
         curatorCollection.collectionId,
       );
-      const otherCuratorCollectionResult = await collectionRepository.findById(
-        otherCuratorCollection.collectionId,
-      );
 
       expect(
         curatorCollectionResult
           .unwrap()!
           .cardIds.some((id) => id.equals(card.cardId)),
       ).toBe(false);
-      expect(
-        otherCuratorCollectionResult
-          .unwrap()!
-          .cardIds.some((id) => id.equals(card.cardId)),
-      ).toBe(true);
 
-      // Verify card is still in other curator's library
+      // Verify card was removed from creator's library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
-      expect(updatedCard.isInLibrary(otherCuratorId)).toBe(true);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
     });
 
     it('should handle card removal when no collections contain the card', async () => {
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card was removed from library
+      // Verify card was removed from library and deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.isInLibrary(curatorId)).toBe(false);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
 
       // Verify no collection unpublish operations occurred
       const unpublishedCollections =
···
     });
   });
 
-  describe('Edge cases', () => {
-    it('should handle card with multiple library memberships', async () => {
+  describe('Card deletion behavior', () => {
+    it('should delete card when removed from last library and curator is owner', async () => {
       const card = await createCard();
+      await addCardToLibrary(card, curatorId);
 
-      // Add to multiple users' libraries
+      // Verify card exists and is in library
+      expect(card.isInLibrary(curatorId)).toBe(true);
+      expect(card.libraryMembershipCount).toBe(1);
+
+      const request = {
+        cardId: card.cardId.getStringValue(),
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(request);
+
+      expect(result.isOk()).toBe(true);
+
+      // Verify card was deleted
+      const cardResult = await cardRepository.findById(card.cardId);
+      const cardFromRepo = cardResult.unwrap();
+      expect(cardFromRepo).toBeNull();
+    });
+
+    it('should not delete card when curator is not the owner', async () => {
+      // Create card with different owner
+      const card = await createCard(CardTypeEnum.NOTE, otherCuratorId);
+
+      // Add to other curator's library first
+      await addCardToLibrary(card, otherCuratorId);
+
+      // Add to current curator's library (note cards can be in multiple libraries)
+      await addCardToLibrary(card, curatorId);
+
+      // Remove from current curator's library
+      const request = {
+        cardId: card.cardId.getStringValue(),
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(request);
+
+      expect(result.isOk()).toBe(true);
+
+      // Verify card still exists (not deleted because curator is not owner)
+      const cardResult = await cardRepository.findById(card.cardId);
+      const cardFromRepo = cardResult.unwrap()!;
+      expect(cardFromRepo).not.toBeNull();
+      expect(cardFromRepo.isInLibrary(curatorId)).toBe(false);
+      expect(cardFromRepo.isInLibrary(otherCuratorId)).toBe(true);
+    });
+
+    it('should not delete card when it still has other library memberships', async () => {
+      // Create note card (can be in multiple libraries)
+      const card = await createCard(CardTypeEnum.NOTE, curatorId);
+
+      // Add to both curator's libraries
       await addCardToLibrary(card, curatorId);
       await addCardToLibrary(card, otherCuratorId);
 
       expect(card.libraryMembershipCount).toBe(2);
 
+      // Remove from curator's library
       const request = {
         cardId: card.cardId.getStringValue(),
         curatorId: curatorId.value,
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card still has one library membership
+      // Verify card still exists (not deleted because it's still in other curator's library)
+      const cardResult = await cardRepository.findById(card.cardId);
+      const cardFromRepo = cardResult.unwrap()!;
+      expect(cardFromRepo).not.toBeNull();
+      expect(cardFromRepo.isInLibrary(curatorId)).toBe(false);
+      expect(cardFromRepo.isInLibrary(otherCuratorId)).toBe(true);
+      expect(cardFromRepo.libraryMembershipCount).toBe(1);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle URL card with single library membership', async () => {
+      // Create URL card with curatorId as creator
+      const card = await createCard(CardTypeEnum.URL, curatorId);
+
+      // Add to creator's library only (URL cards can only be in creator's library)
+      await addCardToLibrary(card, curatorId);
+
+      expect(card.libraryMembershipCount).toBe(1);
+
+      const request = {
+        cardId: card.cardId.getStringValue(),
+        curatorId: curatorId.value,
+      };
+
+      const result = await useCase.execute(request);
+
+      expect(result.isOk()).toBe(true);
+
+      // Verify card was deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-      expect(updatedCard.libraryMembershipCount).toBe(1);
-      expect(updatedCard.isInLibrary(otherCuratorId)).toBe(true);
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
     });
 
     it('should handle repository save failure', async () => {
···
     });
 
     it('should preserve card properties when removing from library', async () => {
-      const card = await createCard();
+      // Create URL card with curatorId as creator
+      const card = await createCard(CardTypeEnum.URL, curatorId);
       await addCardToLibrary(card, curatorId);
 
       const originalCreatedAt = card.createdAt;
···
 
       expect(result.isOk()).toBe(true);
 
-      // Verify card properties are preserved
+      // Verify card was deleted (since it's no longer in any libraries and curator is owner)
       const updatedCardResult = await cardRepository.findById(card.cardId);
-      const updatedCard = updatedCardResult.unwrap()!;
-
-      expect(updatedCard.createdAt).toEqual(originalCreatedAt);
-      expect(updatedCard.type.value).toBe(originalType);
-      expect(updatedCard.content).toEqual(originalContent);
-      expect(updatedCard.updatedAt.getTime()).toBeGreaterThanOrEqual(
-        originalCreatedAt.getTime(),
-      );
+      const updatedCard = updatedCardResult.unwrap();
+      expect(updatedCard).toBeNull();
     });
   });
 });

src/modules/cards/tests/application/UpdateNoteCardUseCase.test.ts

···
         originalCreatedAt.getTime(),
       );
       expect(updatedCard.type.value).toBe(CardTypeEnum.NOTE);
-      expect(updatedCard.content.noteContent!.authorId.equals(curatorId)).toBe(
-        true,
-      );
+      expect(updatedCard.curatorId.equals(curatorId)).toBe(true);
     });
   });
 

src/modules/cards/tests/domain/Card.test.ts

···
+import { Card, CARD_ERROR_MESSAGES } from '../../domain/Card';
+import { CardType, CardTypeEnum } from '../../domain/value-objects/CardType';
+import { CardContent } from '../../domain/value-objects/CardContent';
+import { CuratorId } from '../../domain/value-objects/CuratorId';
+import { URL } from '../../domain/value-objects/URL';
+import { UrlMetadata } from '../../domain/value-objects/UrlMetadata';
+
+describe('Card', () => {
+  describe('create', () => {
+    it('should create URL card without automatically adding to library', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test123').unwrap();
+      const cardType = CardType.create(CardTypeEnum.URL).unwrap();
+      const url = URL.create('https://example.com').unwrap();
+      const cardContent = CardContent.createUrlContent(
+        url,
+        UrlMetadata.create({
+          url: url.toString(),
+          title: 'Test Title',
+          description: 'Test Description',
+        }).unwrap(),
+      ).unwrap();
+
+      // Act
+      const result = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        url,
+      });
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const card = result.unwrap();
+
+      // Verify card is NOT automatically in curator's library
+      expect(card.isInLibrary(curatorId)).toBe(false);
+      expect(card.libraryMembershipCount).toBe(0);
+      expect(card.libraryCount).toBe(0);
+    });
+
+    it('should create note card without automatically adding to library', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test456').unwrap();
+      const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
+      const cardContent = CardContent.createNoteContent(
+        'This is a test note',
+      ).unwrap();
+
+      // Act
+      const result = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+      });
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const card = result.unwrap();
+
+      // Verify card is NOT automatically in curator's library
+      expect(card.isInLibrary(curatorId)).toBe(false);
+      expect(card.libraryMembershipCount).toBe(0);
+      expect(card.libraryCount).toBe(0);
+    });
+
+    it('should fail to create URL card with library membership different from creator', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test789').unwrap();
+      const otherUserId = CuratorId.create('did:plc:other123').unwrap();
+      const cardType = CardType.create(CardTypeEnum.URL).unwrap();
+      const url = URL.create('https://example.com').unwrap();
+      const cardContent = CardContent.createUrlContent(
+        url,
+        UrlMetadata.create({
+          url: url.toString(),
+          title: 'Test Title',
+          description: 'Test Description',
+        }).unwrap(),
+      ).unwrap();
+
+      const existingMemberships = [
+        {
+          curatorId: otherUserId,
+          addedAt: new Date('2023-01-01'),
+          publishedRecordId: undefined,
+        },
+      ];
+
+      // Act
+      const result = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        url,
+        libraryMemberships: existingMemberships,
+        libraryCount: 1,
+      });
+
+      // Assert
+      if (result.isOk()) {
+        throw new Error('Expected creation to fail but it succeeded');
+      }
+      expect(result.isErr()).toBe(true);
+      expect(result.error.message).toBe(
+        CARD_ERROR_MESSAGES.URL_CARD_CREATOR_LIBRARY_ONLY,
+      );
+    });
+
+    it('should fail to create URL card with multiple library memberships', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test789').unwrap();
+      const otherUserId1 = CuratorId.create('did:plc:other123').unwrap();
+      const otherUserId2 = CuratorId.create('did:plc:other456').unwrap();
+      const cardType = CardType.create(CardTypeEnum.URL).unwrap();
+      const url = URL.create('https://example.com').unwrap();
+      const cardContent = CardContent.createUrlContent(
+        url,
+        UrlMetadata.create({
+          url: url.toString(),
+          title: 'Test Title',
+          description: 'Test Description',
+        }).unwrap(),
+      ).unwrap();
+
+      const existingMemberships = [
+        {
+          curatorId: otherUserId1,
+          addedAt: new Date('2023-01-01'),
+          publishedRecordId: undefined,
+        },
+        {
+          curatorId: otherUserId2,
+          addedAt: new Date('2023-01-02'),
+          publishedRecordId: undefined,
+        },
+      ];
+
+      // Act
+      const result = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        url,
+        libraryMemberships: existingMemberships,
+        libraryCount: 2,
+      });
+
+      // Assert
+      if (result.isOk()) {
+        throw new Error('Expected creation to fail but it succeeded');
+      }
+      expect(result.isErr()).toBe(true);
+      expect(result.error.message).toBe(
+        CARD_ERROR_MESSAGES.URL_CARD_SINGLE_LIBRARY_ONLY,
+      );
+    });
+
+    it('should allow NOTE cards to have multiple library memberships', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test789').unwrap();
+      const otherUserId = CuratorId.create('did:plc:other123').unwrap();
+      const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
+      const cardContent = CardContent.createNoteContent(
+        'This is a test note',
+      ).unwrap();
+
+      const existingMemberships = [
+        {
+          curatorId: otherUserId,
+          addedAt: new Date('2023-01-01'),
+          publishedRecordId: undefined,
+        },
+      ];
+
+      // Act
+      const result = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        libraryMemberships: existingMemberships,
+        libraryCount: 1,
+      });
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const card = result.unwrap();
+
+      // Should have only the existing membership (no automatic curator addition)
+      expect(card.libraryMembershipCount).toBe(1);
+      expect(card.libraryCount).toBe(1);
+      expect(card.isInLibrary(curatorId)).toBe(false);
+      expect(card.isInLibrary(otherUserId)).toBe(true);
+    });
+  });
+
+  describe('addToLibrary', () => {
+    it('should allow adding URL card to first library', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test123').unwrap();
+      const cardType = CardType.create(CardTypeEnum.URL).unwrap();
+      const url = URL.create('https://example.com').unwrap();
+      const cardContent = CardContent.createUrlContent(
+        url,
+        UrlMetadata.create({
+          url: url.toString(),
+          title: 'Test Title',
+          description: 'Test Description',
+        }).unwrap(),
+      ).unwrap();
+
+      const card = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        url,
+      }).unwrap();
+
+      // Act - add to curator's library
+      const result = card.addToLibrary(curatorId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      expect(card.libraryMembershipCount).toBe(1);
+      expect(card.isInLibrary(curatorId)).toBe(true);
+    });
+
+    it('should prevent adding URL card to multiple libraries', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test123').unwrap();
+      const otherUserId = CuratorId.create('did:plc:other456').unwrap();
+      const cardType = CardType.create(CardTypeEnum.URL).unwrap();
+      const url = URL.create('https://example.com').unwrap();
+      const cardContent = CardContent.createUrlContent(
+        url,
+        UrlMetadata.create({
+          url: url.toString(),
+          title: 'Test Title',
+          description: 'Test Description',
+        }).unwrap(),
+      ).unwrap();
+
+      const card = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+        url,
+      }).unwrap();
+
+      // First add to curator's library
+      card.addToLibrary(curatorId);
+
+      // Act - try to add to another user's library
+      const result = card.addToLibrary(otherUserId);
+
+      // Assert
+      if (result.isOk()) {
+        throw new Error('Expected creation to fail but it succeeded');
+      }
+      expect(result.isErr()).toBe(true);
+      expect(result.error.message).toBe(
+        CARD_ERROR_MESSAGES.URL_CARD_SINGLE_LIBRARY_ONLY,
+      );
+      expect(card.libraryMembershipCount).toBe(1);
+      expect(card.isInLibrary(curatorId)).toBe(true);
+      expect(card.isInLibrary(otherUserId)).toBe(false);
+    });
+
+    it('should allow adding NOTE card to multiple libraries', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test123').unwrap();
+      const otherUserId = CuratorId.create('did:plc:other456').unwrap();
+      const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
+      const cardContent = CardContent.createNoteContent(
+        'This is a test note',
+      ).unwrap();
+
+      const card = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+      }).unwrap();
+
+      // Act - add to both libraries
+      const result1 = card.addToLibrary(curatorId);
+      const result2 = card.addToLibrary(otherUserId);
+
+      // Assert
+      expect(result1.isOk()).toBe(true);
+      expect(result2.isOk()).toBe(true);
+      expect(card.libraryMembershipCount).toBe(2);
+      expect(card.isInLibrary(curatorId)).toBe(true);
+      expect(card.isInLibrary(otherUserId)).toBe(true);
+    });
+
+    it('should prevent adding same user twice to any card type', () => {
+      // Arrange
+      const curatorId = CuratorId.create('did:plc:test123').unwrap();
+      const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
+      const cardContent = CardContent.createNoteContent(
+        'This is a test note',
+      ).unwrap();
+
+      const card = Card.create({
+        curatorId,
+        type: cardType,
+        content: cardContent,
+      }).unwrap();
+
+      // First add to library
+      card.addToLibrary(curatorId);
+
+      // Act - try to add same user again
+      const result = card.addToLibrary(curatorId);
+
+      // Assert
+      if (result.isOk()) {
+        throw new Error('Expected creation to fail but it succeeded');
+      }
+      expect(result.isErr()).toBe(true);
+      expect(result.error.message).toBe(CARD_ERROR_MESSAGES.ALREADY_IN_LIBRARY);
+      expect(card.libraryMembershipCount).toBe(1);
+    });
+  });
+});

src/modules/cards/tests/infrastructure/DrizzleCardRepository.integration.test.ts

···
     const cardType = CardType.create(CardTypeEnum.URL).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: urlContent,
       url,
···
     // Create a note card
     const noteContent = CardContent.createNoteContent(
       'This is a test note',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
     // Create a note card
     const noteContent = CardContent.createNoteContent(
       'Card with library memberships',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
     // Create a note card
     const noteContent = CardContent.createNoteContent(
       'Card for membership updates',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
 
   it('should delete a card and its library memberships', async () => {
     // Create a card
-    const noteContent = CardContent.createNoteContent(
-      'Card to delete',
-      curatorId,
-    ).unwrap();
+    const noteContent =
+      CardContent.createNoteContent('Card to delete').unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
   });
 
   it('should return null when card is not found', async () => {
-    const noteContent = CardContent.createNoteContent(
-      'Non-existent card',
-      curatorId,
-    ).unwrap();
+    const noteContent =
+      CardContent.createNoteContent('Non-existent card').unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const nonExistentCardId = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     }).unwrap().cardId;
···
     expect(result.unwrap()).toBeNull();
   });
 
-  it('should handle originalPublishedRecordId when marking card as published', async () => {
+  it('should handle publishedRecordId when marking card as published', async () => {
     // Create a note card
     const noteContent = CardContent.createNoteContent(
       'Card for publishing test',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
     // Add to library
     card.addToLibrary(curatorId);
 
-    // Mark as published - this should set the originalPublishedRecordId
+    // Mark as published - this should set the publishedRecordId
     const publishedRecordId = {
       uri: 'at://did:plc:testcurator/network.cosmik.card/test123',
       cid: 'bafytest123',
···
     );
     expect(markResult.isOk()).toBe(true);
 
-    // Verify originalPublishedRecordId is set in memory
-    expect(card.originalPublishedRecordId).toBeDefined();
-    expect(card.originalPublishedRecordId?.uri).toBe(publishedRecordId.uri);
-    expect(card.originalPublishedRecordId?.cid).toBe(publishedRecordId.cid);
+    // Verify publishedRecordId is set in memory
+    expect(card.publishedRecordId).toBeDefined();
+    expect(card.publishedRecordId?.uri).toBe(publishedRecordId.uri);
+    expect(card.publishedRecordId?.cid).toBe(publishedRecordId.cid);
 
-    // Save the card - this should persist the originalPublishedRecordId
+    // Save the card - this should persist the publishedRecordId
     const saveResult = await cardRepository.save(card);
     expect(saveResult.isOk()).toBe(true);
 
-    // Retrieve and verify the originalPublishedRecordId persisted
+    // Retrieve and verify the publishedRecordId persisted
     const retrievedResult = await cardRepository.findById(card.cardId);
     const retrievedCard = retrievedResult.unwrap();
 
-    expect(retrievedCard?.originalPublishedRecordId).toBeDefined();
-    expect(retrievedCard?.originalPublishedRecordId?.uri).toBe(
-      publishedRecordId.uri,
-    );
-    expect(retrievedCard?.originalPublishedRecordId?.cid).toBe(
-      publishedRecordId.cid,
-    );
+    expect(retrievedCard?.publishedRecordId).toBeDefined();
+    expect(retrievedCard?.publishedRecordId?.uri).toBe(publishedRecordId.uri);
+    expect(retrievedCard?.publishedRecordId?.cid).toBe(publishedRecordId.cid);
   });
 
   it('should find URL card by URL', async () => {
···
     const cardType = CardType.create(CardTypeEnum.URL).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: urlContent,
       url,
···
     await cardRepository.save(card);
 
     // Find the card by URL
-    const foundResult = await cardRepository.findUrlCardByUrl(url);
+    const foundResult = await cardRepository.findUsersUrlCardByUrl(
+      url,
+      curatorId,
+    );
     expect(foundResult.isOk()).toBe(true);
 
     const foundCard = foundResult.unwrap();
···
   it('should return null when URL card is not found', async () => {
     const nonExistentUrl = URL.create('https://example.com/notfound').unwrap();
 
-    const result = await cardRepository.findUrlCardByUrl(nonExistentUrl);
+    const result = await cardRepository.findUsersUrlCardByUrl(
+      nonExistentUrl,
+      curatorId,
+    );
     expect(result.isOk()).toBe(true);
     expect(result.unwrap()).toBeNull();
   });
···
   it('should not find note cards when searching by URL', async () => {
     // Create a note card with a URL (but it's not a URL card type)
     const url = URL.create('https://example.com/note-url').unwrap();
-    const noteContent = CardContent.createNoteContent(
-      'Note about a URL',
-      curatorId,
-    ).unwrap();
+    const noteContent =
+      CardContent.createNoteContent('Note about a URL').unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
       url, // Note cards can have URLs too
···
     await cardRepository.save(card);
 
     // Try to find it as a URL card - should return null because it's a NOTE type
-    const foundResult = await cardRepository.findUrlCardByUrl(url);
+    const foundResult = await cardRepository.findUsersUrlCardByUrl(
+      url,
+      curatorId,
+    );
     expect(foundResult.isOk()).toBe(true);
     expect(foundResult.unwrap()).toBeNull();
   });
···
     // Create a note card
     const noteContent = CardContent.createNoteContent(
       'Card for library count test',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
     });
···
     // Create a note card with initial library memberships
     const noteContent = CardContent.createNoteContent(
       'Card with initial memberships',
-      curatorId,
     ).unwrap();
     const cardType = CardType.create(CardTypeEnum.NOTE).unwrap();
 
···
     ];
 
     const cardResult = Card.create({
+      curatorId,
       type: cardType,
       content: noteContent,
       libraryMemberships: initialMemberships,

src/modules/cards/tests/infrastructure/DrizzleCollectionQueryRepository.getCollectionsContainingCardForUser.integration.test.ts

···
+import {
+  PostgreSqlContainer,
+  StartedPostgreSqlContainer,
+} from '@testcontainers/postgresql';
+import postgres from 'postgres';
+import { drizzle, PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { DrizzleCollectionQueryRepository } from '../../infrastructure/repositories/DrizzleCollectionQueryRepository';
+import { DrizzleCardRepository } from '../../infrastructure/repositories/DrizzleCardRepository';
+import { DrizzleCollectionRepository } from '../../infrastructure/repositories/DrizzleCollectionRepository';
+import { CuratorId } from '../../domain/value-objects/CuratorId';
+import { UniqueEntityID } from '../../../../shared/domain/UniqueEntityID';
+import {
+  collections,
+  collectionCollaborators,
+  collectionCards,
+} from '../../infrastructure/repositories/schema/collection.sql';
+import { cards } from '../../infrastructure/repositories/schema/card.sql';
+import { libraryMemberships } from '../../infrastructure/repositories/schema/libraryMembership.sql';
+import { publishedRecords } from '../../infrastructure/repositories/schema/publishedRecord.sql';
+import { Collection, CollectionAccessType } from '../../domain/Collection';
+import { CardFactory } from '../../domain/CardFactory';
+import { CardTypeEnum } from '../../domain/value-objects/CardType';
+import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId';
+import { UrlMetadata } from '../../domain/value-objects/UrlMetadata';
+import { createTestSchema } from '../test-utils/createTestSchema';
+
+describe('DrizzleCollectionQueryRepository - getCollectionsContainingCardForUser', () => {
+  let container: StartedPostgreSqlContainer;
+  let db: PostgresJsDatabase;
+  let queryRepository: DrizzleCollectionQueryRepository;
+  let collectionRepository: DrizzleCollectionRepository;
+  let cardRepository: DrizzleCardRepository;
+
+  // Test data
+  let curatorId: CuratorId;
+  let otherCuratorId: CuratorId;
+
+  // Setup before all tests
+  beforeAll(async () => {
+    // Start PostgreSQL container
+    container = await new PostgreSqlContainer('postgres:14').start();
+
+    // Create database connection
+    const connectionString = container.getConnectionUri();
+    process.env.DATABASE_URL = connectionString;
+    const client = postgres(connectionString);
+    db = drizzle(client);
+
+    // Create repositories
+    queryRepository = new DrizzleCollectionQueryRepository(db);
+    collectionRepository = new DrizzleCollectionRepository(db);
+    cardRepository = new DrizzleCardRepository(db);
+
+    // Create schema using helper function
+    await createTestSchema(db);
+
+    // Create test data
+    curatorId = CuratorId.create('did:plc:testcurator').unwrap();
+    otherCuratorId = CuratorId.create('did:plc:othercurator').unwrap();
+  }, 60000); // Increase timeout for container startup
+
+  // Cleanup after all tests
+  afterAll(async () => {
+    // Stop container
+    await container.stop();
+  });
+
+  // Clear data between tests
+  beforeEach(async () => {
+    await db.delete(collectionCards);
+    await db.delete(collectionCollaborators);
+    await db.delete(collections);
+    await db.delete(libraryMemberships);
+    await db.delete(cards);
+    await db.delete(publishedRecords);
+  });
+
+  describe('URL card in collections', () => {
+    it('should return collections when user has URL card in multiple collections', async () => {
+      const testUrl = 'https://example.com/test-article';
+
+      // Create a URL card
+      const urlMetadata = UrlMetadata.create({
+        url: testUrl,
+        title: 'Test Article',
+        description: 'A test article for testing',
+        author: 'Test Author',
+        siteName: 'Example.com',
+      }).unwrap();
+
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: testUrl,
+          metadata: urlMetadata,
+        },
+      }).unwrap();
+
+      // Add card to library
+      const addToLibResult = card.addToLibrary(curatorId);
+      expect(addToLibResult.isOk()).toBe(true);
+
+      await cardRepository.save(card);
+
+      // Create first collection
+      const collection1 = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Tech Articles',
+          description: 'Collection of technology articles',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Create second collection
+      const collection2 = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Reading List',
+          description: 'My personal reading list',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Add card to both collections
+      const addToCollection1Result = collection1.addCard(
+        card.cardId,
+        curatorId,
+      );
+      expect(addToCollection1Result.isOk()).toBe(true);
+
+      const addToCollection2Result = collection2.addCard(
+        card.cardId,
+        curatorId,
+      );
+      expect(addToCollection2Result.isOk()).toBe(true);
+
+      // Mark collections as published
+      const collection1PublishedRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection1',
+        cid: 'bafyreicollection1cid',
+      });
+
+      const collection2PublishedRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/collection2',
+        cid: 'bafyreicollection2cid',
+      });
+
+      collection1.markAsPublished(collection1PublishedRecordId);
+      collection2.markAsPublished(collection2PublishedRecordId);
+
+      // Save collections
+      await collectionRepository.save(collection1);
+      await collectionRepository.save(collection2);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(2);
+
+      // Sort by name for consistent testing
+      result.sort((a, b) => a.name.localeCompare(b.name));
+
+      // Verify collection details
+      expect(result[0]?.id).toBe(collection2.collectionId.getStringValue()); // Reading List comes first alphabetically
+      expect(result[0]?.uri).toBe(
+        'at://did:plc:testcurator/network.cosmik.collection/collection2',
+      );
+      expect(result[0]?.name).toBe('Reading List');
+      expect(result[0]?.description).toBe('My personal reading list');
+
+      expect(result[1]?.id).toBe(collection1.collectionId.getStringValue()); // Tech Articles comes second
+      expect(result[1]?.uri).toBe(
+        'at://did:plc:testcurator/network.cosmik.collection/collection1',
+      );
+      expect(result[1]?.name).toBe('Tech Articles');
+      expect(result[1]?.description).toBe('Collection of technology articles');
+    });
+
+    it('should return empty array when user has URL card but not in any collections', async () => {
+      const testUrl = 'https://example.com/standalone-article';
+
+      // Create a URL card
+      const urlMetadata = UrlMetadata.create({
+        url: testUrl,
+        title: 'Standalone Article',
+        description: 'A standalone article for testing',
+      }).unwrap();
+
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: testUrl,
+          metadata: urlMetadata,
+        },
+      }).unwrap();
+
+      // Add card to library
+      const addToLibResult = card.addToLibrary(curatorId);
+      expect(addToLibResult.isOk()).toBe(true);
+
+      await cardRepository.save(card);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(0);
+    });
+
+    it('should return empty array when card does not exist', async () => {
+      const nonExistentCardId = new UniqueEntityID().toString();
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        nonExistentCardId,
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(0);
+    });
+
+    it('should not return collections from other users even if they have the same card', async () => {
+      const testUrl = 'https://example.com/shared-article';
+
+      // Create URL card for first user
+      const urlMetadata1 = UrlMetadata.create({
+        url: testUrl,
+        title: 'Shared Article',
+        description: 'An article shared between users',
+      }).unwrap();
+
+      const card1 = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: testUrl,
+          metadata: urlMetadata1,
+        },
+      }).unwrap();
+
+      const addToLibResult1 = card1.addToLibrary(curatorId);
+      expect(addToLibResult1.isOk()).toBe(true);
+
+      await cardRepository.save(card1);
+
+      // Create URL card for second user (different card, same URL)
+      const urlMetadata2 = UrlMetadata.create({
+        url: testUrl,
+        title: 'Shared Article',
+        description: 'An article shared between users',
+      }).unwrap();
+
+      const card2 = CardFactory.create({
+        curatorId: otherCuratorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: testUrl,
+          metadata: urlMetadata2,
+        },
+      }).unwrap();
+
+      const addToLibResult2 = card2.addToLibrary(otherCuratorId);
+      expect(addToLibResult2.isOk()).toBe(true);
+
+      await cardRepository.save(card2);
+
+      // Create collection for second user and add their card
+      const otherUserCollection = Collection.create(
+        {
+          authorId: otherCuratorId,
+          name: 'Other User Collection',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      const addToOtherCollectionResult = otherUserCollection.addCard(
+        card2.cardId,
+        otherCuratorId,
+      );
+      expect(addToOtherCollectionResult.isOk()).toBe(true);
+
+      await collectionRepository.save(otherUserCollection);
+
+      // Execute the query for first user's card
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card1.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result - should be empty since first user's card is not in any collections
+      expect(result).toHaveLength(0);
+    });
+
+    it('should only return collections owned by the requesting user', async () => {
+      const testUrl = 'https://example.com/multi-user-article';
+
+      // Create URL card for the user
+      const urlMetadata = UrlMetadata.create({
+        url: testUrl,
+        title: 'Multi User Article',
+        description: 'An article for multi-user testing',
+      }).unwrap();
+
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: testUrl,
+          metadata: urlMetadata,
+        },
+      }).unwrap();
+
+      const addToLibResult = card.addToLibrary(curatorId);
+      expect(addToLibResult.isOk()).toBe(true);
+
+      await cardRepository.save(card);
+
+      // Create user's own collection
+      const userCollection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'My Collection',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      const addToUserCollectionResult = userCollection.addCard(
+        card.cardId,
+        curatorId,
+      );
+      expect(addToUserCollectionResult.isOk()).toBe(true);
+
+      await collectionRepository.save(userCollection);
+
+      // Create another user's collection (this should not appear in results)
+      const otherUserCollection = Collection.create(
+        {
+          authorId: otherCuratorId,
+          name: 'Other User Collection',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Note: We don't add the card to the other user's collection since they can't add
+      // another user's card to their collection in this domain model
+
+      await collectionRepository.save(otherUserCollection);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result - should only see user's own collection
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe('My Collection');
+      expect(result[0]?.id).toBe(userCollection.collectionId.getStringValue());
+    });
+  });
+
+  describe('Note cards in collections', () => {
+    it('should return collections containing note cards', async () => {
+      // Create a note card
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'This is a test note',
+        },
+      }).unwrap();
+
+      // Add card to library
+      const addToLibResult = card.addToLibrary(curatorId);
+      expect(addToLibResult.isOk()).toBe(true);
+
+      await cardRepository.save(card);
+
+      // Create collection
+      const collection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'My Notes',
+          description: 'Collection of my personal notes',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Add card to collection
+      const addToCollectionResult = collection.addCard(card.cardId, curatorId);
+      expect(addToCollectionResult.isOk()).toBe(true);
+
+      await collectionRepository.save(collection);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe(collection.collectionId.getStringValue());
+      expect(result[0]?.name).toBe('My Notes');
+      expect(result[0]?.description).toBe('Collection of my personal notes');
+      expect(result[0]?.uri).toBeUndefined(); // Not published
+    });
+
+    it('should handle collections with and without descriptions', async () => {
+      // Create a note card
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Test note for collections',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Create collection with description
+      const collectionWithDesc = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Collection With Description',
+          description: 'This collection has a description',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Create collection without description
+      const collectionWithoutDesc = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Collection Without Description',
+          // No description provided
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Add card to both collections
+      collectionWithDesc.addCard(card.cardId, curatorId);
+      collectionWithoutDesc.addCard(card.cardId, curatorId);
+
+      await collectionRepository.save(collectionWithDesc);
+      await collectionRepository.save(collectionWithoutDesc);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(2);
+
+      // Sort by name for consistent testing
+      result.sort((a, b) => a.name.localeCompare(b.name));
+
+      expect(result[0]?.name).toBe('Collection With Description');
+      expect(result[0]?.description).toBe('This collection has a description');
+
+      expect(result[1]?.name).toBe('Collection Without Description');
+      expect(result[1]?.description).toBeUndefined();
+    });
+  });
+
+  describe('Published and unpublished collections', () => {
+    it('should return URI for published collections and undefined for unpublished', async () => {
+      // Create a card
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Card for published/unpublished test',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Create published collection
+      const publishedCollection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Published Collection',
+          description: 'This collection is published',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Create unpublished collection
+      const unpublishedCollection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Unpublished Collection',
+          description: 'This collection is not published',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      // Mark published collection as published
+      const publishedRecordId = PublishedRecordId.create({
+        uri: 'at://did:plc:testcurator/network.cosmik.collection/published123',
+        cid: 'bafyreipublishedcid',
+      });
+
+      publishedCollection.markAsPublished(publishedRecordId);
+
+      // Add card to both collections
+      publishedCollection.addCard(card.cardId, curatorId);
+      unpublishedCollection.addCard(card.cardId, curatorId);
+
+      await collectionRepository.save(publishedCollection);
+      await collectionRepository.save(unpublishedCollection);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(2);
+
+      // Find collections by name
+      const publishedResult = result.find(
+        (c) => c.name === 'Published Collection',
+      );
+      const unpublishedResult = result.find(
+        (c) => c.name === 'Unpublished Collection',
+      );
+
+      expect(publishedResult?.uri).toBe(
+        'at://did:plc:testcurator/network.cosmik.collection/published123',
+      );
+      expect(unpublishedResult?.uri).toBeUndefined();
+    });
+  });
+
+  describe('Sorting and ordering', () => {
+    it('should return collections sorted by name in ascending order', async () => {
+      // Create a card
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Card for sorting test',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Create collections with names that will test alphabetical sorting
+      const collectionNames = [
+        'Zebra Collection',
+        'Alpha Collection',
+        'Beta Collection',
+      ];
+
+      for (const name of collectionNames) {
+        const collection = Collection.create(
+          {
+            authorId: curatorId,
+            name,
+            accessType: CollectionAccessType.OPEN,
+            collaboratorIds: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+          new UniqueEntityID(),
+        ).unwrap();
+
+        collection.addCard(card.cardId, curatorId);
+        await collectionRepository.save(collection);
+      }
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result is sorted by name
+      expect(result).toHaveLength(3);
+      expect(result[0]?.name).toBe('Alpha Collection');
+      expect(result[1]?.name).toBe('Beta Collection');
+      expect(result[2]?.name).toBe('Zebra Collection');
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle non-existent curator gracefully', async () => {
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Test card',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Execute the query with non-existent curator
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        'did:plc:nonexistent',
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(0);
+    });
+
+    it('should handle empty curator ID gracefully', async () => {
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Test card',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Execute the query with empty curator ID
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        '',
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(0);
+    });
+
+    it('should handle collections with null published records', async () => {
+      // Create a card
+      const card = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Card for null published record test',
+        },
+      }).unwrap();
+
+      await cardRepository.save(card);
+
+      // Create collection without published record
+      const collection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Collection Without Published Record',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      collection.addCard(card.cardId, curatorId);
+      await collectionRepository.save(collection);
+
+      // Execute the query
+      const result = await queryRepository.getCollectionsContainingCardForUser(
+        card.cardId.getStringValue(),
+        curatorId.value,
+      );
+
+      // Verify the result
+      expect(result).toHaveLength(1);
+      expect(result[0]?.uri).toBeUndefined();
+      expect(result[0]?.name).toBe('Collection Without Published Record');
+    });
+  });
+
+  describe('Multiple card types', () => {
+    it('should work with different card types in the same collection', async () => {
+      // Create different types of cards
+      const urlMetadata = UrlMetadata.create({
+        url: 'https://example.com/test',
+        title: 'Test URL',
+        description: 'A test URL for mixed content',
+      }).unwrap();
+
+      const urlCard = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.URL,
+          url: 'https://example.com/test',
+          metadata: urlMetadata,
+        },
+      }).unwrap();
+
+      const noteCard = CardFactory.create({
+        curatorId: curatorId.value,
+        cardInput: {
+          type: CardTypeEnum.NOTE,
+          text: 'Test note',
+        },
+      }).unwrap();
+
+      await cardRepository.save(urlCard);
+      await cardRepository.save(noteCard);
+
+      // Create collection and add all cards
+      const collection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Mixed Content Collection',
+          description: 'Collection with different card types',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      collection.addCard(urlCard.cardId, curatorId);
+      collection.addCard(noteCard.cardId, curatorId);
+
+      await collectionRepository.save(collection);
+
+      // Test each card type
+      const urlResult =
+        await queryRepository.getCollectionsContainingCardForUser(
+          urlCard.cardId.getStringValue(),
+          curatorId.value,
+        );
+
+      const noteResult =
+        await queryRepository.getCollectionsContainingCardForUser(
+          noteCard.cardId.getStringValue(),
+          curatorId.value,
+        );
+
+      // Verify all return the same collection
+      expect(urlResult).toHaveLength(1);
+      expect(noteResult).toHaveLength(1);
+
+      expect(urlResult[0]?.name).toBe('Mixed Content Collection');
+      expect(noteResult[0]?.name).toBe('Mixed Content Collection');
+
+      expect(urlResult[0]?.id).toBe(collection.collectionId.getStringValue());
+      expect(noteResult[0]?.id).toBe(collection.collectionId.getStringValue());
+    });
+  });
+});

src/modules/cards/tests/test-utils/createTestSchema.ts

···
     // Cards table (references published_records and self-references)
     sql`CREATE TABLE IF NOT EXISTS cards (
       id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      author_id TEXT NOT NULL,
       type TEXT NOT NULL,
       content_data JSONB NOT NULL,
       url TEXT,
       parent_card_id UUID REFERENCES cards(id),
-      original_published_record_id UUID REFERENCES published_records(id),
+      published_record_id UUID REFERENCES published_records(id),
       library_count INTEGER NOT NULL DEFAULT 0,
       created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
       updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
···
   // Index for efficient AT URI lookups
   await db.execute(sql`
     CREATE INDEX IF NOT EXISTS published_records_uri_idx ON published_records(uri);
+  `);
+
+  // Cards table indexes
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS cards_author_url_idx ON cards(author_id, url);
+  `);
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS cards_author_id_idx ON cards(author_id);
+  `);
+
+  // Collections table indexes
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS collections_author_id_idx ON collections(author_id);
+  `);
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS collections_author_updated_at_idx ON collections(author_id, updated_at);
+  `);
+
+  // Collection cards table indexes
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS collection_cards_card_id_idx ON collection_cards(card_id);
+  `);
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS collection_cards_collection_id_idx ON collection_cards(collection_id);
   `);
 }

src/modules/cards/tests/utils/FakeCardPublisher.ts

···
   async publishCardToLibrary(
     card: Card,
     curatorId: CuratorId,
+    parentCard?: Card,
   ): Promise<Result<PublishedRecordId, UseCaseError>> {
     if (this.shouldFail) {
       return err(
···
 
     const cardId = card.cardId.getStringValue();
     // Simulate generating an AT URI based on curator DID and collection/rkey
-    const fakeUri = `at://${curatorId.value}/network.cosmik.card/${cardId}`;
+    const fakeUri = `at://${curatorId.value}/network.cosmik.dev.card/${cardId}`;
     const fakeCid = `fake-cid-${cardId}`;
     const publishedRecordId = PublishedRecordId.create({
       uri: fakeUri,

src/modules/cards/tests/utils/FakeCollectionPublisher.ts

···
     const fakeDid = process.env.BSKY_DID || 'did:plc:rlknsba2qldjkicxsmni3vyn';
 
     // Simulate publishing the collection record itself
-    const fakeCollectionUri = `at://${fakeDid}/network.cosmik.collection/${collectionId}`;
+    const fakeCollectionUri = `at://${fakeDid}/network.cosmik.dev.collection/${collectionId}`;
     const fakeCollectionCid = `fake-collection-cid-${collectionId}`;
 
     const collectionRecord = PublishedRecordId.create({

src/modules/cards/tests/utils/InMemoryCardRepository.ts

···
 import { ICardRepository } from '../../domain/ICardRepository';
 import { Card } from '../../domain/Card';
 import { CardId } from '../../domain/value-objects/CardId';
+import { CuratorId } from '../../domain/value-objects/CuratorId';
 import { URL } from '../../domain/value-objects/URL';
 
 export class InMemoryCardRepository implements ICardRepository {
···
     // Simple clone - in a real implementation you'd want proper deep cloning
     const cardResult = Card.create(
       {
+        curatorId: card.props.curatorId,
         type: card.type,
         content: card.content,
         parentCardId: card.parentCardId,
         url: card.url,
-        originalPublishedRecordId: card.originalPublishedRecordId,
+        publishedRecordId: card.publishedRecordId,
         libraryMemberships: card.libraryMemberships,
+        libraryCount: card.libraryCount,
         createdAt: card.createdAt,
         updatedAt: card.updatedAt,
       },
···
     }
   }
 
-  async findUrlCardByUrl(url: URL): Promise<Result<Card | null>> {
+  async findUsersUrlCardByUrl(
+    url: URL,
+    curatorId: CuratorId,
+  ): Promise<Result<Card | null>> {
     try {
       const card = Array.from(this.cards.values()).find(
         (card) =>
-          card.content.type === 'URL' &&
-          card.content.urlContent?.url.value === url.value,
+          card.type.value === 'URL' &&
+          card.url?.value === url.value &&
+          card.props.curatorId.equals(curatorId),
       );
       return ok(card ? this.clone(card) : null);
     } catch (error) {

src/modules/cards/tests/utils/InMemoryCollectionQueryRepository.ts

···
-import { Result, ok, err } from '../../../../shared/core/Result';
 import {
   ICollectionQueryRepository,
   CollectionQueryOptions,
   CollectionQueryResultDTO,
+  CollectionContainingCardDTO,
   PaginatedQueryResult,
   CollectionSortField,
   SortOrder,
···
     });
 
     return sorted;
+  }
+
+  async getCollectionsContainingCardForUser(
+    cardId: string,
+    curatorId: string,
+  ): Promise<CollectionContainingCardDTO[]> {
+    try {
+      // Get all collections and filter by creator
+      const allCollections = this.collectionRepository.getAllCollections();
+      const creatorCollections = allCollections.filter(
+        (collection) => collection.authorId.value === curatorId,
+      );
+
+      // Filter collections that contain the specified card
+      const collectionsWithCard = creatorCollections.filter((collection) =>
+        collection.cardLinks.some(
+          (link) => link.cardId.getStringValue() === cardId,
+        ),
+      );
+
+      // Transform to DTOs
+      const result: CollectionContainingCardDTO[] = collectionsWithCard.map(
+        (collection) => {
+          const collectionPublishedRecordId = collection.publishedRecordId;
+          return {
+            id: collection.collectionId.getStringValue(),
+            uri: collectionPublishedRecordId?.uri,
+            name: collection.name.value,
+            description: collection.description?.value,
+          };
+        },
+      );
+
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to get collections containing card: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   clear(): void {

src/modules/cards/tests/utils/builders/CardBuilder.ts

···
   private _content?: CardContent;
   private _url?: URL;
   private _parentCardId?: CardId;
-  private _originalPublishedRecordId?: PublishedRecordId;
+  private _publishedRecordId?: PublishedRecordId;
   private _createdAt?: Date;
   private _updatedAt?: Date;
 
···
       } else if (type === CardTypeEnum.NOTE) {
         const curatorIdResult = CuratorId.create(this._curatorId);
         if (curatorIdResult.isOk()) {
-          const contentResult = CardContent.createNoteContent(
-            'Default note text',
-            curatorIdResult.value,
-          );
+          const contentResult =
+            CardContent.createNoteContent('Default note text');
           if (contentResult.isOk()) {
             this._content = contentResult.value;
           }
···
     return this;
   }
 
-  withOriginalPublishedRecordId(originalPublishedRecordId: {
+  withPublishedRecordId(originalPublishedRecordId: {
     uri: string;
     cid: string;
   }): CardBuilder {
-    this._originalPublishedRecordId = PublishedRecordId.create(
+    this._publishedRecordId = PublishedRecordId.create(
       originalPublishedRecordId,
     );
     return this;
···
 
   withNoteCard(text: string): CardBuilder {
     this._type = CardTypeEnum.NOTE;
-    const contentResult = CardContent.createNoteContent(
-      text,
-      CuratorId.create(this._curatorId).unwrap(),
-    );
+    const contentResult = CardContent.createNoteContent(text);
     if (contentResult.isErr()) {
       throw new Error(
         `Failed to create note content: ${contentResult.error.message}`,
···
           }
           this._content = contentResult.value;
         } else if (this._type === CardTypeEnum.NOTE) {
-          const contentResult = CardContent.createNoteContent(
-            'Default note text',
-            curatorIdResult.value,
-          );
+          const contentResult =
+            CardContent.createNoteContent('Default note text');
           if (contentResult.isErr()) {
             return new Error(
               `Failed to create note content: ${contentResult.error.message}`,
···
 
       const cardResult = Card.create(
         {
+          curatorId: curatorIdResult.value,
           type: cardTypeResult.value,
           content: this._content,
           url: this._url,
           parentCardId: this._parentCardId,
-          originalPublishedRecordId: this._originalPublishedRecordId,
+          publishedRecordId: this._publishedRecordId,
           createdAt: this._createdAt,
           updatedAt: this._updatedAt,
         },

src/modules/cards/tests/utils/builders/CollectionBuilder.ts

···
   withPublished(published: boolean): CollectionBuilder {
     if (published) {
       // Create a fake published record ID when marking as published
-      const fakeUri = `at://fake-did/network.cosmik.collection/${this._id?.toString() || 'fake-id'}`;
+      const fakeUri = `at://fake-did/network.cosmik.dev.collection/${this._id?.toString() || 'fake-id'}`;
       const fakeCid = `fake-collection-cid-${this._id?.toString() || 'fake-id'}`;
       this._publishedRecordId = PublishedRecordId.create({
         uri: fakeUri,

src/shared/infrastructure/config/EnvironmentConfigService.ts

···
   atproto: {
     serviceEndpoint: string;
     baseUrl: string;
+    collections: {
+      card: string;
+      collection: string;
+      collectionLink: string;
+    };
   };
   server: {
     port: number;
···
         serviceEndpoint:
           process.env.ATPROTO_SERVICE_ENDPOINT || 'https://bsky.social',
         baseUrl: process.env.BASE_URL || 'http://127.0.0.1:3000',
+        collections: {
+          card:
+            environment === 'prod'
+              ? 'network.cosmik.card'
+              : 'network.cosmik.dev.card',
+          collection:
+            environment === 'prod'
+              ? 'network.cosmik.collection'
+              : 'network.cosmik.dev.collection',
+          collectionLink:
+            environment === 'prod'
+              ? 'network.cosmik.collectionLink'
+              : 'network.cosmik.dev.collectionLink',
+        },
       },
       server: {
         port: parseInt(process.env.PORT || '3000'),
···
 
   public getAtProtoConfig() {
     return this.config.atproto;
+  }
+
+  public getAtProtoCollections() {
+    return this.config.atproto.collections;
   }
 
   public getServerConfig() {

src/shared/infrastructure/database/migrations/0004_brainy_rocket_racer.sql

···
+ALTER TABLE "cards" RENAME COLUMN "original_published_record_id" TO "published_record_id";--> statement-breakpoint
+ALTER TABLE "cards" DROP CONSTRAINT "cards_original_published_record_id_published_records_id_fk";
+--> statement-breakpoint
+ALTER TABLE "cards" ADD COLUMN "author_id" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "cards" ADD CONSTRAINT "cards_published_record_id_published_records_id_fk" FOREIGN KEY ("published_record_id") REFERENCES "public"."published_records"("id") ON DELETE no action ON UPDATE no action;

src/shared/infrastructure/database/migrations/0005_truncate-tables.sql

···
+-- Custom SQL migration file, put your code below! --
+-- Truncate all tables to wipe data but keep table structure
+-- CASCADE ensures foreign key constraints don't prevent truncation
+TRUNCATE TABLE "collection_cards",
+"collection_collaborators",
+"library_memberships",
+"collections",
+"cards",
+"published_records",
+"feed_activities" CASCADE;

src/shared/infrastructure/database/migrations/0006_lovely_randall.sql

···
+CREATE INDEX "cards_author_url_idx" ON "cards" USING btree ("author_id","url");--> statement-breakpoint
+CREATE INDEX "cards_author_id_idx" ON "cards" USING btree ("author_id");--> statement-breakpoint
+CREATE INDEX "collection_cards_card_id_idx" ON "collection_cards" USING btree ("card_id");--> statement-breakpoint
+CREATE INDEX "collection_cards_collection_id_idx" ON "collection_cards" USING btree ("collection_id");--> statement-breakpoint
+CREATE INDEX "collections_author_id_idx" ON "collections" USING btree ("author_id");--> statement-breakpoint
+CREATE INDEX "collections_author_updated_at_idx" ON "collections" USING btree ("author_id","updated_at");

src/shared/infrastructure/database/migrations/meta/0004_snapshot.json

···
+{
+  "id": "1e15b3e8-04ba-4e0a-965e-07142597ddc4",
+  "prevId": "69abc7ad-c872-43e9-8e83-4d9362cf62c7",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.app_password_sessions": {
+      "name": "app_password_sessions",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session_data": {
+          "name": "session_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "app_password": {
+          "name": "app_password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.cards": {
+      "name": "cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_data": {
+          "name": "content_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_card_id": {
+          "name": "parent_card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "library_count": {
+          "name": "library_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "cards_parent_card_id_cards_id_fk": {
+          "name": "cards_parent_card_id_cards_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "cards",
+          "columnsFrom": ["parent_card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "cards_published_record_id_published_records_id_fk": {
+          "name": "cards_published_record_id_published_records_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_cards": {
+      "name": "collection_cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by": {
+          "name": "added_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_cards_collection_id_collections_id_fk": {
+          "name": "collection_cards_collection_id_collections_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_card_id_cards_id_fk": {
+          "name": "collection_cards_card_id_cards_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_published_record_id_published_records_id_fk": {
+          "name": "collection_cards_published_record_id_published_records_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_collaborators": {
+      "name": "collection_collaborators",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "collaborator_id": {
+          "name": "collaborator_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_collaborators_collection_id_collections_id_fk": {
+          "name": "collection_collaborators_collection_id_collections_id_fk",
+          "tableFrom": "collection_collaborators",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collections": {
+      "name": "collections",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_type": {
+          "name": "access_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_count": {
+          "name": "card_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collections_published_record_id_published_records_id_fk": {
+          "name": "collections_published_record_id_published_records_id_fk",
+          "tableFrom": "collections",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.library_memberships": {
+      "name": "library_memberships",
+      "schema": "",
+      "columns": {
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_user_cards": {
+          "name": "idx_user_cards",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_card_users": {
+          "name": "idx_card_users",
+          "columns": [
+            {
+              "expression": "card_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "library_memberships_card_id_cards_id_fk": {
+          "name": "library_memberships_card_id_cards_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "library_memberships_published_record_id_published_records_id_fk": {
+          "name": "library_memberships_published_record_id_published_records_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "library_memberships_card_id_user_id_pk": {
+          "name": "library_memberships_card_id_user_id_pk",
+          "columns": ["card_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.published_records": {
+      "name": "published_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "uri": {
+          "name": "uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cid": {
+          "name": "cid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recorded_at": {
+          "name": "recorded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uri_cid_unique_idx": {
+          "name": "uri_cid_unique_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "cid",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "published_records_uri_idx": {
+          "name": "published_records_uri_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.feed_activities": {
+      "name": "feed_activities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_session": {
+      "name": "auth_session",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session": {
+          "name": "session",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_state": {
+      "name": "auth_state",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_refresh_tokens": {
+      "name": "auth_refresh_tokens",
+      "schema": "",
+      "columns": {
+        "token_id": {
+          "name": "token_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_did": {
+          "name": "user_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issued_at": {
+          "name": "issued_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked": {
+          "name": "revoked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_refresh_tokens_user_did_users_id_fk": {
+          "name": "auth_refresh_tokens_user_did_users_id_fk",
+          "tableFrom": "auth_refresh_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_did"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "handle": {
+          "name": "handle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "linked_at": {
+          "name": "linked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

src/shared/infrastructure/database/migrations/meta/0005_snapshot.json

···
+{
+  "id": "2d3157fe-869f-46ed-bcdc-03fc757f16c1",
+  "prevId": "1e15b3e8-04ba-4e0a-965e-07142597ddc4",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.app_password_sessions": {
+      "name": "app_password_sessions",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session_data": {
+          "name": "session_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "app_password": {
+          "name": "app_password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.cards": {
+      "name": "cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_data": {
+          "name": "content_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_card_id": {
+          "name": "parent_card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "library_count": {
+          "name": "library_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "cards_parent_card_id_cards_id_fk": {
+          "name": "cards_parent_card_id_cards_id_fk",
+          "tableFrom": "cards",
+          "columnsFrom": ["parent_card_id"],
+          "tableTo": "cards",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        },
+        "cards_published_record_id_published_records_id_fk": {
+          "name": "cards_published_record_id_published_records_id_fk",
+          "tableFrom": "cards",
+          "columnsFrom": ["published_record_id"],
+          "tableTo": "published_records",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_cards": {
+      "name": "collection_cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by": {
+          "name": "added_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_cards_collection_id_collections_id_fk": {
+          "name": "collection_cards_collection_id_collections_id_fk",
+          "tableFrom": "collection_cards",
+          "columnsFrom": ["collection_id"],
+          "tableTo": "collections",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "cascade"
+        },
+        "collection_cards_card_id_cards_id_fk": {
+          "name": "collection_cards_card_id_cards_id_fk",
+          "tableFrom": "collection_cards",
+          "columnsFrom": ["card_id"],
+          "tableTo": "cards",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "cascade"
+        },
+        "collection_cards_published_record_id_published_records_id_fk": {
+          "name": "collection_cards_published_record_id_published_records_id_fk",
+          "tableFrom": "collection_cards",
+          "columnsFrom": ["published_record_id"],
+          "tableTo": "published_records",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_collaborators": {
+      "name": "collection_collaborators",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "collaborator_id": {
+          "name": "collaborator_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_collaborators_collection_id_collections_id_fk": {
+          "name": "collection_collaborators_collection_id_collections_id_fk",
+          "tableFrom": "collection_collaborators",
+          "columnsFrom": ["collection_id"],
+          "tableTo": "collections",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "cascade"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collections": {
+      "name": "collections",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_type": {
+          "name": "access_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_count": {
+          "name": "card_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collections_published_record_id_published_records_id_fk": {
+          "name": "collections_published_record_id_published_records_id_fk",
+          "tableFrom": "collections",
+          "columnsFrom": ["published_record_id"],
+          "tableTo": "published_records",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.library_memberships": {
+      "name": "library_memberships",
+      "schema": "",
+      "columns": {
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_user_cards": {
+          "name": "idx_user_cards",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "with": {},
+          "method": "btree",
+          "concurrently": false
+        },
+        "idx_card_users": {
+          "name": "idx_card_users",
+          "columns": [
+            {
+              "expression": "card_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "with": {},
+          "method": "btree",
+          "concurrently": false
+        }
+      },
+      "foreignKeys": {
+        "library_memberships_card_id_cards_id_fk": {
+          "name": "library_memberships_card_id_cards_id_fk",
+          "tableFrom": "library_memberships",
+          "columnsFrom": ["card_id"],
+          "tableTo": "cards",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "cascade"
+        },
+        "library_memberships_published_record_id_published_records_id_fk": {
+          "name": "library_memberships_published_record_id_published_records_id_fk",
+          "tableFrom": "library_memberships",
+          "columnsFrom": ["published_record_id"],
+          "tableTo": "published_records",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "library_memberships_card_id_user_id_pk": {
+          "name": "library_memberships_card_id_user_id_pk",
+          "columns": ["card_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.published_records": {
+      "name": "published_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "uri": {
+          "name": "uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cid": {
+          "name": "cid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recorded_at": {
+          "name": "recorded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uri_cid_unique_idx": {
+          "name": "uri_cid_unique_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "cid",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "with": {},
+          "method": "btree",
+          "concurrently": false
+        },
+        "published_records_uri_idx": {
+          "name": "published_records_uri_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "with": {},
+          "method": "btree",
+          "concurrently": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.feed_activities": {
+      "name": "feed_activities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_session": {
+      "name": "auth_session",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session": {
+          "name": "session",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_state": {
+      "name": "auth_state",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_refresh_tokens": {
+      "name": "auth_refresh_tokens",
+      "schema": "",
+      "columns": {
+        "token_id": {
+          "name": "token_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_did": {
+          "name": "user_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issued_at": {
+          "name": "issued_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked": {
+          "name": "revoked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_refresh_tokens_user_did_users_id_fk": {
+          "name": "auth_refresh_tokens_user_did_users_id_fk",
+          "tableFrom": "auth_refresh_tokens",
+          "columnsFrom": ["user_did"],
+          "tableTo": "users",
+          "columnsTo": ["id"],
+          "onUpdate": "no action",
+          "onDelete": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "handle": {
+          "name": "handle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "linked_at": {
+          "name": "linked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "views": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

src/shared/infrastructure/database/migrations/meta/0006_snapshot.json

···
+{
+  "id": "8d99a964-b5d3-497c-9b09-42a60ce3b09e",
+  "prevId": "2d3157fe-869f-46ed-bcdc-03fc757f16c1",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.app_password_sessions": {
+      "name": "app_password_sessions",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session_data": {
+          "name": "session_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "app_password": {
+          "name": "app_password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.cards": {
+      "name": "cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_data": {
+          "name": "content_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_card_id": {
+          "name": "parent_card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "library_count": {
+          "name": "library_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "cards_author_url_idx": {
+          "name": "cards_author_url_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "url",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "cards_author_id_idx": {
+          "name": "cards_author_id_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "cards_parent_card_id_cards_id_fk": {
+          "name": "cards_parent_card_id_cards_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "cards",
+          "columnsFrom": ["parent_card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "cards_published_record_id_published_records_id_fk": {
+          "name": "cards_published_record_id_published_records_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_cards": {
+      "name": "collection_cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by": {
+          "name": "added_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "collection_cards_card_id_idx": {
+          "name": "collection_cards_card_id_idx",
+          "columns": [
+            {
+              "expression": "card_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "collection_cards_collection_id_idx": {
+          "name": "collection_cards_collection_id_idx",
+          "columns": [
+            {
+              "expression": "collection_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "collection_cards_collection_id_collections_id_fk": {
+          "name": "collection_cards_collection_id_collections_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_card_id_cards_id_fk": {
+          "name": "collection_cards_card_id_cards_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_published_record_id_published_records_id_fk": {
+          "name": "collection_cards_published_record_id_published_records_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_collaborators": {
+      "name": "collection_collaborators",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "collaborator_id": {
+          "name": "collaborator_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_collaborators_collection_id_collections_id_fk": {
+          "name": "collection_collaborators_collection_id_collections_id_fk",
+          "tableFrom": "collection_collaborators",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collections": {
+      "name": "collections",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_type": {
+          "name": "access_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_count": {
+          "name": "card_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "collections_author_id_idx": {
+          "name": "collections_author_id_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "collections_author_updated_at_idx": {
+          "name": "collections_author_updated_at_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "collections_published_record_id_published_records_id_fk": {
+          "name": "collections_published_record_id_published_records_id_fk",
+          "tableFrom": "collections",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.library_memberships": {
+      "name": "library_memberships",
+      "schema": "",
+      "columns": {
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_user_cards": {
+          "name": "idx_user_cards",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_card_users": {
+          "name": "idx_card_users",
+          "columns": [
+            {
+              "expression": "card_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "library_memberships_card_id_cards_id_fk": {
+          "name": "library_memberships_card_id_cards_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "library_memberships_published_record_id_published_records_id_fk": {
+          "name": "library_memberships_published_record_id_published_records_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "library_memberships_card_id_user_id_pk": {
+          "name": "library_memberships_card_id_user_id_pk",
+          "columns": ["card_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.published_records": {
+      "name": "published_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "uri": {
+          "name": "uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cid": {
+          "name": "cid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recorded_at": {
+          "name": "recorded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uri_cid_unique_idx": {
+          "name": "uri_cid_unique_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "cid",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "published_records_uri_idx": {
+          "name": "published_records_uri_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.feed_activities": {
+      "name": "feed_activities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_session": {
+      "name": "auth_session",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session": {
+          "name": "session",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_state": {
+      "name": "auth_state",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_refresh_tokens": {
+      "name": "auth_refresh_tokens",
+      "schema": "",
+      "columns": {
+        "token_id": {
+          "name": "token_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_did": {
+          "name": "user_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issued_at": {
+          "name": "issued_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked": {
+          "name": "revoked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_refresh_tokens_user_did_users_id_fk": {
+          "name": "auth_refresh_tokens_user_did_users_id_fk",
+          "tableFrom": "auth_refresh_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_did"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "handle": {
+          "name": "handle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "linked_at": {
+          "name": "linked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

src/shared/infrastructure/database/migrations/meta/_journal.json

···
       "when": 1758934838107,
       "tag": "0003_harsh_lady_mastermind",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1759875361391,
+      "tag": "0004_brainy_rocket_racer",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1759957391430,
+      "tag": "0005_truncate-tables",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "7",
+      "when": 1759962763890,
+      "tag": "0006_lovely_randall",
+      "breakpoints": true
     }
   ]
 }

src/shared/infrastructure/http/app.ts

···
     controllers.getLibrariesForCardController,
     controllers.getMyUrlCardsController,
     controllers.getUserUrlCardsController,
+    controllers.getUrlStatusForMyLibraryController,
     // Collection controllers
     controllers.createCollectionController,
     controllers.updateCollectionController,

src/shared/infrastructure/http/factories/ControllerFactory.ts

···
 import { GenerateExtensionTokensController } from 'src/modules/user/infrastructure/http/controllers/GenerateExtensionTokensController';
 import { GetUserCollectionsController } from 'src/modules/cards/infrastructure/http/controllers/GetUserCollectionsController';
 import { GetCollectionPageByAtUriController } from 'src/modules/cards/infrastructure/http/controllers/GetCollectionPageByAtUriController';
+import { GetUrlStatusForMyLibraryController } from '../../../../modules/cards/infrastructure/http/controllers/GetUrlStatusForMyLibraryController';
 
 export interface Controllers {
   // User controllers
···
   getCollectionPageByAtUriController: GetCollectionPageByAtUriController;
   getMyCollectionsController: GetMyCollectionsController;
   getCollectionsController: GetUserCollectionsController;
+  getUrlStatusForMyLibraryController: GetUrlStatusForMyLibraryController;
   // Feed controllers
   getGlobalFeedController: GetGlobalFeedController;
 }
···
       getCollectionsController: new GetUserCollectionsController(
         useCases.getCollectionsUseCase,
       ),
+      getUrlStatusForMyLibraryController:
+        new GetUrlStatusForMyLibraryController(
+          useCases.getUrlStatusForMyLibraryUseCase,
+        ),
 
       // Feed controllers
       getGlobalFeedController: new GetGlobalFeedController(

src/shared/infrastructure/http/factories/ServiceFactory.ts

···
   feedService: FeedService;
   nodeOauthClient: NodeOAuthClient;
   identityResolutionService: IIdentityResolutionService;
+  configService: EnvironmentConfigService;
 }
 
 // Web app specific services (includes publishers, auth middleware)
···
       : new AtProtoOAuthProcessor(sharedServices.nodeOauthClient);
 
     const useFakePublishers = process.env.USE_FAKE_PUBLISHERS === 'true';
+    const collections = configService.getAtProtoCollections();
 
     const collectionPublisher = useFakePublishers
       ? new FakeCollectionPublisher()
-      : new ATProtoCollectionPublisher(sharedServices.atProtoAgentService);
+      : new ATProtoCollectionPublisher(
+          sharedServices.atProtoAgentService,
+          collections.collection,
+          collections.collectionLink,
+        );
 
     const cardPublisher = useFakePublishers
       ? new FakeCardPublisher()
-      : new ATProtoCardPublisher(sharedServices.atProtoAgentService);
+      : new ATProtoCardPublisher(
+          sharedServices.atProtoAgentService,
+          collections.card,
+        );
 
     const cardCollectionService = new CardCollectionService(
       repositories.collectionRepository,
···
       feedService,
       nodeOauthClient,
       identityResolutionService,
+      configService,
     };
   }
 }

src/shared/infrastructure/http/factories/UseCaseFactory.ts

···
 import { AddActivityToFeedUseCase } from '../../../../modules/feeds/application/useCases/commands/AddActivityToFeedUseCase';
 import { GetCollectionsUseCase } from 'src/modules/cards/application/useCases/queries/GetCollectionsUseCase';
 import { GetCollectionPageByAtUriUseCase } from 'src/modules/cards/application/useCases/queries/GetCollectionPageByAtUriUseCase';
+import { GetUrlStatusForMyLibraryUseCase } from '../../../../modules/cards/application/useCases/queries/GetUrlStatusForMyLibraryUseCase';
 
 export interface UseCases {
   // User use cases
···
   getCollectionPageUseCase: GetCollectionPageUseCase;
   getCollectionPageByAtUriUseCase: GetCollectionPageByAtUriUseCase;
   getCollectionsUseCase: GetCollectionsUseCase;
+  getUrlStatusForMyLibraryUseCase: GetUrlStatusForMyLibraryUseCase;
   // Feed use cases
   getGlobalFeedUseCase: GetGlobalFeedUseCase;
   addActivityToFeedUseCase: AddActivityToFeedUseCase;
···
         services.identityResolutionService,
         repositories.atUriResolutionService,
         getCollectionPageUseCase,
+        services.configService.getAtProtoCollections().collection,
       ),
       getCollectionsUseCase: new GetCollectionsUseCase(
         repositories.collectionQueryRepository,
         services.profileService,
         services.identityResolutionService,
+      ),
+      getUrlStatusForMyLibraryUseCase: new GetUrlStatusForMyLibraryUseCase(
+        repositories.cardRepository,
+        repositories.collectionQueryRepository,
+        services.eventPublisher,
       ),
 
       // Feed use cases

src/webapp/api-client/ApiClient.ts

···
   GetUrlCardsResponse,
   GetProfileResponse,
   GetProfileParams,
+  GetUrlStatusForMyLibraryParams,
+  GetUrlStatusForMyLibraryResponse,
 } from './types';
 
 // Main API Client class using composition
···
     params: GetCollectionsParams,
   ): Promise<GetCollectionsResponse> {
     return this.queryClient.getUserCollections(params);
+  }
+
+  async getUrlStatusForMyLibrary(
+    params: GetUrlStatusForMyLibraryParams,
+  ): Promise<GetUrlStatusForMyLibraryResponse> {
+    this.requireAuthentication('getUrlStatusForMyLibrary');
+    return this.queryClient.getUrlStatusForMyLibrary(params);
   }
 
   // Card operations - delegate to CardClient (all require authentication)

src/webapp/api-client/clients/QueryClient.ts

···
   GetProfileResponse,
   GetCollectionPageResponse,
   GetCollectionsResponse,
+  GetUrlStatusForMyLibraryResponse,
   GetMyUrlCardsParams,
   GetUrlCardsParams,
   GetCollectionPageParams,
···
   GetCollectionsParams,
   GetCollectionPageByAtUriParams,
   GetProfileParams,
+  GetUrlStatusForMyLibraryParams,
 } from '../types';
 
 export class QueryClient extends BaseClient {
···
       : `/api/collections/user/${params.identifier}`;
 
     return this.request<GetCollectionsResponse>('GET', endpoint);
+  }
+
+  async getUrlStatusForMyLibrary(
+    params: GetUrlStatusForMyLibraryParams,
+  ): Promise<GetUrlStatusForMyLibraryResponse> {
+    const searchParams = new URLSearchParams({ url: params.url });
+    return this.request<GetUrlStatusForMyLibraryResponse>(
+      'GET',
+      `/api/cards/library/status?${searchParams}`,
+    );
   }
 }

src/webapp/api-client/types/requests.ts

···
 export interface GetProfileParams {
   identifier: string; // Can be DID or handle
 }
+
+export interface GetUrlStatusForMyLibraryParams {
+  url: string;
+}

src/webapp/api-client/types/responses.ts

···
 
 export interface GetUrlMetadataResponse {
   metadata: UrlMetadata;
-  existingCardId?: string;
 }
 
 export interface UrlCardView {
···
     nextCursor?: string;
   };
 }
+
+export interface GetUrlStatusForMyLibraryResponse {
+  cardId?: string;
+  collections?: {
+    id: string;
+    uri?: string;
+    name: string;
+    description?: string;
+  }[];
+}

src/webapp/components/UrlCardForm.tsx

···
   // URL metadata hook
   const {
     metadata,
-    existingCard,
+    existingCardCollections,
     loading: metadataLoading,
     error: metadataError,
   } = useUrlMetadata({
···
 
   // Get existing collections for this card (filtered by current user)
   const existingCollections = useMemo(() => {
-    if (!existingCard || !userId) return [];
-    return existingCard.collections.filter(
-      (collection) => collection.authorId === userId,
-    );
-  }, [existingCard, userId]);
+    if (!existingCardCollections || !userId) return [];
+    return existingCardCollections.map((c) => ({ ...c, authorId: userId }));
+  }, [existingCardCollections, userId]);
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();

src/webapp/features/cards/components/addCardToModal/AddCardToModal.tsx

···
   Alert,
 } from '@mantine/core';
 import { useDebouncedValue } from '@mantine/hooks';
+import { notifications } from '@mantine/notifications';
 import { Fragment, useState } from 'react';
 import { IoSearch } from 'react-icons/io5';
 import { BiPlus } from 'react-icons/bi';
-import useMyCollections from '../../../collections/lib/queries/useMyCollections';
-import useCard from '@/features/cards/lib/queries/useGetCard';
-import { notifications } from '@mantine/notifications';
 import CollectionSelectorError from '../../../collections/components/collectionSelector/Error.CollectionSelector';
 import CollectionSelectorItemList from '../../../collections/components/collectionSelectorItemList/CollectionSelectorItemList';
 import CreateCollectionDrawer from '../../../collections/components/createCollectionDrawer/CreateCollectionDrawer';
 import CardToBeAddedPreview from './CardToBeAddedPreview';
 import useAddCardToLibrary from '../../lib/mutations/useAddCardToLibrary';
-import useGetLibrariesForCard from '../../lib/queries/useGetLibrariesForcard';
-import { useAuth } from '@/hooks/useAuth';
+import useGetCardFromMyLibrary from '../../lib/queries/useGetCardFromMyLibrary';
+import useMyCollections from '../../../collections/lib/queries/useMyCollections';
 
 interface Props {
   isOpen: boolean;
···
 }
 
 export default function AddCardToModal(props: Props) {
-  const { user, isLoading: isLoadingUser } = useAuth();
   const [isDrawerOpen, setIsDrawerOpen] = useState(false);
 
   const [search, setSearch] = useState<string>('');
   const [debouncedSearch] = useDebouncedValue(search, 200);
   const searchedCollections = useCollectionSearch({ query: debouncedSearch });
 
-  const libraries = useGetLibrariesForCard({ id: props.cardId });
-  const isInUserLibrary = libraries.data.users.some((u) => u.id === user?.id);
+  const addCardToLibrary = useAddCardToLibrary();
 
-  const addCardToLibrary = useAddCardToLibrary();
-  const card = useCard({ id: props.cardId });
+  const cardStaus = useGetCardFromMyLibrary({ url: props.cardContent.url });
   const { data, error } = useMyCollections();
   const [selectedCollections, setSelectedCollections] = useState<
     SelectableCollectionItem[]
···
     data?.pages.flatMap((page) => page.collections ?? []) ?? [];
 
   const collectionsWithCard = allCollections.filter((c) =>
-    card.data?.collections.some((col) => col.id === c.id),
+    cardStaus.data.collections?.some((col) => col.id === c.id),
   );
 
   const collectionsWithoutCard = allCollections.filter(
     (c) => !collectionsWithCard.some((col) => col.id === c.id),
   );
+
+  const isInUserLibrary = collectionsWithCard.length > 0;
 
   const hasCollections = allCollections.length > 0;
   const hasSelectedCollections = selectedCollections.length > 0;
···
 
     addCardToLibrary.mutate(
       {
-        cardId: props.cardId,
+        url: props.cardContent.url,
         collectionIds: selectedCollections.map((c) => c.id),
       },
       {
···
                 onClick={handleAddCard}
                 // disabled when:
                 // user already has the card in a collection (and therefore in library)
-                // and when it's already in library and no new collection is selected yet
-                disabled={
-                  isLoadingUser ||
-                  (isInUserLibrary && selectedCollections.length === 0)
-                }
+                // and no new collection is selected yet
+                disabled={isInUserLibrary && selectedCollections.length === 0}
                 loading={addCardToLibrary.isPending}
               >
                 Add

src/webapp/features/cards/components/addCardToModal/CardToBeAddedPreview.tsx

···
   Anchor,
 } from '@mantine/core';
 import Link from 'next/link';
-import { GetCollectionsResponse, UrlCardView } from '@/api-client/types';
+import {
+  GetUrlStatusForMyLibraryResponse,
+  UrlCardView,
+} from '@/api-client/types';
 import { BiCollection } from 'react-icons/bi';
 import { LuLibrary } from 'react-icons/lu';
 import { getDomain } from '@/lib/utils/link';
 import useMyProfile from '@/features/profile/lib/queries/useMyProfile';
 import { getRecordKey } from '@/lib/utils/atproto';
+import { Fragment } from 'react';
 
 interface Props {
   cardId: string;
   cardContent: UrlCardView['cardContent'];
-  collectionsWithCard: GetCollectionsResponse['collections'];
+  collectionsWithCard: GetUrlStatusForMyLibraryResponse['collections'];
   isInLibrary: boolean;
 }
 
···
             In Library
           </Button>
         )}
-        {props.collectionsWithCard.length > 0 && (
+        {props.collectionsWithCard && props.collectionsWithCard.length > 0 && (
           <Menu shadow="sm">
             <Menu.Target>
               <Button
···
             <Menu.Dropdown maw={380}>
               <ScrollArea.Autosize mah={150} type="auto">
                 {props.collectionsWithCard.map((c) => (
-                  <Menu.Item
-                    key={c.id}
-                    component={Link}
-                    href={`/profile/${c.createdBy.handle}/collections/${getRecordKey(c.uri!)}`}
-                    target="_blank"
-                    c="blue"
-                    fw={600}
-                  >
-                    {c.name}
-                  </Menu.Item>
+                  <Fragment key={c.id}>
+                    {c.uri && (
+                      <Menu.Item
+                        component={Link}
+                        href={`/profile/${profile.handle}/collections/${getRecordKey(c.uri)}`}
+                        target="_blank"
+                        c="blue"
+                        fw={600}
+                      >
+                        {c.name}
+                      </Menu.Item>
+                    )}
+                  </Fragment>
                 ))}
               </ScrollArea.Autosize>
             </Menu.Dropdown>

src/webapp/features/cards/lib/mutations/useAddCardToLibrary.tsx

···
 
   const mutation = useMutation({
     mutationFn: ({
-      cardId,
+      url,
+      note,
       collectionIds,
     }: {
-      cardId: string;
+      url: string;
+      note?: string;
       collectionIds: string[];
     }) => {
-      return apiClient.addCardToLibrary({ cardId, collectionIds });
+      return apiClient.addUrlToLibrary({ url, note, collectionIds });
     },
 
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['card', variables.cardId] });
+    onSuccess: (data, variables) => {
+      queryClient.invalidateQueries({ queryKey: ['card', data.urlCardId] });
+      queryClient.invalidateQueries({ queryKey: ['card', data.noteCardId] });
+      queryClient.invalidateQueries({ queryKey: ['card', variables.url] });
       queryClient.invalidateQueries({ queryKey: ['my cards'] });
       queryClient.invalidateQueries({ queryKey: ['home'] });
       queryClient.invalidateQueries({ queryKey: ['collections'] });

src/webapp/features/cards/lib/queries/useGetCard.tsx

···
   id: string;
 }
 
-export default function useCard(props: Props) {
+export default function useGetCard(props: Props) {
   const apiClient = new ApiClient(
     process.env.NEXT_PUBLIC_API_BASE_URL || 'http://localhost:3000',
     createClientTokenManager(),

src/webapp/features/cards/lib/queries/useGetCardFromMyLibrary.tsx

···
+import { ApiClient } from '@/api-client/ApiClient';
+import { createClientTokenManager } from '@/services/auth';
+import { useSuspenseQuery } from '@tanstack/react-query';
+
+interface Props {
+  url: string;
+}
+
+export default function useGetCardFromMyLibrary(props: Props) {
+  const apiClient = new ApiClient(
+    process.env.NEXT_PUBLIC_API_BASE_URL || 'http://localhost:3000',
+    createClientTokenManager(),
+  );
+
+  const cardStatus = useSuspenseQuery({
+    queryKey: ['card from my library', props.url],
+    queryFn: () => apiClient.getUrlStatusForMyLibrary({ url: props.url }),
+  });
+
+  return cardStatus;
+}

src/webapp/features/collections/components/addToCollectionModal/AddToCollectionModal.tsx

···
-import { UrlCardView } from '@/api-client/types';
-import useCollectionSearch from '../../lib/queries/useCollectionSearch';
-import { DEFAULT_OVERLAY_PROPS } from '@/styles/overlays';
-import {
-  Group,
-  Modal,
-  Stack,
-  Text,
-  TextInput,
-  CloseButton,
-  Tabs,
-  ScrollArea,
-  Button,
-  Loader,
-  Alert,
-} from '@mantine/core';
-import { useDebouncedValue } from '@mantine/hooks';
-import { Fragment, useState } from 'react';
-import { IoSearch } from 'react-icons/io5';
-import { BiPlus } from 'react-icons/bi';
-import useMyCollections from '../../lib/queries/useMyCollections';
-import useCard from '@/features/cards/lib/queries/useGetCard';
-import useAddCardToCollection from '@/features/collections/lib/mutations/useAddCardToCollection';
-import { notifications } from '@mantine/notifications';
-import CollectionSelectorError from '../collectionSelector/Error.CollectionSelector';
-import CardToBeAddedPreview from './CardToBeAddedPreview';
-import CollectionSelectorItemList from '../collectionSelectorItemList/CollectionSelectorItemList';
-import CreateCollectionDrawer from '../createCollectionDrawer/CreateCollectionDrawer';
-
-interface Props {
-  isOpen: boolean;
-  onClose: () => void;
-  cardContent: UrlCardView['cardContent'];
-  cardId: string;
-}
-
-export default function AddToCollectionModal(props: Props) {
-  const [isDrawerOpen, setIsDrawerOpen] = useState(false);
-
-  const [search, setSearch] = useState<string>('');
-  const [debouncedSearch] = useDebouncedValue(search, 200);
-  const searchedCollections = useCollectionSearch({ query: debouncedSearch });
-
-  const addCardToCollection = useAddCardToCollection();
-  const card = useCard({ id: props.cardId });
-  const { data, error } = useMyCollections();
-  const [selectedCollections, setSelectedCollections] = useState<
-    SelectableCollectionItem[]
-  >([]);
-
-  const handleCollectionChange = (
-    checked: boolean,
-    item: SelectableCollectionItem,
-  ) => {
-    if (checked) {
-      if (!selectedCollections.some((col) => col.id === item.id)) {
-        setSelectedCollections([...selectedCollections, item]);
-      }
-    } else {
-      setSelectedCollections(
-        selectedCollections.filter((col) => col.id !== item.id),
-      );
-    }
-  };
-
-  const allCollections =
-    data?.pages.flatMap((page) => page.collections ?? []) ?? [];
-
-  const collectionsWithCard = allCollections.filter((c) =>
-    card.data?.collections.some((col) => col.id === c.id),
-  );
-
-  const collectionsWithoutCard = allCollections.filter(
-    (c) => !collectionsWithCard.some((col) => col.id === c.id),
-  );
-
-  const hasCollections = allCollections.length > 0;
-  const hasSelectedCollections = selectedCollections.length > 0;
-
-  const handleAddCardToCollection = (e: React.FormEvent) => {
-    e.preventDefault();
-
-    addCardToCollection.mutate(
-      {
-        cardId: props.cardId,
-        collectionIds: selectedCollections.map((c) => c.id),
-      },
-      {
-        onSuccess: () => {
-          setSelectedCollections([]);
-          props.onClose();
-        },
-        onError: () => {
-          notifications.show({
-            message: 'Could not add card.',
-          });
-        },
-        onSettled: () => {
-          setSelectedCollections([]);
-          props.onClose();
-        },
-      },
-    );
-  };
-
-  if (error) {
-    return <CollectionSelectorError />;
-  }
-
-  return (
-    <Modal
-      opened={props.isOpen}
-      onClose={props.onClose}
-      title="Add to Collections"
-      overlayProps={DEFAULT_OVERLAY_PROPS}
-      centered
-    >
-      <Stack gap={'xl'}>
-        <CardToBeAddedPreview
-          cardContent={props.cardContent}
-          collectionsWithCard={collectionsWithCard}
-        />
-
-        <Stack gap={'md'}>
-          <TextInput
-            placeholder="Search for collections"
-            value={search}
-            onChange={(e) => {
-              setSearch(e.currentTarget.value);
-            }}
-            size="md"
-            variant="filled"
-            id="search"
-            leftSection={<IoSearch size={22} />}
-            rightSection={
-              <CloseButton
-                aria-label="Clear input"
-                onClick={() => setSearch('')}
-                style={{ display: search ? undefined : 'none' }}
-              />
-            }
-          />
-          <Stack gap={'xl'}>
-            <Tabs defaultValue={'collections'}>
-              <Tabs.List grow>
-                <Tabs.Tab value="collections">Collections</Tabs.Tab>
-                <Tabs.Tab value="selected">
-                  Selected ({selectedCollections.length})
-                </Tabs.Tab>
-              </Tabs.List>
-
-              <Tabs.Panel value="collections" my="xs" w="100%">
-                <ScrollArea.Autosize mah={200} type="auto">
-                  <Stack gap="xs">
-                    {search ? (
-                      <Fragment>
-                        <Button
-                          variant="light"
-                          size="md"
-                          color="grape"
-                          radius="lg"
-                          leftSection={<BiPlus size={22} />}
-                          onClick={() => setIsDrawerOpen(true)}
-                        >
-                          Create new collection "{search}"
-                        </Button>
-
-                        {searchedCollections.isPending && (
-                          <Stack align="center">
-                            <Text fw={500} c="gray">
-                              Searching collections...
-                            </Text>
-                            <Loader color="gray" />
-                          </Stack>
-                        )}
-
-                        {searchedCollections.data &&
-                          (searchedCollections.data.collections.length === 0 ? (
-                            <Alert
-                              color="gray"
-                              title={`No results found for "${search}"`}
-                            />
-                          ) : (
-                            <CollectionSelectorItemList
-                              collections={searchedCollections.data.collections}
-                              collectionsWithCard={collectionsWithCard}
-                              selectedCollections={selectedCollections}
-                              onChange={handleCollectionChange}
-                            />
-                          ))}
-                      </Fragment>
-                    ) : hasCollections ? (
-                      <CollectionSelectorItemList
-                        collections={collectionsWithoutCard}
-                        selectedCollections={selectedCollections}
-                        onChange={handleCollectionChange}
-                      />
-                    ) : (
-                      <Stack align="center" gap="xs">
-                        <Text fz="lg" fw={600} c="gray">
-                          No collections
-                        </Text>
-                        <Button
-                          onClick={() => setIsDrawerOpen(true)}
-                          variant="light"
-                          color="gray"
-                          rightSection={<BiPlus size={22} />}
-                        >
-                          Create a collection
-                        </Button>
-                      </Stack>
-                    )}
-                  </Stack>
-                </ScrollArea.Autosize>
-              </Tabs.Panel>
-
-              <Tabs.Panel value="selected" my="xs">
-                <ScrollArea.Autosize mah={200} type="auto">
-                  <Stack gap="xs">
-                    {hasSelectedCollections ? (
-                      <CollectionSelectorItemList
-                        collections={selectedCollections}
-                        selectedCollections={selectedCollections}
-                        onChange={handleCollectionChange}
-                      />
-                    ) : (
-                      <Alert color="gray" title="No collections selected" />
-                    )}
-                  </Stack>
-                </ScrollArea.Autosize>
-              </Tabs.Panel>
-            </Tabs>
-
-            <Group justify="space-between" gap="xs" grow>
-              <Button
-                variant="light"
-                color="gray"
-                size="md"
-                onClick={() => {
-                  setSelectedCollections([]);
-                  props.onClose();
-                }}
-              >
-                Cancel
-              </Button>
-              {hasSelectedCollections && (
-                <Button
-                  variant="light"
-                  color="grape"
-                  size="md"
-                  onClick={() => setSelectedCollections([])}
-                >
-                  Clear
-                </Button>
-              )}
-              <Button
-                size="md"
-                onClick={handleAddCardToCollection}
-                disabled={selectedCollections.length === 0}
-                loading={addCardToCollection.isPending}
-              >
-                Save
-              </Button>
-            </Group>
-          </Stack>
-        </Stack>
-      </Stack>
-      <CreateCollectionDrawer
-        key={search}
-        isOpen={isDrawerOpen}
-        onClose={() => setIsDrawerOpen(false)}
-        initialName={search}
-        onCreate={(newCollection) => {
-          setSelectedCollections([...selectedCollections, newCollection]);
-        }}
-      />
-    </Modal>
-  );
-}

src/webapp/features/collections/components/addToCollectionModal/CardToBeAddedPreview.tsx

···
-import {
-  AspectRatio,
-  Group,
-  Stack,
-  Image,
-  Text,
-  Card,
-  Menu,
-  Button,
-  ScrollArea,
-  Anchor,
-} from '@mantine/core';
-import { GetCollectionsResponse, UrlCardView } from '@/api-client/types';
-import Link from 'next/link';
-import { getDomain } from '@/lib/utils/link';
-import { BiSolidChevronDownCircle } from 'react-icons/bi';
-
-interface Props {
-  cardContent: UrlCardView['cardContent'];
-  collectionsWithCard: GetCollectionsResponse['collections'];
-}
-
-export default function CardToBeAddedPreview(props: Props) {
-  const domain = getDomain(props.cardContent.url);
-
-  return (
-    <Stack gap={'md'}>
-      <Card withBorder p={'xs'} radius={'lg'}>
-        <Stack>
-          <Group gap={'sm'}>
-            {props.cardContent.thumbnailUrl && (
-              <AspectRatio ratio={1 / 1} flex={0.1}>
-                <Image
-                  src={props.cardContent.thumbnailUrl}
-                  alt={`${props.cardContent.url} social preview image`}
-                  radius={'md'}
-                  w={50}
-                  h={50}
-                />
-              </AspectRatio>
-            )}
-            <Stack gap={0} flex={0.9}>
-              <Anchor
-                component={Link}
-                href={props.cardContent.url}
-                target="_blank"
-                c={'gray'}
-                lineClamp={1}
-              >
-                {domain}
-              </Anchor>
-              {props.cardContent.title && (
-                <Text fw={500} lineClamp={1}>
-                  {props.cardContent.title}
-                </Text>
-              )}
-            </Stack>
-          </Group>
-          {props.collectionsWithCard.length > 0 && (
-            <Menu shadow="sm">
-              <Menu.Target>
-                <Button
-                  variant="light"
-                  color="grape"
-                  rightSection={<BiSolidChevronDownCircle />}
-                >
-                  Already in {props.collectionsWithCard.length} collection
-                  {props.collectionsWithCard.length !== 1 && 's'}
-                </Button>
-              </Menu.Target>
-              <Menu.Dropdown maw={380}>
-                <ScrollArea.Autosize mah={150} type="auto">
-                  {props.collectionsWithCard.map((c) => (
-                    <Menu.Item
-                      key={c.id}
-                      component={Link}
-                      href={`/profile/${c.createdBy.handle}/collections/${c.id}`}
-                      target="_blank"
-                      c="blue"
-                      fw={600}
-                    >
-                      {c.name}
-                    </Menu.Item>
-                  ))}
-                </ScrollArea.Autosize>
-              </Menu.Dropdown>
-            </Menu>
-          )}
-        </Stack>
-      </Card>
-    </Stack>
-  );
-}

src/webapp/hooks/useUrlMetadata.ts

···
 import { useState, useEffect, useCallback } from 'react';
 import { ApiClient } from '@/api-client/ApiClient';
 import type { UrlMetadata } from '@/components/UrlMetadataDisplay';
-import type { UrlCardView } from '@/api-client/types';
+import type {
+  GetUrlStatusForMyLibraryResponse,
+  UrlCardView,
+} from '@/api-client/types';
 
 interface UseUrlMetadataProps {
   apiClient: ApiClient;
···
   autoFetch = true,
 }: UseUrlMetadataProps) {
   const [metadata, setMetadata] = useState<UrlMetadata | null>(null);
-  const [existingCard, setExistingCard] = useState<UrlCardView | null>(null);
+  const [existingCardCollections, setExistingCardCollections] = useState<
+    GetUrlStatusForMyLibraryResponse['collections'] | null
+  >(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
···
 
       setLoading(true);
       setError(null);
-      setExistingCard(null);
+      setExistingCardCollections(null);
 
       try {
         const response = await apiClient.getUrlMetadata(targetUrl);
         setMetadata(response.metadata);
 
-        // If there's an existing card, fetch its details including collections
-        if (response.existingCardId) {
+        const existingCard = await apiClient.getUrlStatusForMyLibrary({
+          url: targetUrl,
+        });
+
+        // If there's an existing card, fetch its collections
+        if (existingCard.cardId) {
           try {
-            const cardResponse = await apiClient.getUrlCardView(
-              response.existingCardId,
-            );
-            setExistingCard(cardResponse);
+            setExistingCardCollections(existingCard.collections);
           } catch (cardErr: any) {
             console.error('Failed to fetch existing card details:', cardErr);
             // Don't set error here as the metadata fetch was successful
···
         console.error('Failed to fetch URL metadata:', err);
         setError('Failed to load page information');
         setMetadata(null);
-        setExistingCard(null);
+        setExistingCardCollections(null);
       } finally {
         setLoading(false);
       }
···
 
   return {
     metadata,
-    existingCard,
+    existingCardCollections,
     loading,
     error,
     fetchMetadata,