From e25c476aa21951bf056ff6647a368cf3806d7478 Mon Sep 17 00:00:00 2001
From: dawn <90008@gaze.systems>
Date: Fri, 23 Jan 2026 23:46:24 +0300
Subject: [PATCH] optimize thread building a bit more

---
 src/components/BskyPost.svelte              |  22 +-
 src/components/FollowingTimelineView.svelte |  28 +--
 src/components/GenericTimelineView.svelte   |  12 +-
 src/components/PostComposer.svelte          |   2 +
 src/components/ProfilePicture.svelte        |   2 +-
 src/components/ReplyTimelineView.svelte     |  22 +-
 src/lib/state.svelte.ts                     |  28 +--
 src/lib/thread.ts                           | 247 +++++++++++++++++++-
 8 files changed, 299 insertions(+), 64 deletions(-)

diff --git a/src/components/BskyPost.svelte b/src/components/BskyPost.svelte
index 07c6618..50f3648 100644
--- a/src/components/BskyPost.svelte
+++ b/src/components/BskyPost.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { resolveDidDoc, type AtpClient } from '$lib/at/client.svelte';
-	import { AppBskyActorProfile, AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/bluesky';
+	import { AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/bluesky';
 	import {
 		parseCanonicalResourceUri,
 		type Did,
@@ -51,7 +51,7 @@
 		onQuote?: (quote: PostWithUri) => void;
 		onReply?: (reply: PostWithUri) => void;
 		cornerFragment?: Snippet;
-		isBlocked?: boolean;
+		blockRelationship?: { userBlocked: boolean; blockedByTarget: boolean };
 		isMuted?: boolean;
 	}
 
@@ -66,7 +66,7 @@
 		onReply,
 		isOnPostComposer = false /* replyBacklinks */,
 		cornerFragment,
-		isBlocked = false,
+		blockRelationship = undefined,
 		isMuted = false
 	}: Props = $props();
 
@@ -79,26 +79,26 @@
 	let expandDisallowed = $state(false);
 	const blockRel = $derived(
 		user && !isOnPostComposer
-			? getBlockRelationship(user.did, did)
+			? (blockRelationship ?? getBlockRelationship(user.did, did))
 			: { userBlocked: false, blockedByTarget: false }
 	);
 	const showAsBlocked = $derived(
-		(isBlocked || blockRel.userBlocked || blockRel.blockedByTarget) && !expandDisallowed
+		(blockRel.userBlocked || blockRel.blockedByTarget) && !expandDisallowed
 	);
 	const showAsMuted = $derived(isMuted && !expandDisallowed);
 
 	const handle = $derived(handles.get(did) ?? 'handle.invalid');
-	onMount(() => {
+	$effect(() => {
 		resolveDidDoc(did).then((res) => {
 			if (res.ok) handles.set(did, res.value.handle);
-			return res;
 		});
 	});
 	const profile = $derived(profiles.get(did));
-	onMount(async () => {
-		const p = await client.getProfile(did);
-		if (!p.ok) return;
-		profiles.set(did, p.value);
+	$effect(() => {
+		client.getProfile(did).then((res) => {
+			if (!res.ok) return;
+			profiles.set(did, res.value);
+		});
 	});
 
 	// svelte-ignore state_referenced_locally
diff --git a/src/components/FollowingTimelineView.svelte b/src/components/FollowingTimelineView.svelte
index 715378b..d1ed8fd 100644
--- a/src/components/FollowingTimelineView.svelte
+++ b/src/components/FollowingTimelineView.svelte
@@ -13,7 +13,7 @@
 		followingCursors,
 		initialDone
 	} from '$lib/state.svelte';
-	import { buildThreads, filterThreads } from '$lib/thread';
+	import { buildThreadsFiltered } from '$lib/thread';
 	import type { Did } from '@atcute/lexicons/syntax';
 	import GenericTimelineView from './GenericTimelineView.svelte';
 
@@ -32,11 +32,12 @@
 	}: Props = $props();
 
 	let viewOwnPosts = $state(true);
+	let displayCount = $state(10);
 
 	const userDid = $derived(targetDid ?? client?.user?.did);
 
 	const currentPrefs = $derived(userDid ? accountPreferences.get(userDid) : null);
-	const mutes = $derived(currentPrefs?.mutes ?? []);
+	const mutes = $derived(new Set(currentPrefs?.mutes ?? []));
 
 	const followedDids = $derived.by(() => {
 		if (!userDid) return new Set<Did>();
@@ -46,17 +47,17 @@
 	});
 
 	const threads = $derived(
-		filterThreads(
-			userDid
-				? buildThreads(userDid, followingFeed.get(userDid) ?? new SvelteSet(), allPosts, mutes)
-				: [],
-			$accounts,
-			{
-				viewOwnPosts,
-				filterReplies: true,
-				filterRootsToDids: followedDids
-			}
-		)
+		userDid
+			? buildThreadsFiltered(
+					userDid,
+					followingFeed.get(userDid) ?? new SvelteSet(),
+					allPosts,
+					mutes,
+					$accounts,
+					{ viewOwnPosts, filterReplies: true, filterRootsToDids: followedDids },
+					displayCount
+				)
+			: []
 	);
 
 	const isComplete = $derived.by(() => {
@@ -121,6 +122,7 @@
 	{threads}
 	timelineId={`following:${userDid}`}
 	bind:postComposerState
+	bind:displayCount
 	class={className}
 	isLoggedIn={!!(userDid || $accounts.length > 0)}
 	canLoad={!!(client && userDid && initialDone.has(userDid))}
diff --git a/src/components/GenericTimelineView.svelte b/src/components/GenericTimelineView.svelte
index fe55ead..d993ef3 100644
--- a/src/components/GenericTimelineView.svelte
+++ b/src/components/GenericTimelineView.svelte
@@ -23,10 +23,11 @@
 		timelineId?: string;
 		postComposerState: PostComposerState;
 		class?: string;
-		isLoggedIn?: boolean; // Controls rendering of the list vs NotLoggedIn
-		canLoad?: boolean; // Controls whether we can actually load more data
+		isLoggedIn?: boolean;
+		canLoad?: boolean;
 		onLoadMore: () => Promise<void>;
 		isComplete?: boolean;
+		displayCount?: number;
 	}
 
 	let {
@@ -38,7 +39,8 @@
 		isLoggedIn = false,
 		canLoad = undefined,
 		onLoadMore,
-		isComplete = false
+		isComplete = false,
+		displayCount = $bindable(15)
 	}: Props = $props();
 
 	const shouldLoad = $derived(canLoad ?? isLoggedIn);
@@ -56,7 +58,6 @@
 		return threads.filter((t) => t.newestTime <= boundaryTime!);
 	});
 
-	let displayCount = $state(15);
 	$effect(() => {
 		timelineId;
 		displayCount = 15;
@@ -157,7 +158,7 @@
 	};
 
 	$effect(() => {
-		const isEmpty = threads.length < 15;
+		const isEmpty = threads.length < 10;
 		if (isEmpty && !loading && shouldLoad && !isComplete) loadMore();
 	});
 
@@ -244,6 +245,7 @@
 													postComposerState.replying = post;
 												}}
 												{...post}
+												blockRelationship={post.blockRelationship}
 											/>
 										</div>
 									{:else if mini}
diff --git a/src/components/PostComposer.svelte b/src/components/PostComposer.svelte
index 6055e22..61f566a 100644
--- a/src/components/PostComposer.svelte
+++ b/src/components/PostComposer.svelte
@@ -625,6 +625,7 @@
 						<!-- svelte-ignore a11y_no_static_element_interactions -->
 						<div
 							class="composer relative flex cursor-text items-center gap-0 py-0! transition-all hover:brightness-110"
+							style="--acc-color: {color};"
 							onmousedown={(e) => {
 								if (e.defaultPrevented) return;
 								_state.focus = 'focused';
@@ -639,6 +640,7 @@
 								type="text"
 								placeholder="what's on your mind?"
 								class="min-w-0 flex-1 border-none bg-transparent outline-none placeholder:text-(--nucleus-fg)/45 focus:ring-0"
+								style="--acc-color: {color};"
 							/>
 							{#if _state.quoting}
 								{@render attachmentIndicator(_state.quoting, 'quoting')}
diff --git a/src/components/ProfilePicture.svelte b/src/components/ProfilePicture.svelte
index 1423f45..2ad4424 100644
--- a/src/components/ProfilePicture.svelte
+++ b/src/components/ProfilePicture.svelte
@@ -29,7 +29,7 @@
 	};
 
 	$effect(() => {
-		client;
+		if (!client.user) return;
 		loadProfile(did);
 	});
 
diff --git a/src/components/ReplyTimelineView.svelte b/src/components/ReplyTimelineView.svelte
index 3937b11..e2681d1 100644
--- a/src/components/ReplyTimelineView.svelte
+++ b/src/components/ReplyTimelineView.svelte
@@ -10,7 +10,7 @@
 		fetchInteractionsToTimelineEnd,
 		accountPreferences
 	} from '$lib/state.svelte';
-	import { buildThreads, filterThreads } from '$lib/thread';
+	import { buildThreadsFiltered } from '$lib/thread';
 	import type { Did } from '@atcute/lexicons/syntax';
 	import GenericTimelineView from './GenericTimelineView.svelte';
 
@@ -31,19 +31,26 @@
 	}: Props = $props();
 
 	let viewOwnPosts = $state(true);
+	let displayCount = $state(10);
 
 	const userDid = $derived(client?.user?.did);
 	const did = $derived(targetDid ?? userDid);
 
 	const currentPrefs = $derived(userDid ? accountPreferences.get(userDid) : null);
-	const mutes = $derived(currentPrefs?.mutes ?? []);
+	const mutes = $derived(new Set(currentPrefs?.mutes ?? []));
 
 	const threads = $derived(
-		filterThreads(
-			did && timelines.has(did) ? buildThreads(did, timelines.get(did)!, allPosts, mutes) : [],
-			$accounts,
-			{ viewOwnPosts }
-		)
+		did && timelines.has(did)
+			? buildThreadsFiltered(
+					did,
+					timelines.get(did)!,
+					allPosts,
+					mutes,
+					$accounts,
+					{ viewOwnPosts },
+					displayCount
+				)
+			: []
 	);
 
 	let fetchingInteractions = $state(false);
@@ -87,6 +94,7 @@
 	{threads}
 	timelineId={`replies:${did}`}
 	bind:postComposerState
+	bind:displayCount
 	class={className}
 	isLoggedIn={!!(did || $accounts.length > 0)}
 	canLoad={!!(client && userDid && did)}
diff --git a/src/lib/state.svelte.ts b/src/lib/state.svelte.ts
index 0a68aca..776e663 100644
--- a/src/lib/state.svelte.ts
+++ b/src/lib/state.svelte.ts
@@ -519,8 +519,8 @@ export const fetchFollowingTimeline = async (client: AtpClient, targetDid?: Did,
 		})
 	);
 
-	// 4. Update state
-	const newPosts: ResourceUri[] = [];
+	// 4. Update state - use records directly from listRecords instead of re-fetching
+	const validPosts: PostWithUri[] = [];
 	for (const result of results) {
 		if (!result) continue;
 		const { did, res } = result;
@@ -529,21 +529,17 @@ export const fetchFollowingTimeline = async (client: AtpClient, targetDid?: Did,
 		if (res.cursor) userCursors!.set(did, res.cursor);
 		else userCursors!.set(did, null); // null = exhausted
 
-		for (const record of res.records) newPosts.push(record.uri);
+		for (const record of res.records) {
+			validPosts.push({
+				uri: record.uri,
+				cid: record.cid,
+				record: record.value as AppBskyFeedPost.Main
+			});
+		}
 	}
 
-	if (newPosts.length === 0) return;
-
-	// fetch each post record
-	const posts = await Promise.all(
-		newPosts.map(async (uri) => {
-			const result = await client.getRecordUri(AppBskyFeedPost.mainSchema, uri);
-			if (!result.ok) return null;
-			return { uri: result.value.uri, cid: result.value.cid, record: result.value.record };
-		})
-	);
+	if (validPosts.length === 0) return;
 
-	const validPosts = posts.filter((p): p is PostWithUri => p !== null);
 	addPosts(validPosts);
 
 	for (const post of validPosts) userFeed.add(post.uri);
@@ -970,11 +966,11 @@ export const fetchInteractionsToFeedTimelineEnd = async (
 export const initialDone = new SvelteSet<Did>();
 export const fetchInitial = async (account: Account) => {
 	const client = clients.get(account.did)!;
-	await Promise.all([
+	await Promise.allSettled([
 		fetchBlocks(account),
 		fetchForInteractions(client, account.did),
 		fetchFollows(account).then((follows) =>
-			Promise.all(follows.map((follow) => fetchForInteractions(client, follow.subject)) ?? [])
+			Promise.allSettled(follows.map((follow) => fetchForInteractions(client, follow.subject)) ?? [])
 		)
 	]);
 	initialDone.add(account.did);
diff --git a/src/lib/thread.ts b/src/lib/thread.ts
index 396b8b5..87b4ce4 100644
--- a/src/lib/thread.ts
+++ b/src/lib/thread.ts
@@ -4,7 +4,7 @@ import { parseCanonicalResourceUri, type Did, type ResourceUri } from '@atcute/l
 import type { Account } from './accounts';
 import { expect } from './result';
 import type { PostWithUri } from './at/fetch';
-import { isBlockedBy } from './state.svelte';
+import { isBlockedBy, getBlockRelationship } from './state.svelte';
 import { timestampFromCursor } from '$lib';
 
 export type ThreadPost = {
@@ -15,7 +15,7 @@ export type ThreadPost = {
 	parentUri: ResourceUri | null;
 	depth: number;
 	newestTime: number;
-	isBlocked?: boolean;
+	blockRelationship?: { userBlocked: boolean; blockedByTarget: boolean };
 	isMuted?: boolean;
 };
 
@@ -30,30 +30,48 @@ export const buildThreads = (
 	account: Did,
 	timeline: Set<ResourceUri>,
 	posts: Map<Did, Map<ResourceUri, PostWithUri>>,
-	mutes: Did[],
+	mutes: Set<Did>
 ): Thread[] => {
 	const threadMap = new Map<ResourceUri, ThreadPost[]>();
 
+	// cache block relationships for this build cycle to avoid re-computation
+	// (isBlockedBy uses string ops and map lookups)
+	const blockCache = new Map<Did, { userBlocked: boolean; blockedByTarget: boolean }>();
+	const getBlockRel = (target: Did) => {
+		let rel = blockCache.get(target);
+		if (!rel) {
+			rel = getBlockRelationship(account, target);
+			blockCache.set(target, rel);
+		}
+		return rel;
+	};
+
 	// group posts by root uri into "thread" chains
 	for (const uri of timeline) {
-		const parsedUri = expect(parseCanonicalResourceUri(uri));
-		const data = posts.get(parsedUri.repo)?.get(uri);
+		// fast parse to avoid overhead of regex/validator in tight loop
+		const parts = uri.split('/');
+		if (parts.length < 5) continue;
+		const repo = parts[2] as Did;
+		const rkey = parts[4];
+
+		const data = posts.get(repo)?.get(uri);
 		if (!data) continue;
 
 		const rootUri = (data.record.reply?.root.uri as ResourceUri) || uri;
 		const parentUri = (data.record.reply?.parent.uri as ResourceUri) || null;
 
-		const cursorTime = timestampFromCursor(parsedUri.rkey);
+		const cursorTime = timestampFromCursor(rkey);
+		const blockRel = getBlockRel(repo);
 		const post: ThreadPost = {
 			data,
 			account,
-			did: parsedUri.repo,
-			rkey: parsedUri.rkey,
+			did: repo,
+			rkey,
 			parentUri,
 			depth: 0,
 			newestTime: cursorTime ? cursorTime / 1000 : new Date(data.record.createdAt).getTime(),
-			isBlocked: isBlockedBy(parsedUri.repo, account),
-			isMuted: mutes.includes(parsedUri.repo),
+			blockRelationship: blockRel,
+			isMuted: mutes.has(repo)
 		};
 
 		if (!threadMap.has(rootUri)) threadMap.set(rootUri, []);
@@ -196,8 +214,215 @@ export const filterThreads = (threads: Thread[], accounts: Account[], opts: Filt
 		return true;
 	});
 
-// Helper to extract DID from URI if not already imported from elsewhere
+type ThreadGroup = {
+	rootUri: ResourceUri;
+	posts: ThreadPost[];
+	newestTime: number;
+	isReply: boolean;
+	rootDid: Did | null;
+};
+
+export const buildThreadsFiltered = (
+	account: Did,
+	timeline: Set<ResourceUri>,
+	posts: Map<Did, Map<ResourceUri, PostWithUri>>,
+	mutes: Set<Did>,
+	accounts: Account[],
+	opts: FilterOptions,
+	limit?: number
+): Thread[] => {
+	const blockCache = new Map<Did, { userBlocked: boolean; blockedByTarget: boolean }>();
+	const getBlockRel = (target: Did) => {
+		let rel = blockCache.get(target);
+		if (!rel) {
+			rel = getBlockRelationship(account, target);
+			blockCache.set(target, rel);
+		}
+		return rel;
+	};
+
+	// phase 1: group posts by root uri, track metadata for pre-filtering
+	const groups = new Map<ResourceUri, ThreadGroup>();
+
+	for (const uri of timeline) {
+		const parts = uri.split('/');
+		if (parts.length < 5) continue;
+		const repo = parts[2] as Did;
+		const rkey = parts[4];
+
+		const data = posts.get(repo)?.get(uri);
+		if (!data) continue;
+
+		const rootUri = (data.record.reply?.root.uri as ResourceUri) || uri;
+		const parentUri = (data.record.reply?.parent.uri as ResourceUri) || null;
+		const isReply = !!data.record.reply;
+
+		const cursorTime = timestampFromCursor(rkey);
+		const postTime = cursorTime ? cursorTime / 1000 : new Date(data.record.createdAt).getTime();
+
+		let group = groups.get(rootUri);
+		if (!group) {
+			group = {
+				rootUri,
+				posts: [],
+				newestTime: postTime,
+				isReply,
+				rootDid: extractDidFromUri(rootUri)
+			};
+			groups.set(rootUri, group);
+		}
+
+		const blockRel = getBlockRel(repo);
+		group.posts.push({
+			data,
+			account,
+			did: repo,
+			rkey,
+			parentUri,
+			depth: 0,
+			newestTime: postTime,
+			blockRelationship: blockRel,
+			isMuted: mutes.has(repo)
+		});
+
+		if (postTime > group.newestTime) group.newestTime = postTime;
+	}
+
+	// phase 2: sort groups by newest time descending
+	const sortedGroups = Array.from(groups.values()).sort((a, b) => b.newestTime - a.newestTime);
+
+	// phase 3: process groups with pre-filtering and early exit
+	const threads: Thread[] = [];
+
+	const shouldIncludeGroup = (group: ThreadGroup): boolean => {
+		if (opts.filterReplies && group.isReply) return false;
+
+		if (opts.filterRootsToDids) {
+			if (
+				group.rootDid &&
+				!opts.filterRootsToDids.has(group.rootDid) &&
+				!accounts.some((a) => a.did === group.rootDid)
+			) {
+				return false;
+			}
+		}
+
+		return true;
+	};
+
+	const processGroup = (group: ThreadGroup): Thread[] => {
+		const groupPosts = group.posts;
+		const uriToPost = new Map(groupPosts.map((p) => [p.data.uri, p]));
+		const childrenMap = new Map<ResourceUri | null, ThreadPost[]>();
+
+		for (const post of groupPosts) {
+			let depth = 0;
+			let currentUri = post.parentUri;
+			while (currentUri && uriToPost.has(currentUri)) {
+				depth++;
+				currentUri = uriToPost.get(currentUri)!.parentUri;
+			}
+			post.depth = depth;
+
+			if (!childrenMap.has(post.parentUri)) childrenMap.set(post.parentUri, []);
+			childrenMap.get(post.parentUri)!.push(post);
+		}
+
+		childrenMap.values().forEach((children) => children.sort((a, b) => b.newestTime - a.newestTime));
+
+		const createThread = (
+			posts: ThreadPost[],
+			rootUri: ResourceUri,
+			branchParentUri?: ResourceUri
+		): Thread => ({
+			rootUri,
+			posts,
+			newestTime: Math.max(...posts.map((p) => p.newestTime)),
+			branchParentPost: branchParentUri ? uriToPost.get(branchParentUri) : undefined
+		});
+
+		const collectSubtree = (startPost: ThreadPost): ThreadPost[] => {
+			const result: ThreadPost[] = [];
+			const addWithChildren = (post: ThreadPost) => {
+				result.push(post);
+				const children = childrenMap.get(post.data.uri) || [];
+				children.forEach(addWithChildren);
+			};
+			addWithChildren(startPost);
+			return result;
+		};
+
+		const branchingPoints = Array.from(childrenMap.entries())
+			.filter(([, children]) => children.length > 1)
+			.map(([uri]) => uri);
+
+		const result: Thread[] = [];
+
+		if (branchingPoints.length === 0) {
+			const roots = childrenMap.get(null) || [];
+			const allPosts = roots.flatMap((root) => collectSubtree(root));
+			result.push(createThread(allPosts, group.rootUri));
+		} else {
+			for (const branchParentUri of branchingPoints) {
+				const branches = childrenMap.get(branchParentUri) || [];
+				const sortedBranches = [...branches].sort((a, b) => a.newestTime - b.newestTime);
+
+				sortedBranches.forEach((branchRoot, index) => {
+					const isOldestBranch = index === 0;
+					const branchPosts: ThreadPost[] = [];
+
+					if (isOldestBranch && branchParentUri !== null) {
+						const parentChain: ThreadPost[] = [];
+						let currentUri: ResourceUri | null = branchParentUri;
+						while (currentUri && uriToPost.has(currentUri)) {
+							parentChain.unshift(uriToPost.get(currentUri)!);
+							currentUri = uriToPost.get(currentUri)!.parentUri;
+						}
+						branchPosts.push(...parentChain);
+					}
+
+					branchPosts.push(...collectSubtree(branchRoot));
+
+					const minDepth = Math.min(...branchPosts.map((p) => p.depth));
+					branchPosts.forEach((p) => (p.depth = p.depth - minDepth));
+
+					result.push(
+						createThread(
+							branchPosts,
+							branchRoot.data.uri,
+							isOldestBranch ? undefined : (branchParentUri ?? undefined)
+						)
+					);
+				});
+			}
+		}
+
+		return result;
+	};
+
+	const passesPostFilter = (thread: Thread): boolean => {
+		if (thread.posts.length === 0) return false;
+		if (!opts.viewOwnPosts && hasNonOwnPost(thread.posts, accounts)) return false;
+		return true;
+	};
+
+	for (const group of sortedGroups) {
+		if (!shouldIncludeGroup(group)) continue;
+
+		const groupThreads = processGroup(group);
+
+		for (const thread of groupThreads) {
+			if (!passesPostFilter(thread)) continue;
+			threads.push(thread);
+			if (limit && threads.length >= limit) return threads;
+		}
+	}
+
+	return threads;
+};
+
 const extractDidFromUri = (uri: ResourceUri): Did | null => {
 	const match = uri.match(/^at:\/\/(did:plc:[a-z0-9]+)/);
 	return match ? (match[1] as Did) : null;
 };
+
-- 
2.51.2