optimize following list by a ton

src/components/FollowingItem.svelte

···
+<script lang="ts" module>
+	// Cache for synchronous access during component recycling
+	const profileCache = new SvelteMap<string, { displayName?: string; handle: string }>();
+</script>
+
+<script lang="ts">
+	import ProfilePicture from './ProfilePicture.svelte';
+	import { getRelativeTime } from '$lib/date';
+	import { generateColorForDid } from '$lib/accounts';
+	import type { Did } from '@atcute/lexicons';
+	import type { AtprotoDid } from '@atcute/lexicons/syntax';
+	import type { calculateFollowedUserStats, Sort } from '$lib/following';
+	import type { AtpClient } from '$lib/at/client';
+	import { SvelteMap } from 'svelte/reactivity';
+	import { clients, getClient } from '$lib/state.svelte';
+
+	interface Props {
+		style: string;
+		did: Did;
+		stats: NonNullable<ReturnType<typeof calculateFollowedUserStats>>;
+		client: AtpClient;
+		sort: Sort;
+		currentTime: Date;
+	}
+
+	let { style, did, stats, client, sort, currentTime }: Props = $props();
+
+	// svelte-ignore state_referenced_locally
+	const cached = profileCache.get(did);
+	let displayName = $state<string | undefined>(cached?.displayName);
+	let handle = $state<string>(cached?.handle ?? 'handle.invalid');
+
+	const loadProfile = async (targetDid: Did) => {
+		if (profileCache.has(targetDid)) {
+			const c = profileCache.get(targetDid)!;
+			displayName = c.displayName;
+			handle = c.handle;
+		} else {
+			const existingClient = clients.get(targetDid as AtprotoDid);
+			if (existingClient?.user?.handle) {
+				handle = existingClient.user.handle;
+			} else {
+				handle = 'handle.invalid';
+				displayName = undefined;
+			}
+		}
+
+		try {
+			// Optimization: Check clients map first to avoid async overhead if possible
+			// but we need to ensure we have the profile data, not just client existence.
+			const userClient = await getClient(targetDid as AtprotoDid);
+
+			// Check if the component has been recycled for a different user while we were awaiting
+			if (did !== targetDid) return;
+
+			let newHandle = handle;
+			let newDisplayName = displayName;
+
+			if (userClient.user?.handle) {
+				newHandle = userClient.user.handle;
+				handle = newHandle;
+			} else {
+				newHandle = targetDid;
+				handle = newHandle;
+			}
+
+			const profileRes = await userClient.getProfile();
+
+			if (did !== targetDid) return;
+
+			if (profileRes.ok) {
+				newDisplayName = profileRes.value.displayName;
+				displayName = newDisplayName;
+			}
+
+			// Update cache
+			profileCache.set(targetDid, {
+				handle: newHandle,
+				displayName: newDisplayName
+			});
+		} catch (e) {
+			if (did !== targetDid) return;
+			console.error(`failed to load profile for ${targetDid}`, e);
+			handle = 'error';
+		}
+	};
+
+	// Re-run whenever `did` changes
+	$effect(() => {
+		loadProfile(did);
+	});
+
+	const lastPostAt = $derived(stats?.lastPostAt ?? new Date(0));
+	const relTime = $derived(getRelativeTime(lastPostAt, currentTime));
+	const color = $derived(generateColorForDid(did));
+</script>
+
+<div {style} class="box-border w-full pb-2">
+	<div
+		class="group flex items-center gap-2 rounded-sm bg-(--nucleus-accent)/7 p-3 transition-colors hover:bg-(--post-color)/20"
+		style={`--post-color: ${color};`}
+	>
+		<ProfilePicture {client} {did} size={10} />
+		<div class="min-w-0 flex-1 space-y-1">
+			<div
+				class="flex items-baseline gap-2 font-bold transition-colors group-hover:text-(--post-color)"
+				style={`--post-color: ${color};`}
+			>
+				<span class="truncate">{displayName || handle}</span>
+				<span class="truncate text-sm opacity-60">@{handle}</span>
+			</div>
+			<div class="flex gap-2 text-xs opacity-70">
+				<span
+					class={Date.now() - lastPostAt.getTime() < 1000 * 60 * 60 * 2
+						? 'text-(--nucleus-accent)'
+						: ''}
+				>
+					posted {relTime}
+					{relTime !== 'now' ? 'ago' : ''}
+				</span>
+				{#if stats?.recentPostCount && stats.recentPostCount > 0}
+					<span class="text-(--nucleus-accent2)">
+						{stats.recentPostCount} posts / 6h
+					</span>
+				{/if}
+				{#if sort === 'conversational' && stats?.conversationalScore && stats.conversationalScore > 0}
+					<span class="ml-auto font-bold text-(--nucleus-accent)">
+						★ {stats.conversationalScore.toFixed(1)}
+					</span>
+				{/if}
+			</div>
+		</div>
+	</div>
+</div>

src/components/FollowingView.svelte

···
 <script lang="ts">
-	import { follows, getClient, allPosts, allBacklinks, currentTime } from '$lib/state.svelte';
+	import { follows, allPosts, allBacklinks, currentTime, replyIndex } from '$lib/state.svelte';
 	import type { Did } from '@atcute/lexicons';
-	import ProfilePicture from './ProfilePicture.svelte';
-	import { type AtpClient, resolveDidDoc } from '$lib/at/client';
-	import { getRelativeTime } from '$lib/date';
-	import { generateColorForDid } from '$lib/accounts';
-	import { type AtprotoDid } from '@atcute/lexicons/syntax';
+	import { type AtpClient } from '$lib/at/client';
 	import VirtualList from '@tutorlatin/svelte-tiny-virtual-list';
 	import {
 		calculateFollowedUserStats,
···
 		sortFollowedUser,
 		type Sort
 	} from '$lib/following';
+	import FollowingItem from './FollowingItem.svelte';
 
 	interface Props {
 		selectedDid: Did;
···
 	let followingSort: Sort = $state('active' as Sort);
 	const followsMap = $derived(follows.get(selectedDid));
 
-	const interactionScores = $derived.by(() => {
-		if (followingSort !== 'conversational') return null;
-		return calculateInteractionScores(
-			selectedDid,
-			followsMap ?? new Map(),
-			allPosts,
-			allBacklinks,
-			currentTime.getTime()
-		);
-	});
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let sortedFollowing = $state<{ did: Did; data: any }[]>([]);
 
-	class FollowedUserStats {
-		did: Did;
-		profile: Promise<string | null | undefined>;
-		handle: Promise<string>;
+	let isLongCalculation = $state(false);
+	let calculationTimer: ReturnType<typeof setTimeout> | undefined;
 
-		constructor(did: Did) {
-			this.did = did;
-			this.profile = getClient(did as AtprotoDid)
-				.then((client) => client.getProfile())
-				.then((profile) => {
-					if (profile.ok) return profile.value.displayName;
-					return null;
-				});
-			this.handle = resolveDidDoc(did).then((doc) => {
-				if (doc.ok) return doc.value.handle;
-				return 'handle.invalid';
-			});
+	// Optimization: Use a static timestamp for calculation to avoid re-sorting every second.
+	// Only update this when the sort mode changes.
+	let staticNow = $state(Date.now());
+
+	const updateList = async () => {
+		// Reset timer and loading state at start
+		if (calculationTimer) clearTimeout(calculationTimer);
+		isLongCalculation = false;
+
+		if (!followsMap) {
+			sortedFollowing = [];
+			return;
 		}
 
-		data = $derived.by(() =>
-			calculateFollowedUserStats(
+		// schedule spinner to appear only if calculation takes > 200ms
+		calculationTimer = setTimeout(() => {
+			isLongCalculation = true;
+		}, 200);
+		// yield to main thread to allow UI to show spinner/update
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const interactionScores =
+			followingSort === 'conversational'
+				? calculateInteractionScores(
+						selectedDid,
+						followsMap,
+						allPosts,
+						allBacklinks,
+						replyIndex,
+						staticNow
+					)
+				: null;
+
+		const userStatsList = Array.from(followsMap.values()).map((f) => ({
+			did: f.subject,
+			data: calculateFollowedUserStats(
 				followingSort,
-				this.did,
+				f.subject,
 				allPosts,
 				interactionScores,
-				currentTime.getTime()
+				staticNow
 			)
-		);
-	}
+		}));
+
+		const following = userStatsList.filter((u) => u.data !== null);
+		const sorted = [...following].sort((a, b) => sortFollowedUser(followingSort, a.data!, b.data!));
 
-	const userStatsList = $derived(
-		followsMap ? Array.from(followsMap.values()).map((f) => new FollowedUserStats(f.subject)) : []
-	);
-	const following = $derived(userStatsList.filter((u) => u.data !== null));
-	const sortedFollowing = $derived(
-		[...following].sort((a, b) => sortFollowedUser(followingSort, a.data!, b.data!))
-	);
+		sortedFollowing = sorted;
+
+		// Clear timer and remove loading state immediately after done
+		if (calculationTimer) clearTimeout(calculationTimer);
+		isLongCalculation = false;
+	};
+
+	$effect(() => {
+		// Dependencies that trigger a re-sort
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		const _s = followingSort;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		const _f = followsMap;
+		// Update time when sort changes
+		staticNow = Date.now();
+
+		updateList();
+	});
 
 	let listHeight = $state(0);
 	let listContainer: HTMLDivElement | undefined = $state();
···
 	</div>
 
 	<div class="min-h-0 flex-1" bind:this={listContainer}>
-		{#if sortedFollowing.length === 0}
+		{#if sortedFollowing.length === 0 || isLongCalculation}
 			<div class="flex justify-center py-8">
 				<div
 					class="h-8 w-8 animate-spin rounded-full border-2 border-t-transparent"
···
 			<VirtualList height={listHeight} itemCount={sortedFollowing.length} itemSize={76}>
 				{#snippet item({ index, style }: { index: number; style: string })}
 					{@const user = sortedFollowing[index]}
-					{@const stats = user.data!}
-					{@const lastPostAt = stats.lastPostAt}
-					{@const relTime = getRelativeTime(lastPostAt, currentTime)}
-					{@const color = generateColorForDid(user.did)}
-					<div {style} class="box-border w-full pb-2">
-						<div
-							class="group flex items-center gap-2 rounded-sm bg-(--nucleus-accent)/7 p-3 transition-colors hover:bg-(--post-color)/20"
-							style={`--post-color: ${color};`}
-						>
-							<ProfilePicture client={selectedClient} did={user.did} size={10} />
-							<div class="min-w-0 flex-1 space-y-1">
-								<div
-									class="flex items-baseline gap-2 font-bold transition-colors group-hover:text-(--post-color)"
-									style={`--post-color: ${color};`}
-								>
-									{#await Promise.all([user.profile, user.handle]) then [displayName, handle]}
-										<span class="truncate">{displayName || handle}</span>
-										<span class="truncate text-sm opacity-60">@{handle}</span>
-									{/await}
-								</div>
-								<div class="flex gap-2 text-xs opacity-70">
-									<span
-										class={Date.now() - lastPostAt.getTime() < 1000 * 60 * 60 * 2
-											? 'text-(--nucleus-accent)'
-											: ''}
-									>
-										posted {relTime}
-										{relTime !== 'now' ? 'ago' : ''}
-									</span>
-									{#if stats.recentPostCount > 0}
-										<span class="text-(--nucleus-accent2)">
-											{stats.recentPostCount} posts / 6h
-										</span>
-									{/if}
-									{#if followingSort === 'conversational' && stats.conversationalScore > 0}
-										<span class="ml-auto font-bold text-(--nucleus-accent)">
-											★ {stats.conversationalScore.toFixed(1)}
-										</span>
-									{/if}
-								</div>
-							</div>
-						</div>
-					</div>
+					<FollowingItem
+						{style}
+						did={user.did}
+						stats={user.data!}
+						client={selectedClient}
+						sort={followingSort}
+						{currentTime}
+					/>
 				{/snippet}
 			</VirtualList>
 		{/if}

src/components/ProfilePicture.svelte

···
+<script lang="ts" module>
+	// Module-level cache for synchronous access during component recycling
+	const avatarCache = new SvelteMap<string, string | null>();
+</script>
+
 <script lang="ts">
 	import { generateColorForDid } from '$lib/accounts';
 	import type { AtpClient } from '$lib/at/client';
···
 	import PfpPlaceholder from './PfpPlaceholder.svelte';
 	import { img } from '$lib/cdn';
 	import type { Did } from '@atcute/lexicons';
+	import { SvelteMap } from 'svelte/reactivity';
 
 	interface Props {
 		client: AtpClient;
···
 
 	let { client, did, size }: Props = $props();
 
+	// svelte-ignore state_referenced_locally
+	let avatarUrl = $state<string | null>(avatarCache.get(did) ?? null);
+
+	const loadProfile = async (targetDid: Did) => {
+		// If we already have it in cache, we might want to re-validate eventually,
+		// but for UI stability, using the cache is priority.
+		// However, we still need to handle the case where we don't have it.
+		if (avatarCache.has(targetDid)) avatarUrl = avatarCache.get(targetDid) ?? null;
+		else avatarUrl = null;
+
+		try {
+			const profile = await client.getProfile(targetDid);
+
+			if (did !== targetDid) return;
+
+			if (profile.ok) {
+				const record = profile.value;
+				if (isBlob(record.avatar)) {
+					const url = img('avatar_thumbnail', targetDid, record.avatar.ref.$link);
+					avatarUrl = url;
+					avatarCache.set(targetDid, url);
+				} else {
+					avatarUrl = null;
+					avatarCache.set(targetDid, null);
+				}
+			} else {
+				// Don't cache errors aggressively, or maybe cache 'null' to stop retrying?
+				// For now, just set local state.
+				avatarUrl = null;
+			}
+		} catch (e) {
+			if (did !== targetDid) return;
+			console.error(`${targetDid}: failed to load pfp`, e);
+			avatarUrl = null;
+		}
+	};
+
+	$effect(() => {
+		loadProfile(did);
+	});
+
 	let color = $derived(generateColorForDid(did));
 </script>
 
-{#snippet missingPfp()}
+{#if avatarUrl}
+	<img
+		class="rounded-sm bg-(--nucleus-accent)/10"
+		loading="lazy"
+		style="width: calc(var(--spacing) * {size}); height: calc(var(--spacing) * {size});"
+		alt="avatar for {did}"
+		src={avatarUrl}
+	/>
+{:else}
 	<PfpPlaceholder {color} {size} />
-{/snippet}
-
-{#await client.getProfile(did)}
-	{@render missingPfp()}
-{:then profile}
-	{#if profile.ok}
-		{@const record = profile.value}
-		{#if isBlob(record.avatar)}
-			<img
-				class="rounded-sm"
-				loading="lazy"
-				style="width: calc(var(--spacing) * {size}); height: calc(var(--spacing) * {size});"
-				alt="avatar for {did}"
-				src={img('avatar_thumbnail', did, record.avatar.ref.$link)}
-			/>
-		{:else}
-			{@render missingPfp()}
-		{/if}
-	{:else}
-		{@render missingPfp()}
-	{/if}
-{/await}
+{/if}

src/lib/following.ts

···
 import { type ActorIdentifier, type Did, type ResourceUri } from '@atcute/lexicons';
 import type { PostWithUri } from './at/fetch';
 import type { Backlink, BacklinksSource } from './at/constellation';
-import { repostSource } from '$lib';
+import { extractDidFromUri, repostSource } from '$lib';
 import type { AppBskyGraphFollow } from '@atcute/bluesky';
 
 export type Sort = 'recent' | 'active' | 'conversational';
···
 	statsB: NonNullable<ReturnType<typeof calculateFollowedUserStats>>
 ) => {
 	if (sort === 'conversational') {
-		if (Math.abs(statsB.conversationalScore - statsA.conversationalScore) > 0.1)
+		if (Math.abs(statsB.conversationalScore! - statsA.conversationalScore!) > 0.1)
 			// sort based on conversational score
-			return statsB.conversationalScore - statsA.conversationalScore;
+			return statsB.conversationalScore! - statsA.conversationalScore!;
 	} else {
 		if (sort === 'active')
-			if (Math.abs(statsB.activeScore - statsA.activeScore) > 0.0001)
+			if (Math.abs(statsB.activeScore! - statsA.activeScore!) > 0.0001)
 				// sort based on activity
-				return statsB.activeScore - statsA.activeScore;
+				return statsB.activeScore! - statsA.activeScore!;
 	}
 	// use recent if scores are similar / we are using recent mode
-	return statsB.lastPostAt.getTime() - statsA.lastPostAt.getTime();
+	return statsB.lastPostAt!.getTime() - statsA.lastPostAt!.getTime();
 };
 
+// Caching to prevent re-calculating stats for every render frame if data is stable
+const userStatsCache = new Map<
+	Did,
+	{ timestamp: number; stats: ReturnType<typeof _calculateStats> }
+>();
+const STATS_CACHE_TTL = 60 * 1000; // 1 minute
+
 export const calculateFollowedUserStats = (
 	sort: Sort,
 	did: Did,
···
 	interactionScores: Map<ActorIdentifier, number> | null,
 	now: number
 ) => {
+	// For 'active' sort which is computationally heavy, use cache
+	if (sort === 'active') {
+		const cached = userStatsCache.get(did);
+		if (cached && now - cached.timestamp < STATS_CACHE_TTL) {
+			const postsMap = posts.get(did);
+			// Simple invalidation check: if post count matches, assume cache is valid enough
+			// This avoids iterating the map just to check contents.
+			// Ideally we'd have a version/hash on the map.
+			if (postsMap && postsMap.size > 0) return { ...cached.stats, did };
+		}
+	}
+
+	const stats = _calculateStats(sort, did, posts, interactionScores, now);
+
+	if (stats && sort === 'active') userStatsCache.set(did, { timestamp: now, stats });
+
+	return stats;
+};
+
+const _calculateStats = (
+	sort: Sort,
+	did: Did,
+	posts: Map<Did, Map<ResourceUri, PostWithUri>>,
+	interactionScores: Map<ActorIdentifier, number> | null,
+	now: number
+) => {
 	const postsMap = posts.get(did);
 	if (!postsMap || postsMap.size === 0) return null;
 
···
 const replyWeight = 6;
 const repostWeight = 2;
 
-// interactions decay over time to prioritize recent conversations.
-// half-life of 3 days ensures that inactivity (>1 days) results in a noticeable score drop.
 const oneDay = 24 * 60 * 60 * 1000;
 const halfLifeMs = 3 * oneDay;
 const decayLambda = 0.693 / halfLifeMs;
···
 // normalization constants
 const rateBaseline = 1;
 const ratePower = 0.5;
-// consider the last 7 days for rate calculation
 const windowSize = 7 * oneDay;
 
+// Cache for post rates to avoid iterating every user's timeline every time
+const rateCache = new Map<Did, { rate: number; calculatedAt: number; postCount: number }>();
+
+const getPostRate = (did: Did, posts: Map<ResourceUri, PostWithUri>, now: number): number => {
+	const cached = rateCache.get(did);
+	// If cached and number of posts hasn't changed, return cached rate
+	if (cached && cached.postCount === posts.size && now - cached.calculatedAt < 5 * 60 * 1000)
+		return cached.rate;
+
+	let volume = 0;
+	let minTime = now;
+	let maxTime = 0;
+	let hasRecentPosts = false;
+
+	for (const [, post] of posts) {
+		const t = new Date(post.record.createdAt).getTime();
+		if (now - t < windowSize) {
+			volume += 1;
+			if (t < minTime) minTime = t;
+			if (t > maxTime) maxTime = t;
+			hasRecentPosts = true;
+		}
+	}
+
+	let rate = 0;
+	if (hasRecentPosts) {
+		const days = Math.max((maxTime - minTime) / oneDay, 1);
+		rate = volume / days;
+	}
+
+	rateCache.set(did, { rate, calculatedAt: now, postCount: posts.size });
+	return rate;
+};
+
 export const calculateInteractionScores = (
 	user: Did,
 	followsMap: Map<ResourceUri, AppBskyGraphFollow.Main>,
 	allPosts: Map<Did, Map<ResourceUri, PostWithUri>>,
 	backlinks_: Map<ResourceUri, Map<BacklinksSource, Set<Backlink>>>,
+	replyIndex: Map<Did, Set<ResourceUri>>, // NEW: Inverted Index
 	now: number
 ) => {
 	const scores = new Map<Did, number>();
···
 		return Math.exp(-decayLambda * age);
 	};
 
-	const postRates = new Map<Did, number>();
-
-	const processPosts = (did: Did, posts: Map<ResourceUri, PostWithUri>) => {
-		let volume = 0;
-		let minTime = now;
-		let maxTime = 0;
-		let hasRecentPosts = false;
+	// Helper to add score
+	const addScore = (did: Did, weight: number, time: number) => {
+		const current = scores.get(did) ?? 0;
+		scores.set(did, current + weight * decay(time));
+	};
 
+	// 1. Process MY posts (Me -> Others)
+	// This is relatively cheap as "my posts" are few compared to "everyone's posts"
+	const myPosts = allPosts.get(user);
+	if (myPosts) {
 		const seenRoots = new Set<ResourceUri>();
-
-		for (const [, post] of posts) {
+		for (const post of myPosts.values()) {
 			const t = new Date(post.record.createdAt).getTime();
-			const dec = decay(t);
 
-			// Calculate rate based on raw volume over time frame
-			// We only care about posts within the relevant window to determine "current" activity rate
-			if (now - t < windowSize) {
-				volume += 1;
-				if (t < minTime) minTime = t;
-				if (t > maxTime) maxTime = t;
-				hasRecentPosts = true;
-			}
-
-			const processPostUri = (uri: ResourceUri, weight: number) => {
-				// only try to extract the DID
-				const match = uri.match(/^at:\/\/([^/]+)/);
-				if (!match) return;
-				const targetDid = match[1] as Did;
-				let subjectDid = targetDid;
-				// if we are processing posts of the user
-				if (did === user) {
-					// then only process posts where the user is replying to others
-					if (targetDid === user) return;
-				} else {
-					// otherwise only process posts that are replies to the user
-					if (targetDid !== user) return;
-					subjectDid = did;
-				}
-				// console.log(`${subjectDid} -> ${targetDid}`);
-				const s = scores.get(subjectDid) ?? 0;
-				scores.set(subjectDid, s + weight * dec);
-			};
+			// If I replied to someone
 			if (post.record.reply) {
 				const parentUri = post.record.reply.parent.uri;
 				const rootUri = post.record.reply.root.uri;
-				processPostUri(parentUri, replyWeight);
-				// prevent duplicates
+
+				const targetDid = extractDidFromUri(parentUri);
+				if (targetDid && targetDid !== user) addScore(targetDid, replyWeight, t);
+
 				if (parentUri !== rootUri && !seenRoots.has(rootUri)) {
-					processPostUri(rootUri, replyWeight);
+					const rootDid = extractDidFromUri(rootUri);
+					if (rootDid && rootDid !== user) addScore(rootDid, replyWeight, t);
 					seenRoots.add(rootUri);
 				}
 			}
-			if (post.record.embed?.$type === 'app.bsky.embed.record')
-				processPostUri(post.record.embed.record.uri, quoteWeight);
-			if (post.record.embed?.$type === 'app.bsky.embed.recordWithMedia')
-				processPostUri(post.record.embed.record.record.uri, quoteWeight);
-		}
 
-		let rate = 0;
-		if (hasRecentPosts) {
-			// Rate = Posts / Days
-			// Use at least 1 day to avoid skewing bursts of <24h too high
-			const days = Math.max((maxTime - minTime) / oneDay, 1);
-			rate = volume / days;
+			// If I quoted someone
+			if (post.record.embed?.$type === 'app.bsky.embed.record') {
+				const targetDid = extractDidFromUri(post.record.embed.record.uri);
+				if (targetDid && targetDid !== user) addScore(targetDid, quoteWeight, t);
+			}
 		}
-		postRates.set(did, rate);
-	};
+	}
+
+	// 2. Process OTHERS -> ME (using Index)
+	// Optimized: Use replyIndex instead of iterating all follows
+	const repliesToMe = replyIndex.get(user);
+	if (repliesToMe) {
+		for (const uri of repliesToMe) {
+			const authorDid = extractDidFromUri(uri);
+			if (!authorDid || authorDid === user) continue; // Self-reply
+
+			const postsMap = allPosts.get(authorDid);
+			const post = postsMap?.get(uri);
+			if (!post) continue; // Post data not loaded?
 
-	// process self
-	const myPosts = allPosts.get(user);
-	if (myPosts) processPosts(user, myPosts);
-	// process following
-	for (const follow of followsMap.values()) {
-		const posts = allPosts.get(follow.subject);
-		if (!posts) continue;
-		processPosts(follow.subject, posts);
+			const t = new Date(post.record.createdAt).getTime();
+			addScore(authorDid, replyWeight, t);
+		}
 	}
 
-	const followsSet = new Set(followsMap.values().map((follow) => follow.subject));
-	// interactions with others
 	for (const [uri, backlinks] of backlinks_) {
-		const match = uri.match(/^at:\/\/([^/]+)/);
-		if (!match) continue;
-		const targetDid = match[1] as Did;
-		// only process backlinks that target the user
-		const isSelf = targetDid === user;
-		// and are from users the user follows
-		const isFollowing = followsSet.has(targetDid);
-		if (!isSelf && !isFollowing) continue;
-		// check if the post exists
-		const post = allPosts.get(targetDid)?.get(uri);
-		if (!post) continue;
-		const reposts = backlinks.get(repostSource) ?? new Set();
-		const adds = new Map<Did, { score: number; repostCount: number }>();
-		for (const repost of reposts) {
-			// we dont count "self interactions"
-			if (isSelf && repost.did === user) continue;
-			// we dont count interactions that arent the user's
-			if (isFollowing && repost.did !== user) continue;
-			// use targetDid for following (because it will be the following did)
-			// use repost.did for self interactions (because it will be the following did)
-			const did = isFollowing ? targetDid : repost.did;
-			const add = adds.get(did) ?? { score: 0, repostCount: 0 };
-			// diminish the weight as the number of reposts increases
-			const diminishFactor = 9;
-			const weight = repostWeight * (diminishFactor / (add.repostCount + diminishFactor));
-			adds.set(did, {
-				score: add.score + weight,
-				repostCount: add.repostCount + 1
-			});
-		}
-		for (const [did, add] of adds.entries()) {
-			if (add.score === 0) continue;
-			const time = new Date(post.record.createdAt).getTime();
-			scores.set(did, (scores.get(did) ?? 0) + add.score * decay(time));
+		const targetDid = extractDidFromUri(uri);
+		if (!targetDid || targetDid !== user) continue; // Only care about interactions on MY posts
+
+		const reposts = backlinks.get(repostSource);
+		if (reposts) {
+			const adds = new Map<Did, { score: number; repostCount: number }>();
+			for (const repost of reposts) {
+				if (repost.did === user) continue;
+				const add = adds.get(repost.did) ?? { score: 0, repostCount: 0 };
+				const diminishFactor = 9;
+				const weight = repostWeight * (diminishFactor / (add.repostCount + diminishFactor));
+				adds.set(repost.did, {
+					score: add.score + weight,
+					repostCount: add.repostCount + 1
+				});
+			}
+
+			// Get the timestamp of the post being reposted to calculate decay
+			// (Interaction timestamp is unknown for backlinks usually, so we use post timestamp as proxy or 'now'?
+			// Original code used `post.record.createdAt`.
+			const myPost = myPosts?.get(uri);
+			if (myPost) {
+				const t = new Date(myPost.record.createdAt).getTime();
+				for (const [did, add] of adds.entries()) addScore(did, add.score, t);
+			}
 		}
 	}
 
 	// Apply normalization
 	for (const [did, score] of scores) {
-		const rate = postRates.get(did) ?? 0;
-		// NormalizedScore = DecayScore / (PostRate + Baseline)^alpha
-		// This penalizes spammers (high rate) and inactivity (score decay vs constant rate)
+		const posts = allPosts.get(did);
+		const rate = posts ? getPostRate(did, posts, now) : 0;
 		scores.set(did, score / Math.pow(rate + rateBaseline, ratePower));
 	}
 

src/lib/index.ts

···
 import type {
 	CanonicalResourceUri,
+	Did,
 	ParsedCanonicalResourceUri,
 	ParsedResourceUri,
 	ResourceUri
···
 };
 export const toCanonicalUri = (parsed: ParsedCanonicalResourceUri): CanonicalResourceUri => {
 	return `at://${parsed.repo}/${parsed.collection}/${parsed.rkey}${parsed.fragment ? `#${parsed.fragment}` : ''}`;
+};
+
+export const extractDidFromUri = (uri: string): Did | null => {
+	if (!uri.startsWith('at://')) return null;
+	const idx = uri.indexOf('/', 5);
+	if (idx === -1) return uri.slice(5) as Did;
+	return uri.slice(5, idx) as Did;
 };
 
 export const likeSource: BacklinksSource = 'app.bsky.feed.like:subject.uri';

src/lib/state.svelte.ts

···
 import type { Backlink, BacklinksSource } from './at/constellation';
 import { now as tidNow } from '@atcute/tid';
 import type { Records } from '@atcute/lexicons/ambient';
-import { likeSource, replySource, repostSource, timestampFromCursor } from '$lib';
+import {
+	extractDidFromUri,
+	likeSource,
+	replySource,
+	repostSource,
+	timestampFromCursor
+} from '$lib';
 
 export const notificationStream = writable<NotificationsStream | null>(null);
 export const jetstream = writable<JetstreamSubscription | null>(null);
···
 };
 
 export const allPosts = new SvelteMap<Did, SvelteMap<ResourceUri, PostWithUri>>();
+// did -> post uris that are replies to that did
+export const replyIndex = new SvelteMap<Did, SvelteSet<ResourceUri>>();
 
 export const addPostsRaw = (
 	did: AtprotoDid,
···
 			collection: parsedUri.collection,
 			rkey: parsedUri.rkey
 		};
-		if (post.record.reply) addBacklinks(post.record.reply.parent.uri, replySource, [link]);
+		if (post.record.reply) {
+			addBacklinks(post.record.reply.parent.uri, replySource, [link]);
+
+			// update reply index
+			const parentDid = extractDidFromUri(post.record.reply.parent.uri);
+			if (parentDid) {
+				let set = replyIndex.get(parentDid);
+				if (!set) {
+					set = new SvelteSet();
+					replyIndex.set(parentDid, set);
+				}
+				set.add(uri);
+			}
+		}
 	}
 };