@ewanc26/atproto 0.1.0 → 0.2.0

package/dist/fetch.js

@@ -0,0 +1,280 @@
+import { cache } from './cache.js';
+import { withFallback, resolveIdentity } from './agents.js';
+import { buildPdsBlobUrl } from './media.js';
+import { findArtwork } from './musicbrainz.js';
+export async function fetchProfile(did, fetchFn) {
+    const cacheKey = `profile:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const profile = await withFallback(did, async (agent) => {
+        const response = await agent.getProfile({ actor: did });
+        return response.data;
+    }, false, fetchFn);
+    let pronouns;
+    try {
+        const recordResponse = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.getRecord({
+                repo: did,
+                collection: 'app.bsky.actor.profile',
+                rkey: 'self'
+            });
+            return response.data;
+        }, false, fetchFn);
+        pronouns = recordResponse.value.pronouns;
+    }
+    catch { /* pronouns optional */ }
+    const data = {
+        did: profile.did,
+        handle: profile.handle,
+        displayName: profile.displayName,
+        description: profile.description,
+        avatar: profile.avatar,
+        banner: profile.banner,
+        followersCount: profile.followersCount,
+        followsCount: profile.followsCount,
+        postsCount: profile.postsCount,
+        pronouns
+    };
+    cache.set(cacheKey, data);
+    return data;
+}
+export async function fetchSiteInfo(did, fetchFn) {
+    const cacheKey = `siteinfo:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const result = await withFallback(did, async (agent) => {
+            try {
+                const response = await agent.com.atproto.repo.getRecord({
+                    repo: did,
+                    collection: 'uk.ewancroft.site.info',
+                    rkey: 'self'
+                });
+                return response.data;
+            }
+            catch (err) {
+                if (err.error === 'RecordNotFound')
+                    return null;
+                throw err;
+            }
+        }, true, fetchFn);
+        if (!result?.value)
+            return null;
+        const data = result.value;
+        cache.set(cacheKey, data);
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchLinks(did, fetchFn) {
+    const cacheKey = `links:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const value = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.getRecord({
+                repo: did,
+                collection: 'blue.linkat.board',
+                rkey: 'self'
+            });
+            return response.data.value;
+        }, true, fetchFn);
+        if (!value || !Array.isArray(value.cards))
+            return null;
+        const data = { cards: value.cards };
+        cache.set(cacheKey, data);
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchMusicStatus(did, fetchFn) {
+    const cacheKey = `music-status:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        // Try actor status first
+        try {
+            const statusRecords = await withFallback(did, async (agent) => {
+                const response = await agent.com.atproto.repo.listRecords({
+                    repo: did,
+                    collection: 'fm.teal.alpha.actor.status',
+                    limit: 1
+                });
+                return response.data.records;
+            }, true, fetchFn);
+            if (statusRecords?.length) {
+                const record = statusRecords[0];
+                const value = record.value;
+                if (value.expiry) {
+                    const expiryTime = parseInt(value.expiry) * 1000;
+                    if (Date.now() <= expiryTime) {
+                        const trackName = value.item?.trackName || value.trackName;
+                        const artists = value.item?.artists || value.artists || [];
+                        const releaseName = value.item?.releaseName || value.releaseName;
+                        const artistName = artists[0]?.artistName;
+                        const releaseMbId = value.item?.releaseMbId || value.releaseMbId;
+                        let artworkUrl;
+                        if (releaseName && artistName) {
+                            artworkUrl = (await findArtwork(releaseName, artistName, releaseName, releaseMbId, fetchFn)) || undefined;
+                        }
+                        if (!artworkUrl && trackName && artistName) {
+                            artworkUrl = (await findArtwork(trackName, artistName, releaseName, releaseMbId, fetchFn)) || undefined;
+                        }
+                        if (!artworkUrl) {
+                            const artwork = value.item?.artwork || value.artwork;
+                            if (artwork?.ref?.$link) {
+                                const identity = await resolveIdentity(did, fetchFn);
+                                artworkUrl = buildPdsBlobUrl(identity.pds, did, artwork.ref.$link);
+                            }
+                        }
+                        const data = {
+                            trackName,
+                            artists,
+                            releaseName,
+                            playedTime: value.item?.playedTime || value.playedTime,
+                            originUrl: value.item?.originUrl || value.originUrl,
+                            recordingMbId: value.item?.recordingMbId || value.recordingMbId,
+                            releaseMbId,
+                            isrc: value.isrc,
+                            duration: value.duration,
+                            musicServiceBaseDomain: value.item?.musicServiceBaseDomain || value.musicServiceBaseDomain,
+                            submissionClientAgent: value.item?.submissionClientAgent || value.submissionClientAgent,
+                            $type: 'fm.teal.alpha.actor.status',
+                            expiry: value.expiry,
+                            artwork: value.item?.artwork || value.artwork,
+                            artworkUrl
+                        };
+                        cache.set(cacheKey, data);
+                        return data;
+                    }
+                }
+            }
+        }
+        catch { /* fall through to feed play */ }
+        // Fall back to feed play
+        const playRecords = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.listRecords({
+                repo: did,
+                collection: 'fm.teal.alpha.feed.play',
+                limit: 1
+            });
+            return response.data.records;
+        }, true, fetchFn);
+        if (playRecords?.length) {
+            const record = playRecords[0];
+            const value = record.value;
+            const artists = value.artists || [];
+            const artistName = artists[0]?.artistName;
+            let artworkUrl;
+            if (value.releaseName && artistName) {
+                artworkUrl = (await findArtwork(value.releaseName, artistName, value.releaseName, value.releaseMbId, fetchFn)) || undefined;
+            }
+            if (!artworkUrl && value.trackName && artistName) {
+                artworkUrl = (await findArtwork(value.trackName, artistName, value.releaseName, value.releaseMbId, fetchFn)) || undefined;
+            }
+            if (!artworkUrl && value.artwork?.ref?.$link) {
+                const identity = await resolveIdentity(did, fetchFn);
+                artworkUrl = buildPdsBlobUrl(identity.pds, did, value.artwork.ref.$link);
+            }
+            const data = {
+                trackName: value.trackName,
+                artists,
+                releaseName: value.releaseName,
+                playedTime: value.playedTime,
+                originUrl: value.originUrl,
+                recordingMbId: value.recordingMbId,
+                releaseMbId: value.releaseMbId,
+                isrc: value.isrc,
+                duration: value.duration,
+                musicServiceBaseDomain: value.musicServiceBaseDomain,
+                submissionClientAgent: value.submissionClientAgent,
+                $type: 'fm.teal.alpha.feed.play',
+                artwork: value.artwork,
+                artworkUrl
+            };
+            cache.set(cacheKey, data);
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchKibunStatus(did, fetchFn) {
+    const cacheKey = `kibun-status:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const statusRecords = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.listRecords({
+                repo: did,
+                collection: 'social.kibun.status',
+                limit: 1
+            });
+            return response.data.records;
+        }, true, fetchFn);
+        if (statusRecords?.length) {
+            const value = statusRecords[0].value;
+            const data = {
+                text: value.text,
+                emoji: value.emoji,
+                createdAt: value.createdAt,
+                $type: 'social.kibun.status'
+            };
+            cache.set(cacheKey, data);
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchTangledRepos(did, fetchFn) {
+    const cacheKey = `tangled:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const records = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.listRecords({
+                repo: did,
+                collection: 'sh.tangled.repo',
+                limit: 100
+            });
+            return response.data.records;
+        }, true, fetchFn);
+        if (!records.length)
+            return null;
+        const repos = records.map((record) => {
+            const value = record.value;
+            return {
+                uri: record.uri,
+                name: value.name,
+                description: value.description,
+                knot: value.knot,
+                createdAt: value.createdAt,
+                labels: value.labels,
+                source: value.source,
+                spindle: value.spindle
+            };
+        });
+        repos.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        const data = { repos };
+        cache.set(cacheKey, data);
+        return data;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export type { ProfileData, SiteInfoData, LinkData, LinkCard, BlueskyPost, BlogPost, PostAuthor, ExternalLink, Facet, Technology, License, BasedOnItem, RelatedService, Repository, Credit, SectionLicense, ResolvedIdentity, CacheEntry, MusicStatusData, MusicArtist, KibunStatusData, TangledRepo, TangledReposData, StandardSitePublication, StandardSitePublicationsData, StandardSiteDocument, StandardSiteDocumentsData, StandardSiteBasicTheme, StandardSiteThemeColor } from './types';
+export { fetchProfile, fetchSiteInfo, fetchLinks, fetchMusicStatus, fetchKibunStatus, fetchTangledRepos } from './fetch';
+export { fetchPublications, fetchDocuments, fetchRecentDocuments, fetchBlogPosts } from './documents';
+export { fetchLatestBlueskyPost, fetchPostFromUri } from './posts';
+export { buildPdsBlobUrl, extractCidFromImageObject, extractImageUrlsFromValue } from './media';
+export { createAgent, constellationAgent, defaultAgent, resolveIdentity, getPublicAgent, getPDSAgent, withFallback, resetAgents } from './agents';
+export { searchMusicBrainzRelease, buildCoverArtUrl, searchiTunesArtwork, searchDeezerArtwork, searchLastFmArtwork, findArtwork } from './musicbrainz';
+export { fetchEngagementFromConstellation, fetchAllEngagement } from './engagement';
+export { cache, ATProtoCache, CACHE_TTL } from './cache';
+export { fetchAllRecords, fetchAllUserRecords } from './pagination';
+export type { FetchRecordsConfig, AtProtoRecord } from './pagination';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACX,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,KAAK,EACL,UAAU,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,UAAU,EACV,MAAM,EACN,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,WAAW,EACX,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,uBAAuB,EACvB,4BAA4B,EAC5B,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACN,YAAY,EACZ,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACN,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEhG,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAElJ,OAAO,EACN,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gCAAgC,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEpF,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzD,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACpE,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+// Re-export types and functions from the AT Protocol service layer.
+// Key API difference from the app's src/lib/services/atproto:
+//   All functions that previously read PUBLIC_ATPROTO_DID from the environment
+//   now accept `did: string` as their first argument.
+export { fetchProfile, fetchSiteInfo, fetchLinks, fetchMusicStatus, fetchKibunStatus, fetchTangledRepos } from './fetch';
+export { fetchPublications, fetchDocuments, fetchRecentDocuments, fetchBlogPosts } from './documents';
+export { fetchLatestBlueskyPost, fetchPostFromUri } from './posts';
+export { buildPdsBlobUrl, extractCidFromImageObject, extractImageUrlsFromValue } from './media';
+export { createAgent, constellationAgent, defaultAgent, resolveIdentity, getPublicAgent, getPDSAgent, withFallback, resetAgents } from './agents';
+export { searchMusicBrainzRelease, buildCoverArtUrl, searchiTunesArtwork, searchDeezerArtwork, searchLastFmArtwork, findArtwork } from './musicbrainz';
+export { fetchEngagementFromConstellation, fetchAllEngagement } from './engagement';
+export { cache, ATProtoCache, CACHE_TTL } from './cache';
+export { fetchAllRecords, fetchAllUserRecords } from './pagination';

package/dist/media.d.ts

@@ -0,0 +1,4 @@
+export declare function buildPdsBlobUrl(pds: string, did: string, cid: string): string;
+export declare function extractCidFromImageObject(img: any): string | null;
+export declare function extractImageUrlsFromValue(value: any, did: string, limit?: number): string[];
+//# sourceMappingURL=media.d.ts.map

package/dist/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI,CAOjE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,EAAE,CA4FtF"}

package/dist/media.js

@@ -0,0 +1,109 @@
+export function buildPdsBlobUrl(pds, did, cid) {
+    return `${pds.replace(/\/$/, '')}/xrpc/com.atproto.sync.getBlob?did=${encodeURIComponent(did)}&cid=${encodeURIComponent(cid)}`;
+}
+export function extractCidFromImageObject(img) {
+    if (!img)
+        return null;
+    if (img.image && img.image.ref && img.image.ref.$link)
+        return img.image.ref.$link;
+    if (img.ref && img.ref.$link)
+        return img.ref.$link;
+    if (img.cid)
+        return img.cid;
+    if (typeof img === 'string')
+        return img;
+    return null;
+}
+export function extractImageUrlsFromValue(value, did, limit = 4) {
+    const urls = [];
+    try {
+        const embed = value?.embed ?? null;
+        if (embed) {
+            if (embed.$type === 'app.bsky.embed.images#view' && Array.isArray(embed.images)) {
+                for (const img of embed.images) {
+                    const imageUrl = img.fullsize || img.thumb;
+                    if (imageUrl)
+                        urls.push(imageUrl);
+                    else {
+                        const cid = extractCidFromImageObject(img);
+                        if (cid)
+                            urls.push(`https://cdn.bsky.app/img/feed_fullsize/plain/${did}/${cid}@jpeg`);
+                    }
+                    if (urls.length >= limit)
+                        return urls;
+                }
+            }
+            if (embed.$type === 'app.bsky.embed.video#view' || embed.$type === 'app.bsky.embed.video') {
+                const videoCid = embed?.jobStatus?.blob ??
+                    embed?.video?.ref?.$link ??
+                    embed?.video?.cid ??
+                    null;
+                if (videoCid) {
+                    urls.push(`https://video.bsky.app/watch/${did}/${videoCid}/playlist.m3u8`);
+                    if (urls.length >= limit)
+                        return urls;
+                }
+            }
+            if (embed.$type === 'app.bsky.embed.recordWithMedia#view') {
+                const media = embed.media;
+                if (media &&
+                    media.$type === 'app.bsky.embed.images#view' &&
+                    Array.isArray(media.images)) {
+                    for (const img of media.images) {
+                        const imageUrl = img.fullsize || img.thumb;
+                        if (imageUrl)
+                            urls.push(imageUrl);
+                        else {
+                            const cid = extractCidFromImageObject(img);
+                            if (cid)
+                                urls.push(`https://cdn.bsky.app/img/feed_fullsize/plain/${did}/${cid}@jpeg`);
+                        }
+                        if (urls.length >= limit)
+                            return urls;
+                    }
+                }
+                const quotedRecord = embed.record;
+                if (quotedRecord) {
+                    const quotedValue = quotedRecord.value ?? quotedRecord.record?.value ?? null;
+                    if (quotedValue) {
+                        const nested = extractImageUrlsFromValue(quotedValue, did, limit - urls.length);
+                        urls.push(...nested);
+                        if (urls.length >= limit)
+                            return urls;
+                    }
+                }
+            }
+            if (embed.$type === 'app.bsky.embed.record#view' && embed.record) {
+                const quotedValue = embed.record.value ?? embed.record.record?.value ?? null;
+                if (quotedValue) {
+                    const nested = extractImageUrlsFromValue(quotedValue, did, limit - urls.length);
+                    urls.push(...nested);
+                    if (urls.length >= limit)
+                        return urls;
+                }
+            }
+        }
+        if (Array.isArray(value.embeds)) {
+            for (const e of value.embeds) {
+                if (e.$type === 'app.bsky.embed.images#view' && Array.isArray(e.images)) {
+                    for (const img of e.images) {
+                        const imageUrl = img.fullsize || img.thumb;
+                        if (imageUrl)
+                            urls.push(imageUrl);
+                        else {
+                            const cid = extractCidFromImageObject(img);
+                            if (cid)
+                                urls.push(`https://cdn.bsky.app/img/feed_fullsize/plain/${did}/${cid}@jpeg`);
+                        }
+                        if (urls.length >= limit)
+                            return urls;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // conservative: return what we have
+    }
+    return urls.slice(0, limit);
+}

package/dist/musicbrainz.d.ts

@@ -0,0 +1,10 @@
+export declare function searchMusicBrainzRelease(trackName: string, artistName: string, releaseName?: string): Promise<string | null>;
+export declare function buildCoverArtUrl(releaseMbId: string, size?: 250 | 500 | 1200): string;
+export declare function searchiTunesArtwork(trackName: string, artistName: string, releaseName?: string): Promise<string | null>;
+export declare function searchDeezerArtwork(trackName: string, artistName: string, releaseName?: string): Promise<string | null>;
+export declare function searchLastFmArtwork(trackName: string, artistName: string, releaseName?: string): Promise<string | null>;
+/**
+ * Cascading artwork search: Cover Art Archive → MusicBrainz+CAA → iTunes → Last.fm
+ */
+export declare function findArtwork(trackName: string, artistName: string, releaseName?: string, releaseMbId?: string, fetchFn?: typeof fetch): Promise<string | null>;
+//# sourceMappingURL=musicbrainz.d.ts.map

package/dist/musicbrainz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"musicbrainz.d.ts","sourceRoot":"","sources":["../src/musicbrainz.ts"],"names":[],"mappings":"AAiBA,wBAAsB,wBAAwB,CAC7C,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiBxB;AAkCD,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,GAAG,GAAG,GAAG,GAAG,IAAU,GAAG,MAAM,CAE1F;AAED,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuBxB;AAED,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGxB;AAED,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA2BxB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAChC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA+BxB"}

package/dist/musicbrainz.js

@@ -0,0 +1,176 @@
+import { cache } from './cache.js';
+export async function searchMusicBrainzRelease(trackName, artistName, releaseName) {
+    const cacheKey = `mb:release:${trackName}:${artistName}:${releaseName || 'none'}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== null)
+        return cached;
+    try {
+        if (releaseName) {
+            const result = await searchByReleaseName(releaseName, artistName);
+            if (result) {
+                cache.set(cacheKey, result);
+                return result;
+            }
+        }
+        const result = await searchByTrackName(trackName, artistName);
+        if (result) {
+            cache.set(cacheKey, result);
+            return result;
+        }
+        cache.set(cacheKey, null);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function searchByReleaseName(releaseName, artistName) {
+    try {
+        const query = `release:"${releaseName}" AND artist:"${artistName}"`;
+        const url = `https://musicbrainz.org/ws/2/release/?query=${encodeURIComponent(query)}&fmt=json&limit=5`;
+        const response = await fetch(url, {
+            headers: { 'User-Agent': 'ewancroft.uk/1.0.0 (https://ewancroft.uk)', Accept: 'application/json' }
+        });
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        if (!data.releases?.length)
+            return null;
+        const best = data.releases[0];
+        if (best.score < 80)
+            return null;
+        return best.id;
+    }
+    catch {
+        return null;
+    }
+}
+async function searchByTrackName(trackName, artistName) {
+    try {
+        const query = `recording:"${trackName}" AND artist:"${artistName}"`;
+        const url = `https://musicbrainz.org/ws/2/release/?query=${encodeURIComponent(query)}&fmt=json&limit=5`;
+        const response = await fetch(url, {
+            headers: { 'User-Agent': 'ewancroft.uk/1.0.0 (https://ewancroft.uk)', Accept: 'application/json' }
+        });
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        if (!data.releases?.length)
+            return null;
+        const best = data.releases[0];
+        if (best.score < 75)
+            return null;
+        return best.id;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildCoverArtUrl(releaseMbId, size = 500) {
+    return `https://coverartarchive.org/release/${releaseMbId}/front-${size}`;
+}
+export async function searchiTunesArtwork(trackName, artistName, releaseName) {
+    const cacheKey = `itunes:artwork:${trackName}:${artistName}:${releaseName || 'none'}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== null)
+        return cached;
+    try {
+        const searchTerm = releaseName ? `${releaseName} ${artistName}` : `${trackName} ${artistName}`;
+        const url = `https://itunes.apple.com/search?term=${encodeURIComponent(searchTerm)}&entity=album&limit=5`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            cache.set(cacheKey, null);
+            return null;
+        }
+        const data = await response.json();
+        if (!data.results?.length) {
+            cache.set(cacheKey, null);
+            return null;
+        }
+        let artworkUrl = data.results[0].artworkUrl100;
+        if (artworkUrl) {
+            artworkUrl = artworkUrl.replace('100x100', '600x600');
+            cache.set(cacheKey, artworkUrl);
+            return artworkUrl;
+        }
+        cache.set(cacheKey, null);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function searchDeezerArtwork(trackName, artistName, releaseName) {
+    // Deezer has CORS restrictions in browsers — skip silently
+    return null;
+}
+export async function searchLastFmArtwork(trackName, artistName, releaseName) {
+    if (!releaseName)
+        return null;
+    const cacheKey = `lastfm:artwork:${trackName}:${artistName}:${releaseName}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== null)
+        return cached;
+    try {
+        const url = `https://ws.audioscrobbler.com/2.0/?method=album.getinfo&api_key=8de8b91ab0c3f8d08a35c33bf0e0e803&artist=${encodeURIComponent(artistName)}&album=${encodeURIComponent(releaseName)}&format=json`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            cache.set(cacheKey, null);
+            return null;
+        }
+        const data = await response.json();
+        if (!data.album?.image) {
+            cache.set(cacheKey, null);
+            return null;
+        }
+        const images = data.album.image;
+        const largeImage = images.find((img) => img.size === 'extralarge') ||
+            images.find((img) => img.size === 'large') ||
+            images.find((img) => img.size === 'medium');
+        if (largeImage?.['#text']) {
+            cache.set(cacheKey, largeImage['#text']);
+            return largeImage['#text'];
+        }
+        cache.set(cacheKey, null);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cascading artwork search: Cover Art Archive → MusicBrainz+CAA → iTunes → Last.fm
+ */
+export async function findArtwork(trackName, artistName, releaseName, releaseMbId, fetchFn) {
+    const _fetch = fetchFn || globalThis.fetch;
+    // 1. Try Cover Art Archive with known MBID
+    if (releaseMbId) {
+        const caaUrl = buildCoverArtUrl(releaseMbId, 500);
+        try {
+            const res = await _fetch(caaUrl, { method: 'HEAD' });
+            if (res.ok)
+                return caaUrl;
+        }
+        catch { /* continue */ }
+    }
+    // 2. Search MusicBrainz for MBID, then try CAA
+    const mbId = await searchMusicBrainzRelease(trackName, artistName, releaseName);
+    if (mbId) {
+        const caaUrl = buildCoverArtUrl(mbId, 500);
+        try {
+            const res = await _fetch(caaUrl, { method: 'HEAD' });
+            if (res.ok)
+                return caaUrl;
+        }
+        catch { /* continue */ }
+    }
+    // 3. Try iTunes
+    const iTunesUrl = await searchiTunesArtwork(trackName, artistName, releaseName);
+    if (iTunesUrl)
+        return iTunesUrl;
+    // 4. Try Last.fm
+    const lastFmUrl = await searchLastFmArtwork(trackName, artistName, releaseName);
+    if (lastFmUrl)
+        return lastFmUrl;
+    return null;
+}

package/dist/pagination/fetchAllRecords.d.ts

@@ -0,0 +1,14 @@
+export interface FetchRecordsConfig {
+    repo: string;
+    collection: string;
+    limit?: number;
+    fetchFn?: typeof fetch;
+}
+export interface AtProtoRecord<T = any> {
+    uri: string;
+    value: T;
+    cid?: string;
+}
+export declare function fetchAllRecords<T = any>(config: FetchRecordsConfig): Promise<AtProtoRecord<T>[]>;
+export declare function fetchAllUserRecords<T = any>(did: string, collection: string, fetchFn?: typeof fetch, limit?: number): Promise<AtProtoRecord<T>[]>;
+//# sourceMappingURL=fetchAllRecords.d.ts.map

package/dist/pagination/fetchAllRecords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchAllRecords.d.ts","sourceRoot":"","sources":["../../src/pagination/fetchAllRecords.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACvB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,GAAG;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,CAAC,CAAC;IACT,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,wBAAsB,eAAe,CAAC,CAAC,GAAG,GAAG,EAC5C,MAAM,EAAE,kBAAkB,GACxB,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CA8B7B;AAED,wBAAsB,mBAAmB,CAAC,CAAC,GAAG,GAAG,EAChD,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,OAAO,KAAK,EACtB,KAAK,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAE7B"}

package/dist/pagination/fetchAllRecords.js

@@ -0,0 +1,29 @@
+import { withFallback } from '../agents.js';
+export async function fetchAllRecords(config) {
+    const { repo, collection, limit = 100, fetchFn } = config;
+    const allRecords = [];
+    let cursor;
+    try {
+        do {
+            const records = await withFallback(repo, async (agent) => {
+                const response = await agent.com.atproto.repo.listRecords({
+                    repo,
+                    collection,
+                    limit,
+                    cursor
+                });
+                cursor = response.data.cursor;
+                return response.data.records;
+            }, true, fetchFn);
+            allRecords.push(...records);
+        } while (cursor);
+    }
+    catch (error) {
+        console.warn(`Failed to fetch records from ${collection}:`, error);
+        throw error;
+    }
+    return allRecords;
+}
+export async function fetchAllUserRecords(did, collection, fetchFn, limit) {
+    return fetchAllRecords({ repo: did, collection, limit, fetchFn });
+}