diff --git a/AGENTS.md b/AGENTS.md
index bc8d256..e289da4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,5 +1,27 @@
 # Agent Notes
 
+## RTK Commands
+
+When running shell commands, prefix them with `rtk` by default. If `rtk` has no
+filter for a command, it passes through unchanged.
+
+Examples:
+
+```bash
+rtk git status
+rtk git diff
+rtk rg "pattern" src
+rtk npm run build
+```
+
+Rules:
+
+- In command chains, prefix each segment: `rtk git add . && rtk git commit -m "msg"`.
+- Use `rtk rg` for searching, including TSX/JSX files.
+- Do not use `rtk sed`, `rtk proxy sed`, `rtk cat`, `rtk read`, or other RTK-filtered readers for `.tsx` or `.jsx` files; use raw `sed`, `cat`, or similar so JSX syntax is preserved.
+- For debugging, use a raw command without `rtk` if the filter hides needed detail.
+- Use `apply_patch` for manual edits.
+
 ## Build
 
 Use this as the main verification command:
@@ -8,28 +30,72 @@ Use this as the main verification command:
 rtk npm run build
 ```
 
-The app is a Solid/Vite TypeScript frontend. The build runs `tsc -b && vite build`.
-
-Do not start the Vite dev server from agent sessions. Use the build command for verification.
+This is a Solid/Vite TypeScript frontend. The build runs `tsc -b && vite build`.
+Do not start the Vite dev server from agent sessions; use the build command for
+verification.
 
 ## Architecture Map
 
-Do not start by reading every file. Start from the area you are changing:
+Do not start by reading every file. Start from the area you are changing.
 
-- `src/App.tsx`: app shell, routing, topbar, footer, home page, OAuth callback, not-found page.
+- `src/App.tsx`: provider wiring only. Keep this small. It should compose app-wide providers and render `AppRoutes`.
+- `src/routes.tsx`: the declarative route table. Repo routes are nested under `/:owner/:repo` and use `RepoLayout`.
+- `src/layout.tsx`: global shell and topbar. Preserve the `.untangled-shell` wrapper so app pages keep the intended width and padding. There is intentionally no footer.
+- `src/views/home.tsx`: home page and repository jump/recent/own-repo UI.
+- `src/views/oauth-callback.tsx`: OAuth callback completion page.
+- `src/views/not-found.tsx`: not-found page.
 - `src/pages/repo.tsx`: barrel exports for repo routes only.
-- `src/pages/repo/shared.tsx`: shared repo frame/header/tabs, repo query hook, repo query keys.
+- `src/pages/repo/shared.tsx`: repo layout/context, shared repo frame/header/tabs, repo query keys, and `useRepoQuery`.
 - `src/pages/repo/code.tsx`: repo overview/tree page and blob/file viewer.
-- `src/pages/repo/issues.tsx`: issue list, new issue, issue detail.
-- `src/pages/repo/pulls.tsx`: pull list, new pull, pull detail, patch/diff rendering calls.
-- `src/components/common.tsx`: generic UI primitives such as `Avatar`, `LoadingState`, `StateBadge`, form/button/card style helpers.
-- `src/components/repo.tsx`: repo presentation components such as tabs, file rows, README/comment cards, `CodeView`, `DiffView`, branch pills.
-- `src/lib/api.ts`: API/client calls and response types.
+- `src/pages/repo/code-helpers.ts`: pure code-route helpers such as ref/path resolution, language normalization, delayed loading, and navigation click checks.
+- `src/pages/repo/issues.tsx`: issue list, new issue, and issue detail.
+- `src/pages/repo/issues-helpers.ts`: issue-specific pure helpers such as comment thread building.
+- `src/pages/repo/pulls.tsx`: pull list, new pull, pull detail, and patch/diff rendering calls.
+- `src/pages/repo/pulls-helpers.ts`: pull-specific pure helpers such as state filter parsing.
+- `src/components/common.tsx`: generic UI primitives such as `Avatar`, `LoadingState`, `StateBadge`, and form/button/card style helpers.
+- `src/components/repo.tsx`: repo presentation components such as tabs, file rows, README/comment cards, `CodeView`, `DiffView`, branch pills, and repo skeletons.
+- `src/lib/api.ts`: compatibility facade that re-exports domain APIs. Do not add implementation here.
+- `src/lib/api/core.ts`: current low-level API implementation and shared private helpers.
+- `src/lib/api/constants.ts`: public service URLs and OAuth scope exports.
+- `src/lib/api/identity.ts`: auth RPC, identity resolver, actor resolution, avatar resolution.
+- `src/lib/api/repos.ts`: repo records, repo metadata, tree/blob/branch/tag/log/language APIs, compare APIs, and related response types.
+- `src/lib/api/issues.ts`: issue list/detail/create/comment/state APIs and issue types.
+- `src/lib/api/pulls.ts`: pull list/detail/create/comment/status/patch APIs and pull types.
+- `src/lib/api/stars.ts`: repo star summary/count/create/delete APIs and star types.
+- `src/lib/api/records.ts`: shared record utilities such as AT URI parsing and blob CID extraction.
 - `src/lib/auth.tsx`: auth provider and OAuth session state.
 - `src/lib/live-events.tsx`: live websocket event provider/hook.
-- `src/lib/repo-utils.ts`: repo URL/path helpers, file type checks, formatting, recent repo storage, language colors, tree sorting.
+- `src/lib/repo-utils.ts`: repo URL/path helpers, file type checks, formatting, recent repo storage, language colors, tree sorting, and shared pure repo helpers.
 - `src/index.css`: global CSS plus explicit utility classes used to replace missing Tailwind arbitrary classes.
 
+## Repo Route Pattern
+
+Repo pages live under `RepoLayout` in `src/pages/repo/shared.tsx`.
+
+- `RepoLayout` creates the shared repo query once for the `/:owner/:repo` route subtree.
+- Child routes must call `useRepoQuery()` instead of creating their own repo query.
+- `RepoFrame` owns the shared repo chrome, tab links, star control, recent-repo storage, and live event subscription.
+- New repo-route behavior should usually go in a focused `src/pages/repo/*.tsx` file or a small helper beside it, not in `src/App.tsx` or `src/routes.tsx`.
+- Keep route files from growing indefinitely. Move pure helpers into `*-helpers.ts` files and reusable display pieces into `src/components/repo.tsx`.
+
+## API Module Pattern
+
+Use domain imports for new code:
+
+```ts
+import { getRepoTree } from '../../lib/api/repos';
+import { createIssue } from '../../lib/api/issues';
+```
+
+The facade `src/lib/api.ts` remains for compatibility with existing imports, but new implementation should go into the relevant domain module or, if it truly must share private internals, into `src/lib/api/core.ts` and be re-exported through the domain module.
+
+Guidelines:
+
+- Do not add new implementation to `src/lib/api.ts`.
+- Prefer keeping public types next to the domain module that exposes the API.
+- Keep ATProto/PDS resolution rules centralized; repo UI record hydration should resolve the actor/PDS first and call the record endpoint against that PDS.
+- Do not use `public.api.bsky.app` for repo `listRecords` or record hydration.
+
 ## Styling Source Of Truth
 
 This frontend is intended to match the upstream Tangled app templates in:
@@ -50,111 +116,75 @@ Useful upstream files:
 - `templates/repo/pulls/fragments/*`
 - `static/tw.css`
 
-When matching visuals, compare against those templates before inventing new layout/styling.
+When matching visuals, compare against those templates before inventing new
+layout/styling.
 
 ## Upstream Comparison Workflow
 
-For Tangled parity work, use upstream as the contract and compare details before changing local components:
+For Tangled parity work, use upstream as the contract and compare details before
+changing local components:
 
 - Start from the matching upstream template in `../tangled-upstream/appview/pages/templates/...`, then check nearby Go/router files when behavior or icon names are data-driven.
 - For repo chrome, `templates/layouts/repobase.html` is the main reference. Confirm header grouping, action buttons, tab icons, label spacing, font sizes, and vertical padding against that file before patching `src/pages/repo/shared.tsx`.
 - For code/blob views, compare `templates/repo/index.html` and `templates/repo/blob.html` before changing `src/pages/repo/code.tsx`, `src/components/repo.tsx`, or file-view CSS.
-- Treat screenshots as prompts to inspect upstream source, not as the only source of truth. Small differences such as `gap-*`, `py-*`, icon choice, and short-rev styling matter.
-- Remove or hide upstream controls that are not implemented locally instead of shipping fake UI. Recent examples: fork action and topbar repo search/jump.
+- Treat screenshots as prompts to inspect upstream source, not as the only source of truth.
+- Small differences such as `gap-*`, `py-*`, icon choice, and short-rev styling matter.
+- Remove or hide upstream controls that are not implemented locally instead of shipping fake UI.
 - External upstream-only affordances can link to `https://tangled.org`, such as repo stars and `/:owner/:repo/feed.atom`.
-- When fetching ATProto records for repo UI, resolve the actor/PDS first and call the record endpoint against that PDS. Do not use `public.api.bsky.app` for repo `listRecords`/record hydration.
-- If Vite HMR reports a removed handler or prop after a UI deletion, confirm with `rtk grep` and `rtk npm run build`; stale dev-server modules can survive until the server or page is restarted.
 
 ## Tailwind/CSS Pitfall
 
-The checked-in `public/static/tw.css` does not include all arbitrary Tailwind classes. Avoid relying on classes such as:
+The checked-in `public/static/tw.css` does not include all arbitrary Tailwind
+classes. Avoid relying on classes such as:
 
 - `grid-cols-[...]`
 - `[overflow-wrap:anywhere]`
 - `dark:[&_code]:...`
 - arbitrary safe-area or min-height utilities
 
-If a class is not present in `public/static/tw.css`, add an explicit `.untangled-*` rule in `src/index.css` instead. Many previous visual bugs were caused by the browser dropping missing arbitrary classes.
+If a class is not present in `public/static/tw.css`, add an explicit
+`.untangled-*` rule in `src/index.css` instead.
 
 ## Repo UI Notes
 
+- Preserve the `.untangled-shell` wrapper in `RootShell`; widening pages changes the app layout.
+- Do not add a footer unless explicitly requested.
 - File/tree ordering should be folders first, then files alphabetically. This is implemented in `sortedTreeEntries` in `src/lib/repo-utils.ts`.
 - File/blob rendering uses `CodeView` in `src/components/repo.tsx`.
 - PR diffs use `DiffView`, which parses unified patches into collapsible per-file panels and reuses `CodeView`.
 - Repo overview and blob pages should resolve `HEAD` to the default branch for user-facing links when possible.
 - Keep unimplemented upstream features visually inert rather than adding fake behavior.
-
 - Repo commit lists should show author avatars like upstream. Upstream maps verified commit author emails to DIDs server-side; the local app can render `Avatar` when the commit author email is already a DID, otherwise use `PlaceholderAvatar`.
 - The upstream placeholder avatar is a rounded gray background with a centered `user-round` icon. Use `PlaceholderAvatar` from `src/components/common.tsx` instead of a plain empty circle.
 - Do not show a verified-looking commit badge unless signature validity is actually checked. Use the neutral commit badge/icon for commit hashes.
 - Repo stars must count backlinks for both `sh.tangled.feed.star:subject.did` and legacy/alternate `sh.tangled.feed.star:subjectDid`, then dedupe hydrated refs.
 - Star and unstar should be optimistic. Unstar deletes the current user's `sh.tangled.feed.star` record and should update local state without refetching.
 - While star summary is loading, make the star control unclickable and show the upstream-style `loader-circle` spinner (`LoaderCircle` with `animate-spin` locally).
-- Markdown rendering should not enable hard line breaks globally for README-style content; `marked` should use `breaks: false` to avoid mid-line wrapping artifacts.
+- Markdown rendering should not enable hard line breaks globally for README-style content; `marked` should use `breaks: false`.
 
 ## Editing Guidance
 
-- Keep `src/App.tsx` small. New repo-route behavior should usually go into `src/pages/repo/*.tsx`.
+- Keep `src/App.tsx` small.
+- Keep route declarations in `src/routes.tsx`.
+- Keep global shell/topbar work in `src/layout.tsx`.
+- Keep top-level non-repo pages in `src/views`.
+- Keep repo-route behavior in `src/pages/repo/*.tsx`.
+- Keep repo-route pure helpers in nearby `src/pages/repo/*-helpers.ts` files.
 - Keep generic display components in `src/components/common.tsx`.
 - Keep repo-specific display components in `src/components/repo.tsx`.
-- Keep pure helpers in `src/lib/repo-utils.ts`.
+- Keep shared pure repo helpers in `src/lib/repo-utils.ts`.
 - Do not add large page logic back into `src/App.tsx`.
-- Use `apply_patch` for manual edits.
-- Do not remove existing behavior while restructuring. Run `rtk npm run build` after meaningful changes.
+- Do not remove existing behavior while restructuring.
+- Run `rtk npm run build` after meaningful changes.
 
 ## Current Size Guide
 
-Approximate current file sizes:
+Approximate current file roles:
 
-- `src/App.tsx`: small app shell and routing.
-- `src/pages/repo/code.tsx`: largest file; split further if code/blob logic grows.
+- `src/App.tsx`: tiny provider shell.
+- `src/layout.tsx`: global topbar/shell.
+- `src/routes.tsx`: route table.
+- `src/pages/repo/code.tsx`: largest repo route; split further if code/blob logic grows.
 - `src/pages/repo/pulls.tsx`: pull routes and patch/diff UI.
 - `src/pages/repo/issues.tsx`: issue routes.
-
-If a file grows substantially, prefer extracting focused components or helpers rather than continuing to grow the route file.
-
-
-<!-- headroom:rtk-instructions -->
-# RTK (Rust Token Killer) - Token-Optimized Commands
-
-When running shell commands, **always prefix with `rtk`**. This reduces context
-usage by 60-90% with zero behavior change. If rtk has no filter for a command,
-it passes through unchanged — so it is always safe to use.
-
-## Key Commands
-```bash
-# Git (59-80% savings)
-rtk git status          rtk git diff            rtk git log
-
-# Files & Search (60-75% savings)
-rtk ls <path>           rtk read <file>         rtk grep <pattern>
-rtk find <pattern>      rtk diff <file>
-
-# Test (90-99% savings) — shows failures only
-rtk pytest tests/       rtk cargo test          rtk test <cmd>
-
-# Build & Lint (80-90% savings) — shows errors only
-rtk tsc                 rtk lint                rtk cargo build
-rtk prettier --check    rtk mypy                rtk ruff check
-
-# Analysis (70-90% savings)
-rtk err <cmd>           rtk log <file>          rtk json <file>
-rtk summary <cmd>       rtk deps                rtk env
-
-# GitHub (26-87% savings)
-rtk gh pr view <n>      rtk gh run list         rtk gh issue list
-
-# Infrastructure (85% savings)
-rtk docker ps           rtk kubectl get         rtk docker logs <c>
-
-# Package managers (70-90% savings)
-rtk pip list            rtk pnpm install        rtk npm run <script>
-```
-
-## Rules
-- In command chains, prefix each segment: `rtk git add . && rtk git commit -m "msg"`
-- Use `rtk rg` for searching, including TSX/JSX files.
-- Do not use RTK for reading `.tsx` or `.jsx` files; use raw `sed`, `cat`, or similar so JSX syntax is preserved.
-- For debugging, use raw command without rtk prefix.
-- `rtk proxy <cmd>` runs command without filtering but tracks usage
-<!-- /headroom:rtk-instructions -->
+- `src/lib/api/core.ts`: compatibility implementation backend; prefer new domain modules for new API surfaces.
diff --git a/src/App.tsx b/src/App.tsx
index 12b3ec6..e8dc4e9 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,23 +1,9 @@
-import clsx from 'clsx';
-import { Bell, LogOut } from 'lucide-solid';
-import { A, Route, Router, useNavigate } from '@solidjs/router';
-import { QueryClient, QueryClientProvider, createQuery } from '@tanstack/solid-query';
-import { For, Show, createMemo, createSignal, onMount, type Component, type JSX } from 'solid-js';
-import { listRepoRecords, resolveActor } from './lib/api';
-import { AuthProvider, useAuth } from './lib/auth';
-import { Avatar, LoadingState, buttonStyles, cardStyles, inputStyles } from './components/common';
-import { formatRelativeTime, loadRecentRepos, parseRepoJump } from './lib/repo-utils';
-import { LiveEventsProvider, useLiveEvents, type LiveEvent } from './lib/live-events';
-import {
-	BlobPage,
-	IssuePage,
-	IssuesPage,
-	NewIssuePage,
-	NewPullPage,
-	PullPage,
-	PullsPage,
-	RepoCodePage,
-} from './pages/repo';
+import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
+import type { Component } from 'solid-js';
+
+import { AuthProvider } from './lib/auth';
+import { LiveEventsProvider } from './lib/live-events';
+import { AppRoutes } from './routes';
 
 const queryClient = new QueryClient({
 	defaultOptions: {
@@ -28,339 +14,14 @@ const queryClient = new QueryClient({
 	},
 });
 
-
-const SAMPLE_REPOS = [
-	{ owner: 'mary.my.id', slug: 'atcute' },
-	{ owner: 'mary.my.id', slug: 'boat' },
-	{ owner: 'mary.my.id', slug: 'aglais' },
-];
-
-
 const App: Component = () => (
 	<QueryClientProvider client={queryClient}>
 		<AuthProvider>
 			<LiveEventsProvider>
-				<Router root={RootShell}>
-					<Route path="/" component={HomePage} />
-					<Route path="/oauth/callback" component={OAuthCallbackPage} />
-					<Route path="/:owner/:repo/issues/new" component={NewIssuePage} />
-					<Route path="/:owner/:repo/issues/:issueRef" component={IssuePage} />
-					<Route path="/:owner/:repo/issues" component={IssuesPage} />
-					<Route path="/:owner/:repo/pulls/new" component={NewPullPage} />
-					<Route path="/:owner/:repo/pulls/:pullRef" component={PullPage} />
-					<Route path="/:owner/:repo/pulls" component={PullsPage} />
-					<Route path="/:owner/:repo/blob/:ref/*path" component={BlobPage} />
-					<Route path="/:owner/:repo/tree/:ref/*path" component={RepoCodePage} />
-					<Route path="/:owner/:repo" component={RepoCodePage} />
-					<Route path="*404" component={NotFoundPage} />
-				</Router>
+				<AppRoutes />
 			</LiveEventsProvider>
 		</AuthProvider>
 	</QueryClientProvider>
 );
 
-const RootShell: Component<{ children?: JSX.Element }> = (props) => (
-	<div class="min-h-screen flex flex-col gap-4 bg-slate-100 dark:bg-gray-900 dark:text-white">
-		<header class="untangled-safe-header w-full shadow-sm dark:text-white bg-white dark:bg-gray-800" style="z-index: 20;">
-			<Topbar />
-		</header>
-
-		<div class="flex-grow">
-			<div class="untangled-shell mx-auto flex flex-col gap-4">{props.children}</div>
-		</div>
-	</div>
-);
-
-export const Footer: Component = () => {
-	const linkStyle = 'hover:text-gray-900 hover:underline dark:hover:text-gray-100';
-
-	return (
-		<div class="w-full border-t border-gray-200 bg-white px-4 py-3 text-sm text-gray-500 dark:border-gray-700 dark:bg-gray-800 dark:text-gray-400">
-			<div class="untangled-footer-links untangled-shell mx-auto">
-				<img src="/static/logos/dolly.svg" alt="" class="size-5" />
-				<span>&copy; 2026 Tangled Labs Oy.</span>
-				<a href="https://blog.tangled.org" class={linkStyle}>blog</a>
-				<a href="https://docs.tangled.org" class={linkStyle}>docs</a>
-				<a href="https://tangled.org/@tangled.org/core" class={linkStyle}>source</a>
-				<a href="https://tangled.org/brand" class={linkStyle}>brand</a>
-				<a href="https://chat.tangled.org" class={linkStyle}>discord</a>
-				<a href="https://bsky.app/profile/tangled.org" class={linkStyle}>bluesky</a>
-				<a href="https://x.com/tangled_org" class={linkStyle}>twitter (x)</a>
-				<a href="/terms" class={linkStyle}>terms</a>
-				<a href="/privacy" class={linkStyle}>privacy</a>
-			</div>
-		</div>
-	);
-};
-
-
-const eventLabel = (event: LiveEvent): string => {
-	if (
-		event.source === 'sh.tangled.repo.issue:repoDid' ||
-		event.source === 'sh.tangled.repo.issue:repo'
-	) {
-		return `new issue on ${event.subject}`;
-	}
-	if (event.source === 'sh.tangled.repo.pull:target.repo') {
-		return `new pull on ${event.subject}`;
-	}
-	return `${event.source} → ${event.subject}`;
-};
-
-const Topbar: Component = () => {
-	const auth = useAuth();
-	const live = useLiveEvents();
-	const [identifier, setIdentifier] = createSignal('');
-
-	const viewerQuery = createQuery(() => ({
-		queryKey: ['viewer', auth.currentDid()],
-		enabled: Boolean(auth.currentDid()),
-		queryFn: async () => resolveActor(auth.currentDid()!),
-	}));
-
-	const onSignIn = async (event: SubmitEvent) => {
-		event.preventDefault();
-		await auth.signIn(identifier());
-	};
-
-	return (
-		<nav class="mx-auto space-x-4 px-6 py-2">
-			<div class="flex justify-between p-0 items-center">
-				<A href="/" class="text-2xl no-underline hover:no-underline flex items-center gap-2">
-					<img src="/static/logos/dolly.svg" alt="" class="size-8" />
-					<span class="font-bold text-xl">untangled</span>
-					<span class="font-normal text-xs rounded bg-gray-100 dark:bg-gray-700 px-1">alpha</span>
-			</A>
-
-			<div class="flex items-center gap-4">
-				<Show
-					when={auth.currentDid()}
-						fallback={
-							<details class="relative">
-								<summary class={clsx(buttonStyles(), 'cursor-pointer list-none')}>login</summary>
-								<div class="absolute right-0 mt-3 w-72 rounded border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 p-4 shadow-lg z-50">
-									<form onSubmit={onSignIn} class="flex flex-col gap-3">
-										<input
-											value={identifier()}
-											onInput={(event) => setIdentifier(event.currentTarget.value)}
-											placeholder="handle or did"
-											class={inputStyles()}
-										/>
-										<button type="submit" class={clsx(buttonStyles('primary'), 'justify-center')}>
-											continue with OAuth
-										</button>
-										<Show when={auth.error()}>
-											<p class="text-sm text-red-500">{auth.error()}</p>
-										</Show>
-									</form>
-								</div>
-							</details>
-						}
-					>
-						<details class="relative">
-							<summary
-								class="cursor-pointer list-none flex items-center gap-2"
-								onClick={() => live.markRead()}
-							>
-								<div class="relative">
-									<Bell class="size-5 text-gray-500 dark:text-gray-400" />
-									<Show when={live.unread() > 0}>
-										<span class="untangled-unread-badge absolute -top-2 -right-2 min-w-5 h-5 rounded-full bg-blue-600 text-white flex items-center justify-center px-1">
-											{Math.min(live.unread(), 99)}
-										</span>
-									</Show>
-								</div>
-							</summary>
-							<div class="absolute right-0 mt-3 w-80 rounded border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 shadow-lg z-50 overflow-hidden">
-								<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700 font-medium">live activity</div>
-								<div class="max-h-96 overflow-auto">
-									<Show
-										when={live.events().length > 0}
-										fallback={<div class="px-4 py-6 text-sm text-gray-500 dark:text-gray-400">No live events yet.</div>}
-									>
-										<For each={live.events()}>
-											{(event) => (
-												<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700 text-sm">
-													<div class="font-medium break-all">{eventLabel(event)}</div>
-													<div class="text-gray-500 dark:text-gray-400">{formatRelativeTime(event.receivedAt)}</div>
-												</div>
-											)}
-										</For>
-									</Show>
-								</div>
-							</div>
-						</details>
-
-						<details class="relative">
-							<summary class="cursor-pointer list-none flex items-center gap-2">
-								<Avatar did={auth.currentDid()!} size="size-8 md:size-6" />
-								<span class="hidden md:inline">{viewerQuery.data?.handle ?? auth.currentDid()}</span>
-							</summary>
-							<div class="absolute right-0 mt-4 rounded bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 shadow-lg z-50 text-sm w-56">
-								<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700">
-									<div class="font-medium truncate">{viewerQuery.data?.handle ?? auth.currentDid()}</div>
-									<div class="text-gray-500 dark:text-gray-400 truncate">{auth.currentDid()}</div>
-								</div>
-								<button
-									type="button"
-									class="w-full px-4 py-3 flex items-center gap-2 text-left hover:bg-gray-50 hover:dark:bg-gray-700/50"
-									onClick={() => void auth.signOut()}
-								>
-									<LogOut class="size-4" />
-									logout
-								</button>
-							</div>
-						</details>
-					</Show>
-				</div>
-			</div>
-		</nav>
-	);
-};
-
-const HomePage: Component = () => {
-	const auth = useAuth();
-	const [jump, setJump] = createSignal('');
-	const recentRepos = createMemo(loadRecentRepos);
-	const navigate = useNavigate();
-
-	const ownReposQuery = createQuery(() => ({
-		queryKey: ['own-repos', auth.currentDid()],
-		enabled: Boolean(auth.currentDid()),
-		queryFn: async () => {
-			const actor = await resolveActor(auth.currentDid()!);
-			return listRepoRecords(actor);
-		},
-	}));
-
-	const onSubmit = (event: SubmitEvent) => {
-		event.preventDefault();
-		const parsed = parseRepoJump(jump());
-		if (!parsed) {
-			return;
-		}
-
-		navigate(`/${parsed.owner}/${parsed.repo}`);
-	};
-
-	return (
-		<section class="untangled-home-grid">
-			<div class={cardStyles('p-6')}>
-				<div class="flex items-center gap-3 mb-6">
-					<img src="/static/logos/dolly.svg" alt="" class="size-10" />
-					<div>
-							<h1 class="text-2xl font-bold m-0">untangled</h1>
-							<p class="m-0 text-sm text-gray-500 dark:text-gray-400">tightly-knit social coding</p>
-					</div>
-				</div>
-
-				<form onSubmit={onSubmit} class="flex flex-col gap-3">
-					<label class="text-sm font-medium">repository</label>
-					<div class="flex gap-2">
-						<input
-							value={jump()}
-							onInput={(event) => setJump(event.currentTarget.value)}
-							placeholder="mary.my.id/atcute"
-							class={inputStyles()}
-						/>
-						<button type="submit" class={clsx(buttonStyles('primary'), 'shrink-0')}>
-							open
-						</button>
-					</div>
-				</form>
-
-				<div class="mt-8">
-					<div class="text-sm font-medium mb-3">sample repositories</div>
-					<div class="grid gap-2 sm:grid-cols-2">
-						<For each={SAMPLE_REPOS}>
-							{(repo) => (
-								<A href={`/${repo.owner}/${repo.slug}`} class={cardStyles('p-4 hover:bg-gray-50 dark:hover:bg-gray-700/30 no-underline')}>
-									<div class="font-medium">
-										{repo.owner}/{repo.slug}
-									</div>
-								</A>
-							)}
-						</For>
-					</div>
-				</div>
-			</div>
-
-			<div class="flex flex-col gap-4">
-				<div class={cardStyles('p-6')}>
-					<div class="text-sm font-medium mb-3">recent</div>
-					<Show
-						when={recentRepos().length > 0}
-						fallback={<div class="text-sm text-gray-500 dark:text-gray-400">No recent repositories.</div>}
-					>
-						<div class="flex flex-col gap-2">
-							<For each={recentRepos()}>
-								{(repo) => (
-									<A href={`/${repo.owner}/${repo.slug}`} class="no-underline hover:no-underline rounded border border-gray-200 dark:border-gray-700 px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-700/30">
-										<div class="font-medium">{repo.title}</div>
-										<div class="text-xs text-gray-500 dark:text-gray-400">{formatRelativeTime(repo.updatedAt)}</div>
-									</A>
-								)}
-							</For>
-						</div>
-					</Show>
-				</div>
-
-				<Show when={auth.currentDid()}>
-					<div class={cardStyles('p-6')}>
-						<div class="text-sm font-medium mb-3">your repositories</div>
-						<Show
-							when={!ownReposQuery.isLoading}
-							fallback={<LoadingState label="Loading repositories…" />}
-						>
-							<div class="flex flex-col gap-2">
-								<For each={ownReposQuery.data ?? []}>
-									{(repo) => (
-										<A
-											href={`/${auth.currentDid()}/${repo.value.name?.trim() || repo.rkey}`}
-											class="no-underline hover:no-underline rounded border border-gray-200 dark:border-gray-700 px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-700/30"
-										>
-											<div class="font-medium">{repo.value.name?.trim() || repo.rkey}</div>
-											<div class="text-xs text-gray-500 dark:text-gray-400">
-												{repo.value.description || repo.value.repoDid}
-											</div>
-										</A>
-									)}
-								</For>
-							</div>
-						</Show>
-					</div>
-				</Show>
-			</div>
-		</section>
-	);
-};
-
-const OAuthCallbackPage: Component = () => {
-	const auth = useAuth();
-	const navigate = useNavigate();
-
-	onMount(() => {
-		void (async () => {
-			try {
-				const target = await auth.completeSignIn();
-				navigate(target, { replace: true });
-			} catch {
-				// error already captured in auth state
-			}
-		})();
-	});
-
-	return (
-		<div class={cardStyles('p-10 text-center')}>
-			<LoadingState label={auth.error() ?? 'Completing OAuth sign-in…'} />
-		</div>
-	);
-};
-
-const NotFoundPage: Component = () => (
-	<div class={cardStyles('p-10 text-center')}>
-		<h1 class="text-2xl font-bold m-0">not found</h1>
-	</div>
-);
-
 export default App;
diff --git a/src/components/repo.tsx b/src/components/repo.tsx
index 056134d..e35730f 100644
--- a/src/components/repo.tsx
+++ b/src/components/repo.tsx
@@ -592,16 +592,108 @@ const totalDiffStats = (files: DiffFile[]) =>
 		{ additions: 0, deletions: 0 },
 	);
 
-const fileTreeRows = (files: DiffFile[]) =>
-	files.map((file) => {
+type DiffFileTreeNode = {
+	name: string;
+	path: string;
+	file?: DiffFile;
+	children?: DiffFileTreeNode[];
+};
+
+const sortDiffFileTree = (nodes: DiffFileTreeNode[]): DiffFileTreeNode[] =>
+	nodes
+		.sort((a, b) => a.name.localeCompare(b.name))
+		.map((node) => ({
+			...node,
+			children: node.children ? sortDiffFileTree(node.children) : undefined,
+		}));
+
+const diffFileTree = (files: DiffFile[]) => {
+	const roots: DiffFileTreeNode[] = [];
+
+	for (const file of files) {
 		const parts = file.path.split('/').filter(Boolean);
-		return {
-			file,
-			depth: Math.max(parts.length - 1, 0),
-			name: parts.at(-1) ?? file.path,
-			folder: parts.length > 1 ? parts.slice(0, -1).join('/') : '',
-		};
-	});
+		const pathParts = parts.length > 0 ? parts : [file.path || 'patch'];
+		let siblings = roots;
+		let path = '';
+
+		for (const [index, part] of pathParts.entries()) {
+			path = path ? `${path}/${part}` : part;
+			const isFile = index === pathParts.length - 1;
+
+			if (isFile) {
+				siblings.push({ name: part, path: file.path, file });
+				continue;
+			}
+
+			let node = siblings.find((child) => !child.file && child.name === part);
+			if (!node) {
+				node = { name: part, path, children: [] };
+				siblings.push(node);
+			}
+
+			siblings = node.children!;
+		}
+	}
+
+	return sortDiffFileTree(roots);
+};
+
+const diffFileElementId = (path: string) =>
+	`diff-${Array.from(path, (char) => char.codePointAt(0)!.toString(16).padStart(4, '0')).join('-')}`;
+
+const scrollToDiffFile = (path: string, event: MouseEvent) => {
+	if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+
+	const target = document.getElementById(diffFileElementId(path));
+	if (!target) return;
+
+	event.preventDefault();
+	target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+
+	const hash = `#${target.id}`;
+	if (window.location.hash !== hash) {
+		window.history.pushState(null, '', `${window.location.pathname}${window.location.search}${hash}`);
+	}
+};
+
+const DiffFileTreeNodes: Component<{ nodes: DiffFileTreeNode[] }> = (props) => (
+	<div class="untangled-pr-file-tree-list">
+		<For each={props.nodes}>{(node) => <DiffFileTreeNodeView node={node} />}</For>
+	</div>
+);
+
+const DiffFileTreeNodeView: Component<{ node: DiffFileTreeNode }> = (props) => (
+	<div class="untangled-pr-file-tree-node">
+		<Show
+			when={props.node.file}
+			fallback={
+				<>
+					<div class="untangled-pr-file-tree-entry" title={props.node.path}>
+						<Folder class="size-4 shrink-0" />
+						<span class="truncate">{props.node.name}</span>
+					</div>
+					<Show when={props.node.children?.length}>
+						<div class="untangled-pr-file-tree-children">
+							<DiffFileTreeNodes nodes={props.node.children!} />
+						</div>
+					</Show>
+				</>
+			}
+		>
+			{(file) => (
+				<a
+					href={`#${diffFileElementId(file().path)}`}
+					class="untangled-pr-file-tree-entry untangled-pr-file-tree-link"
+					title={file().path}
+					onClick={(event) => scrollToDiffFile(file().path, event)}
+				>
+					<FileText class="size-4 shrink-0" />
+					<span class="truncate">{props.node.name}</span>
+				</a>
+			)}
+		</Show>
+	</div>
+);
 
 const DiffStatPill: Component<{ additions: number; deletions: number }> = (props) => (
 	<div class="untangled-diff-stat-pill">
@@ -617,7 +709,7 @@ const DiffStatPill: Component<{ additions: number; deletions: number }> = (props
 export const PullDiffView: Component<{ patch: string; roundLabel: string; history: JSX.Element }> = (props) => {
 	const files = createMemo(() => parseDiffFiles(props.patch));
 	const stats = createMemo(() => totalDiffStats(files()));
-	const rows = createMemo(() => fileTreeRows(files()));
+	const tree = createMemo(() => diffFileTree(files()));
 	const [expanded, setExpanded] = createSignal(true);
 	const [filesVisible, setFilesVisible] = createSignal(true);
 	const [historyVisible, setHistoryVisible] = createSignal(true);
@@ -681,28 +773,14 @@ export const PullDiffView: Component<{ patch: string; roundLabel: string; histor
 			>
 				<Show when={filesVisible()}>
 					<aside class="untangled-pr-file-tree" aria-label="changed files">
-						<For each={rows()}>
-							{(row) => (
-								<a
-									href={`#diff-${encodeURIComponent(row.file.path)}`}
-									class="untangled-pr-file-tree-row"
-									style={{ 'padding-left': `${0.75 + row.depth * 0.85}rem` }}
-									title={row.file.path}
-								>
-									<Show when={row.folder} fallback={<FileText class="size-4 shrink-0" />}>
-										<Folder class="size-4 shrink-0" />
-									</Show>
-									<span class="truncate">{row.name}</span>
-								</a>
-							)}
-						</For>
+						<DiffFileTreeNodes nodes={tree()} />
 					</aside>
 				</Show>
 
 				<div class="untangled-pr-diff-files">
 					<For each={files()}>
 						{(file) => (
-							<details id={`diff-${encodeURIComponent(file.path)}`} class="untangled-pr-diff-file" open={expanded()}>
+							<details id={diffFileElementId(file.path)} class="untangled-pr-diff-file" open={expanded()}>
 								<summary class="untangled-pr-diff-file-header">
 									<div class="flex min-w-0 items-center gap-2">
 										<ChevronRight class="untangled-pr-diff-chevron size-4 shrink-0" />
diff --git a/src/index.css b/src/index.css
index e5df282..5ffccb4 100644
--- a/src/index.css
+++ b/src/index.css
@@ -98,7 +98,7 @@
 	top: 0;
 	z-index: 30;
 	display: grid;
-	grid-template-columns: 11.5rem minmax(0, 1fr) 29.5rem;
+	grid-template-columns: 15.5rem minmax(0, 1fr) 29.5rem;
 	gap: 1rem;
 	align-items: center;
 	padding: 0.5rem;
@@ -110,7 +110,7 @@
 }
 
 .untangled-pr-diff-toolbar-history-collapsed {
-	grid-template-columns: 11.5rem minmax(0, 1fr) 2.125rem;
+	grid-template-columns: 15.5rem minmax(0, 1fr) 2.125rem;
 }
 
 .untangled-pr-diff-toolbar-sidebar-collapsed.untangled-pr-diff-toolbar-history-collapsed {
@@ -199,7 +199,7 @@
 
 .untangled-pr-diff-grid {
 	display: grid;
-	grid-template-columns: 11.5rem minmax(0, 1fr) 29.5rem;
+	grid-template-columns: 15.5rem minmax(0, 1fr) 29.5rem;
 	gap: 1rem;
 	align-items: start;
 }
@@ -209,7 +209,7 @@
 }
 
 .untangled-pr-diff-grid-history-collapsed {
-	grid-template-columns: 11.5rem minmax(0, 1fr);
+	grid-template-columns: 15.5rem minmax(0, 1fr);
 }
 
 .untangled-pr-diff-grid-sidebar-collapsed.untangled-pr-diff-grid-history-collapsed {
@@ -226,24 +226,45 @@
 	border-top: 0;
 	border-radius: 0 0 0.25rem 0.25rem;
 	background: rgb(255 255 255);
-	padding: 0.625rem 0 1.5rem;
+	padding: 0.75rem 0.75rem 1.5rem;
 	box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
 }
 
-.untangled-pr-file-tree-row {
+.untangled-pr-file-tree-list {
+	display: flex;
+	min-width: 0;
+	flex-direction: column;
+	gap: 0.125rem;
+}
+
+.untangled-pr-file-tree-node {
+	min-width: 0;
+}
+
+.untangled-pr-file-tree-children {
+	margin-left: 1rem;
+	border-left: 1px solid rgb(209 213 219);
+	padding-left: 0.75rem;
+}
+
+.untangled-pr-file-tree-entry {
 	display: flex;
 	min-width: 0;
 	align-items: center;
 	gap: 0.375rem;
-	padding-top: 0.25rem;
+	min-height: 1.5rem;
+	border-radius: 0.25rem;
+	padding-top: 0.125rem;
 	padding-right: 0.5rem;
-	padding-bottom: 0.25rem;
+	padding-bottom: 0.125rem;
+	padding-left: 0.25rem;
 	color: rgb(55 65 81);
 	font-size: 0.875rem;
 	text-decoration: none;
 }
 
-.untangled-pr-file-tree-row:hover {
+.untangled-pr-file-tree-link:hover,
+.untangled-pr-file-tree-entry:hover {
 	background: rgb(243 244 246);
 	text-decoration: none;
 }
@@ -256,6 +277,7 @@
 }
 
 .untangled-pr-diff-file {
+	scroll-margin-top: 4rem;
 	overflow: hidden;
 	border: 1px solid rgb(209 213 219);
 	border-radius: 0.25rem;
@@ -436,11 +458,15 @@
 		color: rgb(248 113 113);
 	}
 
-	.untangled-pr-file-tree-row {
+	.untangled-pr-file-tree-entry {
 		color: rgb(229 231 235);
 	}
 
-	.untangled-pr-file-tree-row:hover {
+	.untangled-pr-file-tree-children {
+		border-color: rgb(75 85 99);
+	}
+
+	.untangled-pr-file-tree-entry:hover {
 		background: rgb(31 41 55);
 	}
 
diff --git a/src/layout.tsx b/src/layout.tsx
new file mode 100644
index 0000000..0721b28
--- /dev/null
+++ b/src/layout.tsx
@@ -0,0 +1,146 @@
+import clsx from 'clsx';
+import { Bell, LogOut } from 'lucide-solid';
+import { A } from '@solidjs/router';
+import { createQuery } from '@tanstack/solid-query';
+import { For, Show, createSignal, type Component, type JSX } from 'solid-js';
+
+import { Avatar, buttonStyles, inputStyles } from './components/common';
+import { resolveActor } from './lib/api';
+import { useAuth } from './lib/auth';
+import { useLiveEvents, type LiveEvent } from './lib/live-events';
+import { formatRelativeTime } from './lib/repo-utils';
+
+const eventLabel = (event: LiveEvent) => {
+	if (event.source === 'sh.tangled.repo.issue:repo') {
+		return `new issue on ${event.subject}`;
+	}
+
+	if (event.source === 'sh.tangled.repo.pull:target.repo') {
+		return `new pull on ${event.subject}`;
+	}
+
+	return `${event.source} -> ${event.subject}`;
+};
+
+const Topbar: Component = () => {
+	const auth = useAuth();
+	const live = useLiveEvents();
+	const [identifier, setIdentifier] = createSignal('');
+
+	const viewerQuery = createQuery(() => ({
+		queryKey: ['viewer', auth.currentDid()],
+		enabled: Boolean(auth.currentDid()),
+		queryFn: async () => resolveActor(auth.currentDid()!),
+	}));
+
+	const onSignIn = async (event: SubmitEvent) => {
+		event.preventDefault();
+		await auth.signIn(identifier());
+	};
+
+	return (
+		<nav class="mx-auto space-x-4 px-6 py-2">
+			<div class="flex justify-between p-0 items-center">
+				<A href="/" class="text-2xl no-underline hover:no-underline flex items-center gap-2">
+					<img src="/static/logos/dolly.svg" alt="" class="size-8" />
+					<span class="font-bold text-xl">untangled</span>
+					<span class="font-normal text-xs rounded bg-gray-100 dark:bg-gray-700 px-1">alpha</span>
+				</A>
+
+				<div class="flex items-center gap-4">
+					<Show
+						when={auth.currentDid()}
+						fallback={
+							<details class="relative">
+								<summary class={clsx(buttonStyles(), 'cursor-pointer list-none')}>login</summary>
+								<div class="absolute right-0 mt-3 w-72 rounded border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 p-4 shadow-lg z-50">
+									<form onSubmit={onSignIn} class="flex flex-col gap-3">
+										<input
+											value={identifier()}
+											onInput={(event) => setIdentifier(event.currentTarget.value)}
+											placeholder="handle or did"
+											class={inputStyles()}
+										/>
+										<button type="submit" class={clsx(buttonStyles('primary'), 'justify-center')}>
+											continue with OAuth
+										</button>
+										<Show when={auth.error()}>
+											<p class="text-sm text-red-500">{auth.error()}</p>
+										</Show>
+									</form>
+								</div>
+							</details>
+						}
+					>
+						<details class="relative">
+							<summary
+								class="cursor-pointer list-none flex items-center gap-2"
+								onClick={() => live.markRead()}
+							>
+								<div class="relative">
+									<Bell class="size-5 text-gray-500 dark:text-gray-400" />
+									<Show when={live.unread() > 0}>
+										<span class="untangled-unread-badge absolute -top-2 -right-2 min-w-5 h-5 rounded-full bg-blue-600 text-white flex items-center justify-center px-1">
+											{Math.min(live.unread(), 99)}
+										</span>
+									</Show>
+								</div>
+							</summary>
+							<div class="absolute right-0 mt-3 w-80 rounded border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 shadow-lg z-50 overflow-hidden">
+								<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700 font-medium">live activity</div>
+								<div class="max-h-96 overflow-auto">
+									<Show
+										when={live.events().length > 0}
+										fallback={<div class="px-4 py-6 text-sm text-gray-500 dark:text-gray-400">No live events yet.</div>}
+									>
+										<For each={live.events()}>
+											{(event) => (
+												<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700 text-sm">
+													<div class="font-medium break-all">{eventLabel(event)}</div>
+													<div class="text-gray-500 dark:text-gray-400">{formatRelativeTime(event.receivedAt)}</div>
+												</div>
+											)}
+										</For>
+									</Show>
+								</div>
+							</div>
+						</details>
+
+						<details class="relative">
+							<summary class="cursor-pointer list-none flex items-center gap-2">
+								<Avatar did={auth.currentDid()!} size="size-8 md:size-6" />
+								<span class="hidden md:inline">{viewerQuery.data?.handle ?? auth.currentDid()}</span>
+							</summary>
+							<div class="absolute right-0 mt-4 rounded bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 shadow-lg z-50 text-sm w-56">
+								<div class="px-4 py-3 border-b border-gray-200 dark:border-gray-700">
+									<div class="font-medium truncate">{viewerQuery.data?.handle ?? auth.currentDid()}</div>
+									<div class="text-gray-500 dark:text-gray-400 truncate">{auth.currentDid()}</div>
+								</div>
+								<button
+									type="button"
+									class="w-full px-4 py-3 flex items-center gap-2 text-left hover:bg-gray-50 hover:dark:bg-gray-700/50"
+									onClick={() => void auth.signOut()}
+								>
+									<LogOut class="size-4" />
+									logout
+								</button>
+							</div>
+						</details>
+					</Show>
+				</div>
+			</div>
+		</nav>
+	);
+};
+
+export const RootShell: Component<{ children?: JSX.Element }> = (props) => (
+	<div class="min-h-screen flex flex-col gap-4 bg-slate-100 dark:bg-gray-900 dark:text-white">
+		<header class="untangled-safe-header w-full shadow-sm dark:text-white bg-white dark:bg-gray-800" style="z-index: 20;">
+			<Topbar />
+		</header>
+
+		<div class="flex-grow">
+			<div class="untangled-shell mx-auto flex flex-col gap-4">{props.children}</div>
+		</div>
+	</div>
+);
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 332a71e..3beed11 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -1,1416 +1,91 @@
-import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
-import {
-	type ActorResolver,
-	type ResolveActorOptions,
-	type ResolvedActor,
-} from '@atcute/identity-resolver';
-import type {
-	ActorIdentifier,
-	Did,
-	Nsid,
-	ResourceUri,
-} from '@atcute/lexicons/syntax';
-import type { GenericUri } from '@atcute/lexicons/syntax';
-import type { OAuthUserAgent } from '@atcute/oauth-browser-client';
-import {
-	ShTangledActorProfile,
-	ShTangledFeedStar,
-	ShTangledRepo,
-	ShTangledRepoIssue,
-	ShTangledRepoIssueComment,
-	ShTangledRepoIssueState,
-	ShTangledRepoPull,
-	ShTangledRepoPullComment,
-	ShTangledRepoPullStatus,
-} from '@atcute/tangled';
-import { gunzipSync, gzipSync, strFromU8, strToU8 } from 'fflate';
-
-import type {} from '@atcute/atproto';
-import type {} from '@atcute/microcosm';
-import type {} from '@atcute/tangled';
-
-export const PUBLIC_API_SERVICE = 'https://public.api.bsky.app';
-export const CONSTELLATION_SERVICE = 'https://constellation.microcosm.blue';
-export const SLINGSHOT_SERVICE = 'https://slingshot.microcosm.blue';
-export const SPACEDUST_SERVICE = 'wss://spacedust.microcosm.blue/subscribe';
-
-export const TANGLED_OAUTH_SCOPE = import.meta.env.VITE_OAUTH_SCOPE;
-
-const REPO_COLLECTION: Nsid = 'sh.tangled.repo';
-const STAR_COLLECTION: Nsid = 'sh.tangled.feed.star';
-const ACTOR_PROFILE_COLLECTION: Nsid = 'sh.tangled.actor.profile';
-const APP_BSKY_PROFILE_COLLECTION: Nsid = 'app.bsky.actor.profile';
-const ISSUE_COLLECTION: Nsid = 'sh.tangled.repo.issue';
-const ISSUE_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.issue.comment';
-const ISSUE_STATE_COLLECTION: Nsid = 'sh.tangled.repo.issue.state';
-const PULL_COLLECTION: Nsid = 'sh.tangled.repo.pull';
-const PULL_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.pull.comment';
-const PULL_STATUS_COLLECTION: Nsid = 'sh.tangled.repo.pull.status';
-
-class SlingshotActorResolver implements ActorResolver {
-	async resolve(actor: ActorIdentifier, options?: ResolveActorOptions): Promise<ResolvedActor> {
-		const resolved = await ok(
-			getRpc(SLINGSHOT_SERVICE).get('blue.microcosm.identity.resolveMiniDoc', {
-				params: {
-					identifier: actor,
-				},
-				signal: options?.signal,
-			}),
-		);
-
-		return {
-			did: resolved.did,
-			handle: resolved.handle,
-			pds: normalizeServiceUrl(resolved.pds),
-		};
-	}
-}
-
-export const identityResolver = new SlingshotActorResolver();
-
-export interface RepoContext {
-	owner: ResolvedActor;
-	record: RepoRecord;
-	repoDid: Did;
-	slug: string;
-	rkey: string;
-	knot: string;
-}
-
-export interface RepoRecord {
-	uri: ResourceUri;
-	cid: string;
-	rkey: string;
-	value: ShTangledRepo.Main;
-}
-
-export interface HydratedRecord<T> {
-	author: ResolvedActor;
-	collection: Nsid;
-	rkey: string;
-	uri: ResourceUri;
-	cid?: string;
-	value: T;
-}
-
-export interface IssueSummary extends HydratedRecord<ShTangledRepoIssue.Main> {
-	number: number;
-	state: 'open' | 'closed';
-}
-
-export interface PullSummary extends HydratedRecord<ShTangledRepoPull.Main> {
-	number: number;
-	state: 'open' | 'closed' | 'merged';
-}
-
-export interface IssueComment extends HydratedRecord<ShTangledRepoIssueComment.Main> {}
-export interface PullComment extends HydratedRecord<ShTangledRepoPullComment.Main> {}
-
-export interface IssueDetail {
-	issue: IssueSummary;
-	comments: IssueComment[];
-}
-
-export interface PullDetail {
-	pull: PullSummary;
-	comments: PullComment[];
-}
-
-export interface PaginatedResult<T> {
-	items: T[];
-	totalCount?: number;
-	hasNext: boolean;
-}
-
-export interface TreeResponse {
-	ref: string;
-	parent?: string;
-	dotdot?: string;
-	lastCommit?: CommitHeadline;
-	readme?: {
-		contents: string;
-		filename: string;
-	};
-	files: TreeEntry[];
-}
-
-export interface TreeEntry {
-	name: string;
-	mode: string;
-	size: number;
-	last_commit?: CommitHeadline;
-}
-
-export interface CommitHeadline {
-	hash: string;
-	message: string;
-	when: string;
-	author?: {
-		email: string;
-		name: string;
-		when: string;
-	};
-}
-
-export interface BranchResponse {
-	branches: BranchEntry[];
-}
-
-export interface DefaultBranchResponse {
-	name: string;
-	hash?: string;
-	when?: string;
-}
-
-export interface BranchEntry {
-	reference: {
-		name: string;
-		hash: string;
-	};
-	commit?: {
-		Message: string;
-		Author?: {
-			Name: string;
-			Email: string;
-			When: string;
-		};
-		Committer?: {
-			Name: string;
-			Email: string;
-			When: string;
-		};
-	};
-	is_default?: boolean;
-}
-
-export interface TagResponse {
-	tags: Array<{
-		name: string;
-		hash: string;
-		message?: string;
-		tag?: {
-			Name: string;
-			Message: string;
-			Tagger?: {
-				Name: string;
-				Email: string;
-				When: string;
-			};
-		};
-	}>;
-}
-
-export interface LanguageResponse {
-	ref: string;
-	totalFiles?: number;
-	totalSize?: number;
-	languages: Array<{
-		name: string;
-		percentage: number;
-		size: number;
-		color?: string;
-	}>;
-}
-
-export interface LogResponse {
-	ref: string;
-	total: number;
-	page: number;
-	per_page: number;
-	log: boolean;
-	commits: Array<{
-		this: string;
-		message: string;
-		author?: {
-			Name: string;
-			Email: string;
-			When: string;
-		};
-		committer?: {
-			Name: string;
-			Email: string;
-			When: string;
-		};
-		pgp_signature?: string;
-		parent?: string;
-		parent_hashes?: number[][];
-	}>;
-}
-
-export interface BlobResponse {
-	path: string;
-	ref: string;
-	content?: string;
-	encoding?: 'base64' | 'utf-8';
-	fileTooLarge?: boolean;
-	isBinary?: boolean;
-	mimeType?: string;
-	size?: number;
-	lastCommit?: CommitHeadline;
-	submodule?: {
-		name: string;
-		url: string;
-		branch?: string;
-	};
-}
-
-export interface ComparePatch {
-	Title: string;
-	Body: string;
-	Raw: string;
-	SHA: string;
-	Author?: string;
-	Committer?: string;
-	AuthorDate?: string;
-	CommitterDate?: string;
-	SubjectPrefix?: string;
-	RawHeaders?: string;
-	BodyAppendix?: string;
-}
-
-export interface CompareResponse {
-	rev1: string;
-	rev2: string;
-	patch: string;
-	format_patch: ComparePatch[];
-}
-
-export interface CreateIssueInput {
-	title: string;
-	body: string;
-}
-
-export interface CreatePullInput {
-	title: string;
-	body: string;
-	targetBranch: string;
-	sourceBranch: string;
-	patch: string;
-}
-
-export interface RecordCreationResult {
-	uri: ResourceUri;
-	rkey: string;
-}
-
-interface BacklinkRecordRef {
-	did: Did;
-	collection: Nsid;
-	rkey: string;
-}
-
-interface ProfileWithAvatar {
-	avatar?: unknown;
-}
-
-const actorCache = new Map<string, Promise<ResolvedActor>>();
-const rpcCache = new Map<string, Client>();
-
-const normalizeServiceUrl = (input: string): string => {
-	if (input.startsWith('http://') || input.startsWith('https://')) {
-		return input;
-	}
-
-	return `https://${input}`;
-};
-
-const getRpc = (service: string): Client => {
-	const normalized = normalizeServiceUrl(service);
-	const existing = rpcCache.get(normalized);
-	if (existing) {
-		return existing;
-	}
-
-	const client = new Client({
-		handler: simpleFetchHandler({
-			service: normalized,
-		}),
-	});
-
-	rpcCache.set(normalized, client);
-	return client;
-};
-
-export const createAuthRpc = (agent: OAuthUserAgent): Client =>
-	new Client({
-		handler: agent,
-	});
-
-export const resolveActor = async (identifier: string): Promise<ResolvedActor> => {
-	const key = identifier.toLowerCase();
-	const cached = actorCache.get(key);
-	if (cached) {
-		return cached;
-	}
-
-	const promise = identityResolver.resolve(asActorIdentifier(identifier));
-	actorCache.set(key, promise);
-	return promise;
-};
-
-const fetchAllRepoRecords = async (
-	actor: ResolvedActor,
-	collection: Nsid,
-): Promise<Array<{ uri: ResourceUri; cid: string; value: unknown }>> => {
-	const rpc = getRpc(actor.pds);
-	const records: Array<{ uri: ResourceUri; cid: string; value: unknown }> = [];
-	let cursor: string | undefined;
-
-	do {
-		const page = await ok(
-			rpc.get('com.atproto.repo.listRecords', {
-				params: {
-					repo: actor.did,
-					collection,
-					limit: 100,
-					cursor,
-					reverse: true,
-				},
-			}),
-		);
-
-		records.push(...page.records);
-		cursor = page.cursor;
-	} while (cursor);
-
-	return records;
-};
-
-export const listRepoRecords = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => {
-	const actor = typeof owner === 'string' ? await resolveActor(owner) : owner;
-	const records = await fetchAllRepoRecords(actor, REPO_COLLECTION);
-
-	return records.map((record) => ({
-		uri: record.uri,
-		cid: record.cid,
-		rkey: parseAtUri(record.uri).rkey,
-		value: record.value as ShTangledRepo.Main,
-	}));
-};
-
-export interface RepoStarSummary {
-	count: number;
-	isStarred: boolean;
-	currentUserStarRkey?: string;
-}
-
-const STAR_BACKLINK_SOURCES = [
-	'sh.tangled.feed.star:subject.did',
-	'sh.tangled.feed.star:subjectDid',
-];
-
-export const getRepoStarSummary = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => {
-	const starrers = new Set<Did>();
-	const backlinkDidGroups = await Promise.all(STAR_BACKLINK_SOURCES.map((source) => getBacklinkDids(repo.repoDid, source)));
-
-	for (const did of backlinkDidGroups.flat()) {
-		starrers.add(did);
-	}
-
-	const currentUserStar =
-		viewerDid && starrers.has(viewerDid)
-			? await findBacklinkRefByDid(repo.repoDid, STAR_BACKLINK_SOURCES, viewerDid)
-			: undefined;
-
-	return {
-		count: starrers.size,
-		isStarred: !!currentUserStar,
-		currentUserStarRkey: currentUserStar?.rkey,
-	};
-};
-
-export const getRepoStarCount = async (repo: RepoContext): Promise<number> => {
-	const summary = await getRepoStarSummary(repo);
-	return summary.count;
-};
-
-export const createRepoStar = async (agent: OAuthUserAgent, repo: RepoContext): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledFeedStar.Main = {
-		$type: 'sh.tangled.feed.star',
-		subject: {
-			$type: 'sh.tangled.feed.star#repo',
-			did: repo.repoDid,
-		},
-		createdAt: new Date().toISOString(),
-	};
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: STAR_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const deleteRepoStar = async (agent: OAuthUserAgent, rkey: string): Promise<void> => {
-	const rpc = createAuthRpc(agent);
-	await ok(
-		rpc.post('com.atproto.repo.deleteRecord', {
-			input: {
-				repo: agent.sub,
-				collection: STAR_COLLECTION,
-				rkey,
-			},
-		}),
-	);
-};
-
-export const getRepo = async (ownerIdentifier: string, repoSlug: string): Promise<RepoContext> => {
-	const owner = await resolveActor(ownerIdentifier);
-	const all = await listRepoRecords(owner);
-	const wanted = repoSlug.trim().toLowerCase();
-	const match = all.find((record) => {
-		const name = record.value.name?.trim().toLowerCase();
-		return name === wanted || record.rkey.toLowerCase() === wanted;
-	});
-
-	if (!match) {
-		throw new Error(`Repository not found: ${ownerIdentifier}/${repoSlug}`);
-	}
-
-	if (!match.value.repoDid) {
-		throw new Error(`Repository is missing repoDid metadata`);
-	}
-
-	const slug = match.value.name?.trim() || match.rkey;
-
-	return {
-		owner,
-		record: match,
-		repoDid: match.value.repoDid,
-		slug,
-		rkey: match.rkey,
-		knot: normalizeServiceUrl(match.value.knot),
-	};
-};
-
-export const getRepoTree = async (
-	repo: RepoContext,
-	ref: string,
-	path = '',
-): Promise<TreeResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.tree', {
-			params: {
-				repo: repo.repoDid,
-				ref,
-				path,
-			},
-		}),
-	)) as TreeResponse;
-
-export const getRepoBranches = async (repo: RepoContext): Promise<BranchResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.branches', {
-			params: {
-				repo: repo.repoDid,
-			},
-			as: 'json',
-		}),
-	)) as BranchResponse;
-
-export const getRepoDefaultBranch = async (repo: RepoContext): Promise<DefaultBranchResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.getDefaultBranch', {
-			params: {
-				repo: repo.repoDid,
-			},
-		}),
-	)) as DefaultBranchResponse;
-
-export const getRepoTags = async (repo: RepoContext): Promise<TagResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.tags', {
-			params: {
-				repo: repo.repoDid,
-			},
-			as: 'json',
-		}),
-	)) as TagResponse;
-
-export const getRepoLanguages = async (repo: RepoContext, ref: string): Promise<LanguageResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.languages', {
-			params: {
-				repo: repo.repoDid,
-				ref,
-			},
-		}),
-	)) as LanguageResponse;
-
-export const getRepoLog = async (repo: RepoContext, ref: string): Promise<LogResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.log', {
-			params: {
-				repo: repo.repoDid,
-				ref,
-				limit: 8,
-			},
-			as: 'json',
-		}),
-	)) as LogResponse;
-
-export const getRepoBlob = async (
-	repo: RepoContext,
-	ref: string,
-	path: string,
-): Promise<BlobResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.blob', {
-			params: {
-				repo: repo.repoDid,
-				ref,
-				path,
-			},
-		}),
-	)) as BlobResponse;
-
-export const compareBranches = async (
-	repo: RepoContext,
-	rev1: string,
-	rev2: string,
-): Promise<CompareResponse> =>
-	(await ok(
-		getRpc(repo.knot).get('sh.tangled.repo.compare', {
-			params: {
-				repo: repo.repoDid,
-				rev1,
-				rev2,
-			},
-			as: 'json',
-		}),
-	)) as CompareResponse;
-
-const getBacklinksPage = async (
-	subject: GenericUri,
-	source: string,
-	limit: number,
-	cursor?: string,
-): Promise<{ records: BacklinkRecordRef[]; cursor?: string; total?: number }> => {
-	const constellation = getRpc(CONSTELLATION_SERVICE);
-	const page = await ok(
-		constellation.get('blue.microcosm.links.getBacklinks', {
-			params: {
-				subject,
-				source,
-				limit,
-				...(cursor ? { cursor } : {}),
-			},
-		}),
-	);
-
-	return page as { records: BacklinkRecordRef[]; cursor?: string; total?: number };
-};
-
-const getBacklinkDidsPage = async (
-	subject: GenericUri,
-	source: string,
-	limit: number,
-	cursor?: string,
-): Promise<{ linking_dids: Did[]; cursor?: string | null; total?: number }> => {
-	const constellation = getRpc(CONSTELLATION_SERVICE);
-	const page = await ok(
-		constellation.get('blue.microcosm.links.getBacklinkDids', {
-			params: {
-				subject,
-				source,
-				limit,
-				...(cursor ? { cursor } : {}),
-			},
-		}),
-	);
-
-	return page as { linking_dids: Did[]; cursor?: string | null; total?: number };
-};
-
-const getBacklinkDids = async (subject: GenericUri, source: string): Promise<Did[]> => {
-	const dids: Did[] = [];
-	let cursor: string | null = null;
-
-	do {
-		const page = await getBacklinkDidsPage(subject, source, 100, cursor ?? undefined);
-		dids.push(...page.linking_dids);
-		cursor = page.cursor ?? null;
-	} while (cursor);
-
-	return dids;
-};
-
-const findBacklinkRefByDidForSource = async (
-	subject: GenericUri,
-	source: string,
-	did: Did,
-): Promise<BacklinkRecordRef | undefined> => {
-	let cursor: string | null = null;
-
-	do {
-		const page = await getBacklinksPage(subject, source, 100, cursor ?? undefined);
-		const ref = page.records.find((record) => record.did === did && record.collection === STAR_COLLECTION);
-		if (ref) {
-			return ref;
-		}
-		cursor = page.cursor ?? null;
-	} while (cursor);
-};
-
-const findBacklinkRefByDid = async (
-	subject: GenericUri,
-	sources: string[],
-	did: Did,
-): Promise<BacklinkRecordRef | undefined> => {
-	const refs = await Promise.all(sources.map((source) => findBacklinkRefByDidForSource(subject, source, did)));
-	return refs.find((ref) => ref);
-};
-
-const getBacklinks = async (subject: GenericUri, source: string): Promise<BacklinkRecordRef[]> => {
-	const records: BacklinkRecordRef[] = [];
-	let cursor: string | null = null;
-	const constellation = getRpc(CONSTELLATION_SERVICE);
-
-	do {
-		const page: { records: BacklinkRecordRef[]; cursor?: string | null } = await ok(
-			constellation.get('blue.microcosm.links.getBacklinks', {
-				params: {
-					subject,
-					source,
-					limit: 100,
-					...(cursor ? { cursor } : {}),
-				},
-			}),
-		);
-		records.push(...page.records);
-		cursor = page.cursor ?? null;
-	} while (cursor);
-
-	return records;
-};
-
-const hydrateRecord = async <T>(
-	ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string },
-): Promise<HydratedRecord<T>> => {
-	const actor = await resolveActor(ref.did);
-	const record = await ok(
-		getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
-			params: {
-				repo: ref.did,
-				collection: ref.collection,
-				rkey: ref.rkey,
-			},
-		}),
-	);
-
-	return {
-		author: actor,
-		collection: ref.collection,
-		rkey: ref.rkey,
-		uri: record.uri,
-		cid: record.cid,
-		value: record.value as T,
-	};
-};
-
-const fetchRecordValue = async <T>(
-	ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string },
-): Promise<T> => {
-	const record = await ok(
-		getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
-			params: {
-				repo: ref.did,
-				collection: ref.collection,
-				rkey: ref.rkey,
-			},
-		}),
-	);
-
-	return record.value as T;
-};
-
-const hydrateBacklinks = async <T>(refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<T>>> =>
-	Promise.all(refs.map((ref) => hydrateRecord<T>(ref)));
-
-const getOptionalRecord = async <T>(
-	actor: ResolvedActor,
-	collection: Nsid,
-	rkey: string,
-): Promise<T | null> => {
-	try {
-		const record = await ok(
-			getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
-				params: {
-					repo: actor.did,
-					collection,
-					rkey,
-				},
-			}),
-		);
-
-		return record.value as T;
-	} catch (cause) {
-		if (
-			cause instanceof ClientResponseError &&
-			(cause.status === 400 || cause.status === 404)
-		) {
-			return null;
-		}
-
-		throw cause;
-	}
-};
-
-const toNumberMap = <T extends { uri: string; rkey: string; value: { createdAt?: string } }>(
-	items: T[],
-): Map<string, number> => {
-	const ordered = [...items].sort((left, right) => {
-		const leftTime = left.value.createdAt ? new Date(left.value.createdAt).getTime() : 0;
-		const rightTime = right.value.createdAt ? new Date(right.value.createdAt).getTime() : 0;
-		if (leftTime !== rightTime) {
-			return leftTime - rightTime;
-		}
-
-		return left.rkey.localeCompare(right.rkey);
-	});
-
-	return new Map(ordered.map((item, index) => [item.uri, index + 1]));
-};
-
-const normalizeIssueState = (value?: string): 'open' | 'closed' =>
-	value?.endsWith('.closed') ? 'closed' : 'open';
-
-const normalizePullStatus = (value?: string): 'open' | 'closed' | 'merged' => {
-	if (value?.endsWith('.merged')) {
-		return 'merged';
-	}
-
-	if (value?.endsWith('.closed')) {
-		return 'closed';
-	}
-
-	return 'open';
-};
-
-const latestBacklinkRefByRkey = (refs: BacklinkRecordRef[]): BacklinkRecordRef | undefined =>
-	[...refs].sort((left, right) => left.rkey.localeCompare(right.rkey)).at(-1);
-
-const BACKLINK_BATCH_LIMIT = 50;
-
-const listBacklinkedRecordsPage = async <T extends { createdAt?: string }, State extends string>(
-	subject: GenericUri,
-	source: string | string[],
-	options: { offset: number; limit: number; state: State },
-	getState: (uri: ResourceUri) => Promise<State>,
-): Promise<PaginatedResult<HydratedRecord<T> & { number: number; state: State }>> => {
-	const requestedEnd = options.offset + options.limit;
-	const items: Array<HydratedRecord<T> & { number: number; state: State }> = [];
-	const sources = Array.isArray(source) ? source : [source];
-	const batchLimit = Math.min(BACKLINK_BATCH_LIMIT, Math.max(options.limit + 1, 1));
-	const cursors = new Map(sources.map((entry) => [entry, undefined as string | undefined]));
-	const exhausted = new Set<string>();
-	const seenRefs = new Set<string>();
-	let matchingSeen = 0;
-	let scannedSeen = 0;
-	let total: number | undefined;
-
-	while (items.length <= options.limit) {
-		const pages = await Promise.all(
-			sources
-				.filter((entry) => !exhausted.has(entry))
-				.map(async (entry) => ({
-					source: entry,
-					page: await getBacklinksPage(subject, entry, batchLimit, cursors.get(entry)),
-				})),
-		);
-
-		if (pages.length === 0) {
-			return { items, totalCount: matchingSeen, hasNext: false };
-		}
-
-		const refs = pages
-			.flatMap(({ source: entry, page }) => {
-				total = sources.length === 1 ? page.total ?? total : undefined;
-				cursors.set(entry, page.cursor);
-				if (!page.cursor) {
-					exhausted.add(entry);
-				}
-				return page.records;
-			})
-			.filter((ref) => {
-				const key = `${ref.did}/${ref.collection}/${ref.rkey}`;
-				if (seenRefs.has(key)) {
-					return false;
-				}
-				seenRefs.add(key);
-				return true;
-			});
-
-		if (refs.length === 0) {
-			if (exhausted.size === sources.length) {
-				return { items, totalCount: matchingSeen, hasNext: false };
-			}
-			continue;
-		}
-
-		if (pages.every(({ page }) => page.records.length === 0)) {
-			return { items, totalCount: matchingSeen, hasNext: false };
-		}
-
-		const hydrated = await hydrateBacklinks<T>(refs);
-		hydrated.sort(sortByCreatedAt).reverse();
-		const states = await Promise.all(hydrated.map((record) => getState(record.uri)));
-
-		for (let index = 0; index < hydrated.length; index += 1) {
-			const record = hydrated[index];
-			const state = states[index];
-			const number = total ? Math.max(total - scannedSeen, 1) : scannedSeen + 1;
-			scannedSeen += 1;
-
-			if (state !== options.state) {
-				continue;
-			}
-
-			if (matchingSeen >= options.offset && matchingSeen < requestedEnd + 1) {
-				items.push({ ...record, number, state });
-			}
-
-			matchingSeen += 1;
-			if (matchingSeen > requestedEnd) {
-				return { items: items.slice(0, options.limit), hasNext: true };
-			}
-		}
-
-		if (exhausted.size === sources.length) {
-			return { items, totalCount: matchingSeen, hasNext: false };
-		}
-	}
-
-	return { items: items.slice(0, options.limit), hasNext: true };
-};
-
-const getLatestIssueState = async (issueUri: ResourceUri): Promise<'open' | 'closed'> => {
-	const refs = await getBacklinks(issueUri, 'sh.tangled.repo.issue.state:issue');
-	if (refs.length === 0) {
-		return 'open';
-	}
-
-	const state = await fetchRecordValue<ShTangledRepoIssueState.Main>(latestBacklinkRefByRkey(refs)!);
-	return normalizeIssueState(state.state);
-};
-
-const getLatestPullStatus = async (pullUri: ResourceUri): Promise<'open' | 'closed' | 'merged'> => {
-	const refs = await getBacklinks(pullUri, 'sh.tangled.repo.pull.status:pull');
-	if (refs.length === 0) {
-		return 'open';
-	}
-
-	const status = await fetchRecordValue<ShTangledRepoPullStatus.Main>(latestBacklinkRefByRkey(refs)!);
-	return normalizePullStatus(status.status);
-};
-
-export const listIssues = async (repo: RepoContext): Promise<IssueSummary[]> => {
-	const refs = Array.from(
-		new Map(
-			(
-				await Promise.all([
-					getBacklinks(repo.repoDid, 'sh.tangled.repo.issue:repoDid'),
-					getBacklinks(repo.repoDid, 'sh.tangled.repo.issue:repo'),
-				])
-			)
-				.flat()
-				.map((ref) => [`${ref.did}/${ref.collection}/${ref.rkey}`, ref] as const),
-		).values(),
-	);
-	const issues = await hydrateBacklinks<ShTangledRepoIssue.Main>(refs);
-	const numbers = toNumberMap(issues);
-	const states = await Promise.all(issues.map((issue) => getLatestIssueState(issue.uri)));
-
-	return issues
-		.map((issue, index) => ({
-			...issue,
-			number: numbers.get(issue.uri) ?? index + 1,
-			state: states[index],
-		}))
-		.sort((left, right) => right.number - left.number);
-};
-
-export const listIssuesPage = async (
-	repo: RepoContext,
-	options: { offset: number; limit: number; state: 'open' | 'closed' },
-): Promise<PaginatedResult<IssueSummary>> =>
-	listBacklinkedRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>(
-		repo.repoDid,
-		['sh.tangled.repo.issue:repoDid', 'sh.tangled.repo.issue:repo'],
-		options,
-		getLatestIssueState,
-	);
-
-export const getIssue = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => {
-	const issues = await listIssues(repo);
-	const issue = findNumberedRecord(issues, issueRef);
-	if (!issue) {
-		throw new Error(`Issue not found`);
-	}
-
-	const commentRefs = await getBacklinks(issue.uri, 'sh.tangled.repo.issue.comment:issue');
-	const comments = await hydrateBacklinks<ShTangledRepoIssueComment.Main>(commentRefs);
-	comments.sort(sortByCreatedAt);
-
-	return {
-		issue,
-		comments,
-	};
-};
-
-export const listPulls = async (repo: RepoContext): Promise<PullSummary[]> => {
-	const refs = await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo');
-	const pulls = await hydrateBacklinks<ShTangledRepoPull.Main>(refs);
-	const numbers = toNumberMap(pulls);
-	const states = await Promise.all(pulls.map((pull) => getLatestPullStatus(pull.uri)));
-
-	return pulls
-		.map((pull, index) => ({
-			...pull,
-			number: numbers.get(pull.uri) ?? index + 1,
-			state: states[index],
-		}))
-		.sort((left, right) => right.number - left.number);
-};
-
-export const listPullsPage = async (
-	repo: RepoContext,
-	options: { offset: number; limit: number; state: 'open' | 'closed' | 'merged' },
-): Promise<PaginatedResult<PullSummary>> =>
-	listBacklinkedRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>(
-		repo.repoDid,
-		'sh.tangled.repo.pull:target.repo',
-		options,
-		getLatestPullStatus,
-	);
-
-export const getPull = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => {
-	const pulls = await listPulls(repo);
-	const pull = findNumberedRecord(pulls, pullRef);
-	if (!pull) {
-		throw new Error(`Pull request not found`);
-	}
-
-	const commentRefs = await getBacklinks(pull.uri, 'sh.tangled.repo.pull.comment:pull');
-	const comments = await hydrateBacklinks<ShTangledRepoPullComment.Main>(commentRefs);
-	comments.sort(sortByCreatedAt);
-
-	return {
-		pull,
-		comments,
-	};
-};
-
-export const fetchPullRoundPatch = async (
-	pull: PullSummary,
-	roundIndex: number,
-): Promise<string> => {
-	const round = pull.value.rounds[roundIndex];
-	if (!round) {
-		throw new Error(`Round ${roundIndex + 1} not found`);
-	}
-
-	const cid = extractBlobCid(round.patchBlob);
-	if (!cid) {
-		throw new Error(`Missing patch blob CID`);
-	}
-
-	const rpc = getRpc(pull.author.pds);
-	const bytes = await ok(
-		rpc.get('com.atproto.sync.getBlob', {
-			params: {
-				did: pull.author.did,
-				cid,
-			},
-			as: 'bytes',
-		}),
-	);
-
-	return strFromU8(gunzipSync(bytes));
-};
-
-export const createIssue = async (
-	agent: OAuthUserAgent,
-	repo: RepoContext,
-	input: CreateIssueInput,
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledRepoIssue.Main = {
-		$type: 'sh.tangled.repo.issue',
-		repo: repo.repoDid,
-		title: input.title.trim(),
-		body: optionalString(input.body),
-		createdAt: new Date().toISOString(),
-		mentions: extractDids(input.body),
-		references: extractAtUris(input.body),
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: ISSUE_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const createIssueComment = async (
-	agent: OAuthUserAgent,
-	issueUri: ResourceUri,
-	body: string,
-	replyTo?: ResourceUri,
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledRepoIssueComment.Main = {
-		$type: 'sh.tangled.repo.issue.comment',
-		issue: issueUri,
-		body: body.trim(),
-		createdAt: new Date().toISOString(),
-		mentions: extractDids(body),
-		references: extractAtUris(body),
-		...(replyTo ? { replyTo } : {}),
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: ISSUE_COMMENT_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const setIssueState = async (
-	agent: OAuthUserAgent,
-	issueUri: ResourceUri,
-	state: 'open' | 'closed',
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledRepoIssueState.Main = {
-		$type: 'sh.tangled.repo.issue.state',
-		issue: issueUri,
-		state:
-			state === 'closed'
-				? 'sh.tangled.repo.issue.state.closed'
-				: 'sh.tangled.repo.issue.state.open',
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: ISSUE_STATE_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const createPull = async (
-	agent: OAuthUserAgent,
-	repo: RepoContext,
-	input: CreatePullInput,
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const patchBytes = new Uint8Array(gzipSync(strToU8(input.patch)));
-	const patchBlob = new Blob([patchBytes.buffer], {
-		type: 'application/gzip',
-	});
-
-	const uploaded = await ok(
-		rpc.post('com.atproto.repo.uploadBlob', {
-			input: patchBlob,
-		}),
-	);
-
-	const record: ShTangledRepoPull.Main = {
-		$type: 'sh.tangled.repo.pull',
-		title: input.title.trim(),
-		body: optionalString(input.body),
-		target: {
-			repo: repo.repoDid,
-			branch: input.targetBranch,
-		},
-		source: {
-			branch: input.sourceBranch,
-		},
-		rounds: [
-			{
-				createdAt: new Date().toISOString(),
-				patchBlob: uploaded.blob,
-			},
-		],
-		createdAt: new Date().toISOString(),
-		mentions: extractDids(input.body),
-		references: extractAtUris(input.body),
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: PULL_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const createPullComment = async (
-	agent: OAuthUserAgent,
-	pullUri: ResourceUri,
-	body: string,
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledRepoPullComment.Main = {
-		$type: 'sh.tangled.repo.pull.comment',
-		pull: pullUri,
-		body: body.trim(),
-		createdAt: new Date().toISOString(),
-		mentions: extractDids(body),
-		references: extractAtUris(body),
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: PULL_COMMENT_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const setPullStatus = async (
-	agent: OAuthUserAgent,
-	pullUri: ResourceUri,
-	status: 'open' | 'closed' | 'merged',
-): Promise<RecordCreationResult> => {
-	const rpc = createAuthRpc(agent);
-	const record: ShTangledRepoPullStatus.Main = {
-		$type: 'sh.tangled.repo.pull.status',
-		pull: pullUri,
-		status:
-			status === 'merged'
-				? 'sh.tangled.repo.pull.status.merged'
-				: status === 'closed'
-					? 'sh.tangled.repo.pull.status.closed'
-					: 'sh.tangled.repo.pull.status.open',
-	};
-
-	const result = await ok(
-		rpc.post('com.atproto.repo.createRecord', {
-			input: {
-				repo: agent.sub,
-				collection: PULL_STATUS_COLLECTION,
-				record,
-			},
-		}),
-	);
-
-	return {
-		uri: result.uri,
-		rkey: parseAtUri(result.uri).rkey,
-	};
-};
-
-export const decodeBlobText = (blob: BlobResponse): string => {
-	if (!blob.content) {
-		return '';
-	}
-
-	if (blob.encoding === 'base64') {
-		const buffer = Uint8Array.from(atob(blob.content), (char) => char.charCodeAt(0));
-		return new TextDecoder().decode(buffer);
-	}
-
-	return blob.content;
-};
-
-export const buildBlobDataUrl = (blob: BlobResponse): string | null => {
-	if (!blob.content || !blob.mimeType) {
-		return null;
-	}
-
-	if (blob.encoding === 'base64') {
-		return `data:${blob.mimeType};base64,${blob.content}`;
-	}
-
-	return `data:${blob.mimeType};charset=utf-8,${encodeURIComponent(blob.content)}`;
-};
-
-export const resolveAvatarUrl = async (identifier: string): Promise<string | null> => {
-	const actor = await resolveActor(identifier);
-	const tangledProfile = await getOptionalRecord<ShTangledActorProfile.Main>(
-		actor,
-		ACTOR_PROFILE_COLLECTION,
-		'self',
-	);
-	const tangledCid = extractBlobCid(tangledProfile?.avatar);
-	if (tangledCid) {
-		return buildPdsBlobUrl(actor.pds, actor.did, tangledCid);
-	}
-
-	const bskyProfile = await getOptionalRecord<ProfileWithAvatar>(
-		actor,
-		APP_BSKY_PROFILE_COLLECTION,
-		'self',
-	);
-	const bskyCid = extractBlobCid(bskyProfile?.avatar);
-	if (bskyCid) {
-		return buildPdsBlobUrl(actor.pds, actor.did, bskyCid);
-	}
-
-	return null;
-};
-
-export const parseAtUri = (uri: string): { did: Did; collection: Nsid; rkey: string } => {
-	if (!uri.startsWith('at://')) {
-		throw new Error(`Invalid at-uri: ${uri}`);
-	}
-
-	const parts = uri.slice(5).split('/');
-	const [did, collection, ...rkey] = parts;
-	return {
-		did: asDid(did),
-		collection: asNsid(collection),
-		rkey: rkey.join('/'),
-	};
-};
-
-export const extractBlobCid = (blob: unknown): string | null => {
-	if (!blob || typeof blob !== 'object') {
-		return null;
-	}
-
-	const value = blob as Record<string, unknown>;
-	const ref = value.ref;
-
-	if (typeof ref === 'string') {
-		return ref;
-	}
-
-	if (ref && typeof ref === 'object') {
-		const maybeLink = (ref as Record<string, unknown>).$link;
-		if (typeof maybeLink === 'string') {
-			return maybeLink;
-		}
-	}
-
-	const maybeCid = value.cid;
-	return typeof maybeCid === 'string' ? maybeCid : null;
-};
-
-const findNumberedRecord = <T extends { number: number; rkey: string; uri: string }>(
-	records: T[],
-	ref: string,
-): T | undefined => {
-	const trimmed = ref.trim();
-	if (/^\d+$/.test(trimmed)) {
-		const number = Number(trimmed);
-		return records.find((record) => record.number === number);
-	}
-
-	return records.find(
-		(record) =>
-			record.rkey === trimmed ||
-			record.uri === trimmed ||
-			parseAtUri(record.uri).rkey === trimmed,
-	);
-};
-
-const optionalString = (value: string): string | undefined => {
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : undefined;
-};
-
-const uniq = <T extends string>(values: T[]): T[] | undefined => {
-	if (values.length === 0) {
-		return undefined;
-	}
-
-	return [...new Set(values)];
-};
-
-const extractDids = (input: string): Did[] | undefined =>
-	uniq(
-		Array.from(
-			input.matchAll(/\bdid:[a-z0-9]+:[A-Za-z0-9._:%-]+\b/gi),
-			(match) => match[0] as Did,
-		),
-	);
-
-const extractAtUris = (input: string): ResourceUri[] | undefined =>
-	uniq(
-		Array.from(
-			input.matchAll(/\bat:\/\/[^\s<>()]+/gi),
-			(match) => match[0] as ResourceUri,
-		),
-	);
-
-const sortByCreatedAt = <T extends { value: { createdAt?: string } }>(left: T, right: T): number =>
-	new Date(left.value.createdAt ?? 0).getTime() - new Date(right.value.createdAt ?? 0).getTime();
-
-const asActorIdentifier = (value: string): ActorIdentifier => value as ActorIdentifier;
-
-const asDid = (value: string): Did => {
-	if (!value.startsWith('did:')) {
-		throw new Error(`Invalid DID: ${value}`);
-	}
-
-	return value as Did;
-};
-
-const asNsid = (value: string): Nsid => {
-	if (value.split('.').length < 3) {
-		throw new Error(`Invalid NSID: ${value}`);
-	}
-
-	return value as Nsid;
-};
-
-const buildPdsBlobUrl = (pds: string, did: Did, cid: string): string => {
-	const url = new URL('/xrpc/com.atproto.sync.getBlob', normalizeServiceUrl(pds));
-	url.searchParams.set('did', did);
-	url.searchParams.set('cid', cid);
-	return url.toString();
-};
+export {
+	CONSTELLATION_SERVICE,
+	PUBLIC_API_SERVICE,
+	SLINGSHOT_SERVICE,
+	SPACEDUST_SERVICE,
+	TANGLED_OAUTH_SCOPE,
+} from './api/constants';
+export {
+	createAuthRpc,
+	identityResolver,
+	resolveActor,
+	resolveAvatarUrl,
+} from './api/identity';
+export {
+	extractBlobCid,
+	parseAtUri,
+} from './api/records';
+export {
+	buildBlobDataUrl,
+	compareBranches,
+	decodeBlobText,
+	getRepo,
+	getRepoBlob,
+	getRepoBranches,
+	getRepoDefaultBranch,
+	getRepoLanguages,
+	getRepoLog,
+	getRepoTags,
+	getRepoTree,
+	listRepoRecords,
+} from './api/repos';
+export {
+	createRepoStar,
+	deleteRepoStar,
+	getRepoStarCount,
+	getRepoStarSummary,
+} from './api/stars';
+export {
+	createIssue,
+	createIssueComment,
+	getIssue,
+	listIssues,
+	listIssuesPage,
+	setIssueState,
+} from './api/issues';
+export {
+	createPull,
+	createPullComment,
+	fetchPullRoundPatch,
+	getPull,
+	listPulls,
+	listPullsPage,
+	setPullStatus,
+} from './api/pulls';
+
+export type {
+	HydratedRecord,
+	PaginatedResult,
+	RecordCreationResult,
+} from './api/records';
+export type {
+	BlobResponse,
+	BranchEntry,
+	BranchResponse,
+	CommitHeadline,
+	ComparePatch,
+	CompareResponse,
+	DefaultBranchResponse,
+	LanguageResponse,
+	LogResponse,
+	RepoContext,
+	RepoRecord,
+	TagResponse,
+	TreeEntry,
+	TreeResponse,
+} from './api/repos';
+export type {
+	RepoStarSummary,
+} from './api/stars';
+export type {
+	CreateIssueInput,
+	IssueComment,
+	IssueDetail,
+	IssueSummary,
+} from './api/issues';
+export type {
+	CreatePullInput,
+	PullComment,
+	PullDetail,
+	PullSummary,
+} from './api/pulls';
diff --git a/src/lib/api/constants.ts b/src/lib/api/constants.ts
new file mode 100644
index 0000000..ab0f4d4
--- /dev/null
+++ b/src/lib/api/constants.ts
@@ -0,0 +1,7 @@
+export {
+	CONSTELLATION_SERVICE,
+	PUBLIC_API_SERVICE,
+	SLINGSHOT_SERVICE,
+	SPACEDUST_SERVICE,
+	TANGLED_OAUTH_SCOPE,
+} from './core';
diff --git a/src/lib/api/core.ts b/src/lib/api/core.ts
new file mode 100644
index 0000000..332a71e
--- /dev/null
+++ b/src/lib/api/core.ts
@@ -0,0 +1,1416 @@
+import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
+import {
+	type ActorResolver,
+	type ResolveActorOptions,
+	type ResolvedActor,
+} from '@atcute/identity-resolver';
+import type {
+	ActorIdentifier,
+	Did,
+	Nsid,
+	ResourceUri,
+} from '@atcute/lexicons/syntax';
+import type { GenericUri } from '@atcute/lexicons/syntax';
+import type { OAuthUserAgent } from '@atcute/oauth-browser-client';
+import {
+	ShTangledActorProfile,
+	ShTangledFeedStar,
+	ShTangledRepo,
+	ShTangledRepoIssue,
+	ShTangledRepoIssueComment,
+	ShTangledRepoIssueState,
+	ShTangledRepoPull,
+	ShTangledRepoPullComment,
+	ShTangledRepoPullStatus,
+} from '@atcute/tangled';
+import { gunzipSync, gzipSync, strFromU8, strToU8 } from 'fflate';
+
+import type {} from '@atcute/atproto';
+import type {} from '@atcute/microcosm';
+import type {} from '@atcute/tangled';
+
+export const PUBLIC_API_SERVICE = 'https://public.api.bsky.app';
+export const CONSTELLATION_SERVICE = 'https://constellation.microcosm.blue';
+export const SLINGSHOT_SERVICE = 'https://slingshot.microcosm.blue';
+export const SPACEDUST_SERVICE = 'wss://spacedust.microcosm.blue/subscribe';
+
+export const TANGLED_OAUTH_SCOPE = import.meta.env.VITE_OAUTH_SCOPE;
+
+const REPO_COLLECTION: Nsid = 'sh.tangled.repo';
+const STAR_COLLECTION: Nsid = 'sh.tangled.feed.star';
+const ACTOR_PROFILE_COLLECTION: Nsid = 'sh.tangled.actor.profile';
+const APP_BSKY_PROFILE_COLLECTION: Nsid = 'app.bsky.actor.profile';
+const ISSUE_COLLECTION: Nsid = 'sh.tangled.repo.issue';
+const ISSUE_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.issue.comment';
+const ISSUE_STATE_COLLECTION: Nsid = 'sh.tangled.repo.issue.state';
+const PULL_COLLECTION: Nsid = 'sh.tangled.repo.pull';
+const PULL_COMMENT_COLLECTION: Nsid = 'sh.tangled.repo.pull.comment';
+const PULL_STATUS_COLLECTION: Nsid = 'sh.tangled.repo.pull.status';
+
+class SlingshotActorResolver implements ActorResolver {
+	async resolve(actor: ActorIdentifier, options?: ResolveActorOptions): Promise<ResolvedActor> {
+		const resolved = await ok(
+			getRpc(SLINGSHOT_SERVICE).get('blue.microcosm.identity.resolveMiniDoc', {
+				params: {
+					identifier: actor,
+				},
+				signal: options?.signal,
+			}),
+		);
+
+		return {
+			did: resolved.did,
+			handle: resolved.handle,
+			pds: normalizeServiceUrl(resolved.pds),
+		};
+	}
+}
+
+export const identityResolver = new SlingshotActorResolver();
+
+export interface RepoContext {
+	owner: ResolvedActor;
+	record: RepoRecord;
+	repoDid: Did;
+	slug: string;
+	rkey: string;
+	knot: string;
+}
+
+export interface RepoRecord {
+	uri: ResourceUri;
+	cid: string;
+	rkey: string;
+	value: ShTangledRepo.Main;
+}
+
+export interface HydratedRecord<T> {
+	author: ResolvedActor;
+	collection: Nsid;
+	rkey: string;
+	uri: ResourceUri;
+	cid?: string;
+	value: T;
+}
+
+export interface IssueSummary extends HydratedRecord<ShTangledRepoIssue.Main> {
+	number: number;
+	state: 'open' | 'closed';
+}
+
+export interface PullSummary extends HydratedRecord<ShTangledRepoPull.Main> {
+	number: number;
+	state: 'open' | 'closed' | 'merged';
+}
+
+export interface IssueComment extends HydratedRecord<ShTangledRepoIssueComment.Main> {}
+export interface PullComment extends HydratedRecord<ShTangledRepoPullComment.Main> {}
+
+export interface IssueDetail {
+	issue: IssueSummary;
+	comments: IssueComment[];
+}
+
+export interface PullDetail {
+	pull: PullSummary;
+	comments: PullComment[];
+}
+
+export interface PaginatedResult<T> {
+	items: T[];
+	totalCount?: number;
+	hasNext: boolean;
+}
+
+export interface TreeResponse {
+	ref: string;
+	parent?: string;
+	dotdot?: string;
+	lastCommit?: CommitHeadline;
+	readme?: {
+		contents: string;
+		filename: string;
+	};
+	files: TreeEntry[];
+}
+
+export interface TreeEntry {
+	name: string;
+	mode: string;
+	size: number;
+	last_commit?: CommitHeadline;
+}
+
+export interface CommitHeadline {
+	hash: string;
+	message: string;
+	when: string;
+	author?: {
+		email: string;
+		name: string;
+		when: string;
+	};
+}
+
+export interface BranchResponse {
+	branches: BranchEntry[];
+}
+
+export interface DefaultBranchResponse {
+	name: string;
+	hash?: string;
+	when?: string;
+}
+
+export interface BranchEntry {
+	reference: {
+		name: string;
+		hash: string;
+	};
+	commit?: {
+		Message: string;
+		Author?: {
+			Name: string;
+			Email: string;
+			When: string;
+		};
+		Committer?: {
+			Name: string;
+			Email: string;
+			When: string;
+		};
+	};
+	is_default?: boolean;
+}
+
+export interface TagResponse {
+	tags: Array<{
+		name: string;
+		hash: string;
+		message?: string;
+		tag?: {
+			Name: string;
+			Message: string;
+			Tagger?: {
+				Name: string;
+				Email: string;
+				When: string;
+			};
+		};
+	}>;
+}
+
+export interface LanguageResponse {
+	ref: string;
+	totalFiles?: number;
+	totalSize?: number;
+	languages: Array<{
+		name: string;
+		percentage: number;
+		size: number;
+		color?: string;
+	}>;
+}
+
+export interface LogResponse {
+	ref: string;
+	total: number;
+	page: number;
+	per_page: number;
+	log: boolean;
+	commits: Array<{
+		this: string;
+		message: string;
+		author?: {
+			Name: string;
+			Email: string;
+			When: string;
+		};
+		committer?: {
+			Name: string;
+			Email: string;
+			When: string;
+		};
+		pgp_signature?: string;
+		parent?: string;
+		parent_hashes?: number[][];
+	}>;
+}
+
+export interface BlobResponse {
+	path: string;
+	ref: string;
+	content?: string;
+	encoding?: 'base64' | 'utf-8';
+	fileTooLarge?: boolean;
+	isBinary?: boolean;
+	mimeType?: string;
+	size?: number;
+	lastCommit?: CommitHeadline;
+	submodule?: {
+		name: string;
+		url: string;
+		branch?: string;
+	};
+}
+
+export interface ComparePatch {
+	Title: string;
+	Body: string;
+	Raw: string;
+	SHA: string;
+	Author?: string;
+	Committer?: string;
+	AuthorDate?: string;
+	CommitterDate?: string;
+	SubjectPrefix?: string;
+	RawHeaders?: string;
+	BodyAppendix?: string;
+}
+
+export interface CompareResponse {
+	rev1: string;
+	rev2: string;
+	patch: string;
+	format_patch: ComparePatch[];
+}
+
+export interface CreateIssueInput {
+	title: string;
+	body: string;
+}
+
+export interface CreatePullInput {
+	title: string;
+	body: string;
+	targetBranch: string;
+	sourceBranch: string;
+	patch: string;
+}
+
+export interface RecordCreationResult {
+	uri: ResourceUri;
+	rkey: string;
+}
+
+interface BacklinkRecordRef {
+	did: Did;
+	collection: Nsid;
+	rkey: string;
+}
+
+interface ProfileWithAvatar {
+	avatar?: unknown;
+}
+
+const actorCache = new Map<string, Promise<ResolvedActor>>();
+const rpcCache = new Map<string, Client>();
+
+const normalizeServiceUrl = (input: string): string => {
+	if (input.startsWith('http://') || input.startsWith('https://')) {
+		return input;
+	}
+
+	return `https://${input}`;
+};
+
+const getRpc = (service: string): Client => {
+	const normalized = normalizeServiceUrl(service);
+	const existing = rpcCache.get(normalized);
+	if (existing) {
+		return existing;
+	}
+
+	const client = new Client({
+		handler: simpleFetchHandler({
+			service: normalized,
+		}),
+	});
+
+	rpcCache.set(normalized, client);
+	return client;
+};
+
+export const createAuthRpc = (agent: OAuthUserAgent): Client =>
+	new Client({
+		handler: agent,
+	});
+
+export const resolveActor = async (identifier: string): Promise<ResolvedActor> => {
+	const key = identifier.toLowerCase();
+	const cached = actorCache.get(key);
+	if (cached) {
+		return cached;
+	}
+
+	const promise = identityResolver.resolve(asActorIdentifier(identifier));
+	actorCache.set(key, promise);
+	return promise;
+};
+
+const fetchAllRepoRecords = async (
+	actor: ResolvedActor,
+	collection: Nsid,
+): Promise<Array<{ uri: ResourceUri; cid: string; value: unknown }>> => {
+	const rpc = getRpc(actor.pds);
+	const records: Array<{ uri: ResourceUri; cid: string; value: unknown }> = [];
+	let cursor: string | undefined;
+
+	do {
+		const page = await ok(
+			rpc.get('com.atproto.repo.listRecords', {
+				params: {
+					repo: actor.did,
+					collection,
+					limit: 100,
+					cursor,
+					reverse: true,
+				},
+			}),
+		);
+
+		records.push(...page.records);
+		cursor = page.cursor;
+	} while (cursor);
+
+	return records;
+};
+
+export const listRepoRecords = async (owner: string | ResolvedActor): Promise<RepoRecord[]> => {
+	const actor = typeof owner === 'string' ? await resolveActor(owner) : owner;
+	const records = await fetchAllRepoRecords(actor, REPO_COLLECTION);
+
+	return records.map((record) => ({
+		uri: record.uri,
+		cid: record.cid,
+		rkey: parseAtUri(record.uri).rkey,
+		value: record.value as ShTangledRepo.Main,
+	}));
+};
+
+export interface RepoStarSummary {
+	count: number;
+	isStarred: boolean;
+	currentUserStarRkey?: string;
+}
+
+const STAR_BACKLINK_SOURCES = [
+	'sh.tangled.feed.star:subject.did',
+	'sh.tangled.feed.star:subjectDid',
+];
+
+export const getRepoStarSummary = async (repo: RepoContext, viewerDid?: Did | null): Promise<RepoStarSummary> => {
+	const starrers = new Set<Did>();
+	const backlinkDidGroups = await Promise.all(STAR_BACKLINK_SOURCES.map((source) => getBacklinkDids(repo.repoDid, source)));
+
+	for (const did of backlinkDidGroups.flat()) {
+		starrers.add(did);
+	}
+
+	const currentUserStar =
+		viewerDid && starrers.has(viewerDid)
+			? await findBacklinkRefByDid(repo.repoDid, STAR_BACKLINK_SOURCES, viewerDid)
+			: undefined;
+
+	return {
+		count: starrers.size,
+		isStarred: !!currentUserStar,
+		currentUserStarRkey: currentUserStar?.rkey,
+	};
+};
+
+export const getRepoStarCount = async (repo: RepoContext): Promise<number> => {
+	const summary = await getRepoStarSummary(repo);
+	return summary.count;
+};
+
+export const createRepoStar = async (agent: OAuthUserAgent, repo: RepoContext): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledFeedStar.Main = {
+		$type: 'sh.tangled.feed.star',
+		subject: {
+			$type: 'sh.tangled.feed.star#repo',
+			did: repo.repoDid,
+		},
+		createdAt: new Date().toISOString(),
+	};
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: STAR_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const deleteRepoStar = async (agent: OAuthUserAgent, rkey: string): Promise<void> => {
+	const rpc = createAuthRpc(agent);
+	await ok(
+		rpc.post('com.atproto.repo.deleteRecord', {
+			input: {
+				repo: agent.sub,
+				collection: STAR_COLLECTION,
+				rkey,
+			},
+		}),
+	);
+};
+
+export const getRepo = async (ownerIdentifier: string, repoSlug: string): Promise<RepoContext> => {
+	const owner = await resolveActor(ownerIdentifier);
+	const all = await listRepoRecords(owner);
+	const wanted = repoSlug.trim().toLowerCase();
+	const match = all.find((record) => {
+		const name = record.value.name?.trim().toLowerCase();
+		return name === wanted || record.rkey.toLowerCase() === wanted;
+	});
+
+	if (!match) {
+		throw new Error(`Repository not found: ${ownerIdentifier}/${repoSlug}`);
+	}
+
+	if (!match.value.repoDid) {
+		throw new Error(`Repository is missing repoDid metadata`);
+	}
+
+	const slug = match.value.name?.trim() || match.rkey;
+
+	return {
+		owner,
+		record: match,
+		repoDid: match.value.repoDid,
+		slug,
+		rkey: match.rkey,
+		knot: normalizeServiceUrl(match.value.knot),
+	};
+};
+
+export const getRepoTree = async (
+	repo: RepoContext,
+	ref: string,
+	path = '',
+): Promise<TreeResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.tree', {
+			params: {
+				repo: repo.repoDid,
+				ref,
+				path,
+			},
+		}),
+	)) as TreeResponse;
+
+export const getRepoBranches = async (repo: RepoContext): Promise<BranchResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.branches', {
+			params: {
+				repo: repo.repoDid,
+			},
+			as: 'json',
+		}),
+	)) as BranchResponse;
+
+export const getRepoDefaultBranch = async (repo: RepoContext): Promise<DefaultBranchResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.getDefaultBranch', {
+			params: {
+				repo: repo.repoDid,
+			},
+		}),
+	)) as DefaultBranchResponse;
+
+export const getRepoTags = async (repo: RepoContext): Promise<TagResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.tags', {
+			params: {
+				repo: repo.repoDid,
+			},
+			as: 'json',
+		}),
+	)) as TagResponse;
+
+export const getRepoLanguages = async (repo: RepoContext, ref: string): Promise<LanguageResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.languages', {
+			params: {
+				repo: repo.repoDid,
+				ref,
+			},
+		}),
+	)) as LanguageResponse;
+
+export const getRepoLog = async (repo: RepoContext, ref: string): Promise<LogResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.log', {
+			params: {
+				repo: repo.repoDid,
+				ref,
+				limit: 8,
+			},
+			as: 'json',
+		}),
+	)) as LogResponse;
+
+export const getRepoBlob = async (
+	repo: RepoContext,
+	ref: string,
+	path: string,
+): Promise<BlobResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.blob', {
+			params: {
+				repo: repo.repoDid,
+				ref,
+				path,
+			},
+		}),
+	)) as BlobResponse;
+
+export const compareBranches = async (
+	repo: RepoContext,
+	rev1: string,
+	rev2: string,
+): Promise<CompareResponse> =>
+	(await ok(
+		getRpc(repo.knot).get('sh.tangled.repo.compare', {
+			params: {
+				repo: repo.repoDid,
+				rev1,
+				rev2,
+			},
+			as: 'json',
+		}),
+	)) as CompareResponse;
+
+const getBacklinksPage = async (
+	subject: GenericUri,
+	source: string,
+	limit: number,
+	cursor?: string,
+): Promise<{ records: BacklinkRecordRef[]; cursor?: string; total?: number }> => {
+	const constellation = getRpc(CONSTELLATION_SERVICE);
+	const page = await ok(
+		constellation.get('blue.microcosm.links.getBacklinks', {
+			params: {
+				subject,
+				source,
+				limit,
+				...(cursor ? { cursor } : {}),
+			},
+		}),
+	);
+
+	return page as { records: BacklinkRecordRef[]; cursor?: string; total?: number };
+};
+
+const getBacklinkDidsPage = async (
+	subject: GenericUri,
+	source: string,
+	limit: number,
+	cursor?: string,
+): Promise<{ linking_dids: Did[]; cursor?: string | null; total?: number }> => {
+	const constellation = getRpc(CONSTELLATION_SERVICE);
+	const page = await ok(
+		constellation.get('blue.microcosm.links.getBacklinkDids', {
+			params: {
+				subject,
+				source,
+				limit,
+				...(cursor ? { cursor } : {}),
+			},
+		}),
+	);
+
+	return page as { linking_dids: Did[]; cursor?: string | null; total?: number };
+};
+
+const getBacklinkDids = async (subject: GenericUri, source: string): Promise<Did[]> => {
+	const dids: Did[] = [];
+	let cursor: string | null = null;
+
+	do {
+		const page = await getBacklinkDidsPage(subject, source, 100, cursor ?? undefined);
+		dids.push(...page.linking_dids);
+		cursor = page.cursor ?? null;
+	} while (cursor);
+
+	return dids;
+};
+
+const findBacklinkRefByDidForSource = async (
+	subject: GenericUri,
+	source: string,
+	did: Did,
+): Promise<BacklinkRecordRef | undefined> => {
+	let cursor: string | null = null;
+
+	do {
+		const page = await getBacklinksPage(subject, source, 100, cursor ?? undefined);
+		const ref = page.records.find((record) => record.did === did && record.collection === STAR_COLLECTION);
+		if (ref) {
+			return ref;
+		}
+		cursor = page.cursor ?? null;
+	} while (cursor);
+};
+
+const findBacklinkRefByDid = async (
+	subject: GenericUri,
+	sources: string[],
+	did: Did,
+): Promise<BacklinkRecordRef | undefined> => {
+	const refs = await Promise.all(sources.map((source) => findBacklinkRefByDidForSource(subject, source, did)));
+	return refs.find((ref) => ref);
+};
+
+const getBacklinks = async (subject: GenericUri, source: string): Promise<BacklinkRecordRef[]> => {
+	const records: BacklinkRecordRef[] = [];
+	let cursor: string | null = null;
+	const constellation = getRpc(CONSTELLATION_SERVICE);
+
+	do {
+		const page: { records: BacklinkRecordRef[]; cursor?: string | null } = await ok(
+			constellation.get('blue.microcosm.links.getBacklinks', {
+				params: {
+					subject,
+					source,
+					limit: 100,
+					...(cursor ? { cursor } : {}),
+				},
+			}),
+		);
+		records.push(...page.records);
+		cursor = page.cursor ?? null;
+	} while (cursor);
+
+	return records;
+};
+
+const hydrateRecord = async <T>(
+	ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string },
+): Promise<HydratedRecord<T>> => {
+	const actor = await resolveActor(ref.did);
+	const record = await ok(
+		getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
+			params: {
+				repo: ref.did,
+				collection: ref.collection,
+				rkey: ref.rkey,
+			},
+		}),
+	);
+
+	return {
+		author: actor,
+		collection: ref.collection,
+		rkey: ref.rkey,
+		uri: record.uri,
+		cid: record.cid,
+		value: record.value as T,
+	};
+};
+
+const fetchRecordValue = async <T>(
+	ref: BacklinkRecordRef | { did: Did; collection: Nsid; rkey: string },
+): Promise<T> => {
+	const record = await ok(
+		getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
+			params: {
+				repo: ref.did,
+				collection: ref.collection,
+				rkey: ref.rkey,
+			},
+		}),
+	);
+
+	return record.value as T;
+};
+
+const hydrateBacklinks = async <T>(refs: BacklinkRecordRef[]): Promise<Array<HydratedRecord<T>>> =>
+	Promise.all(refs.map((ref) => hydrateRecord<T>(ref)));
+
+const getOptionalRecord = async <T>(
+	actor: ResolvedActor,
+	collection: Nsid,
+	rkey: string,
+): Promise<T | null> => {
+	try {
+		const record = await ok(
+			getRpc(SLINGSHOT_SERVICE).get('com.atproto.repo.getRecord', {
+				params: {
+					repo: actor.did,
+					collection,
+					rkey,
+				},
+			}),
+		);
+
+		return record.value as T;
+	} catch (cause) {
+		if (
+			cause instanceof ClientResponseError &&
+			(cause.status === 400 || cause.status === 404)
+		) {
+			return null;
+		}
+
+		throw cause;
+	}
+};
+
+const toNumberMap = <T extends { uri: string; rkey: string; value: { createdAt?: string } }>(
+	items: T[],
+): Map<string, number> => {
+	const ordered = [...items].sort((left, right) => {
+		const leftTime = left.value.createdAt ? new Date(left.value.createdAt).getTime() : 0;
+		const rightTime = right.value.createdAt ? new Date(right.value.createdAt).getTime() : 0;
+		if (leftTime !== rightTime) {
+			return leftTime - rightTime;
+		}
+
+		return left.rkey.localeCompare(right.rkey);
+	});
+
+	return new Map(ordered.map((item, index) => [item.uri, index + 1]));
+};
+
+const normalizeIssueState = (value?: string): 'open' | 'closed' =>
+	value?.endsWith('.closed') ? 'closed' : 'open';
+
+const normalizePullStatus = (value?: string): 'open' | 'closed' | 'merged' => {
+	if (value?.endsWith('.merged')) {
+		return 'merged';
+	}
+
+	if (value?.endsWith('.closed')) {
+		return 'closed';
+	}
+
+	return 'open';
+};
+
+const latestBacklinkRefByRkey = (refs: BacklinkRecordRef[]): BacklinkRecordRef | undefined =>
+	[...refs].sort((left, right) => left.rkey.localeCompare(right.rkey)).at(-1);
+
+const BACKLINK_BATCH_LIMIT = 50;
+
+const listBacklinkedRecordsPage = async <T extends { createdAt?: string }, State extends string>(
+	subject: GenericUri,
+	source: string | string[],
+	options: { offset: number; limit: number; state: State },
+	getState: (uri: ResourceUri) => Promise<State>,
+): Promise<PaginatedResult<HydratedRecord<T> & { number: number; state: State }>> => {
+	const requestedEnd = options.offset + options.limit;
+	const items: Array<HydratedRecord<T> & { number: number; state: State }> = [];
+	const sources = Array.isArray(source) ? source : [source];
+	const batchLimit = Math.min(BACKLINK_BATCH_LIMIT, Math.max(options.limit + 1, 1));
+	const cursors = new Map(sources.map((entry) => [entry, undefined as string | undefined]));
+	const exhausted = new Set<string>();
+	const seenRefs = new Set<string>();
+	let matchingSeen = 0;
+	let scannedSeen = 0;
+	let total: number | undefined;
+
+	while (items.length <= options.limit) {
+		const pages = await Promise.all(
+			sources
+				.filter((entry) => !exhausted.has(entry))
+				.map(async (entry) => ({
+					source: entry,
+					page: await getBacklinksPage(subject, entry, batchLimit, cursors.get(entry)),
+				})),
+		);
+
+		if (pages.length === 0) {
+			return { items, totalCount: matchingSeen, hasNext: false };
+		}
+
+		const refs = pages
+			.flatMap(({ source: entry, page }) => {
+				total = sources.length === 1 ? page.total ?? total : undefined;
+				cursors.set(entry, page.cursor);
+				if (!page.cursor) {
+					exhausted.add(entry);
+				}
+				return page.records;
+			})
+			.filter((ref) => {
+				const key = `${ref.did}/${ref.collection}/${ref.rkey}`;
+				if (seenRefs.has(key)) {
+					return false;
+				}
+				seenRefs.add(key);
+				return true;
+			});
+
+		if (refs.length === 0) {
+			if (exhausted.size === sources.length) {
+				return { items, totalCount: matchingSeen, hasNext: false };
+			}
+			continue;
+		}
+
+		if (pages.every(({ page }) => page.records.length === 0)) {
+			return { items, totalCount: matchingSeen, hasNext: false };
+		}
+
+		const hydrated = await hydrateBacklinks<T>(refs);
+		hydrated.sort(sortByCreatedAt).reverse();
+		const states = await Promise.all(hydrated.map((record) => getState(record.uri)));
+
+		for (let index = 0; index < hydrated.length; index += 1) {
+			const record = hydrated[index];
+			const state = states[index];
+			const number = total ? Math.max(total - scannedSeen, 1) : scannedSeen + 1;
+			scannedSeen += 1;
+
+			if (state !== options.state) {
+				continue;
+			}
+
+			if (matchingSeen >= options.offset && matchingSeen < requestedEnd + 1) {
+				items.push({ ...record, number, state });
+			}
+
+			matchingSeen += 1;
+			if (matchingSeen > requestedEnd) {
+				return { items: items.slice(0, options.limit), hasNext: true };
+			}
+		}
+
+		if (exhausted.size === sources.length) {
+			return { items, totalCount: matchingSeen, hasNext: false };
+		}
+	}
+
+	return { items: items.slice(0, options.limit), hasNext: true };
+};
+
+const getLatestIssueState = async (issueUri: ResourceUri): Promise<'open' | 'closed'> => {
+	const refs = await getBacklinks(issueUri, 'sh.tangled.repo.issue.state:issue');
+	if (refs.length === 0) {
+		return 'open';
+	}
+
+	const state = await fetchRecordValue<ShTangledRepoIssueState.Main>(latestBacklinkRefByRkey(refs)!);
+	return normalizeIssueState(state.state);
+};
+
+const getLatestPullStatus = async (pullUri: ResourceUri): Promise<'open' | 'closed' | 'merged'> => {
+	const refs = await getBacklinks(pullUri, 'sh.tangled.repo.pull.status:pull');
+	if (refs.length === 0) {
+		return 'open';
+	}
+
+	const status = await fetchRecordValue<ShTangledRepoPullStatus.Main>(latestBacklinkRefByRkey(refs)!);
+	return normalizePullStatus(status.status);
+};
+
+export const listIssues = async (repo: RepoContext): Promise<IssueSummary[]> => {
+	const refs = Array.from(
+		new Map(
+			(
+				await Promise.all([
+					getBacklinks(repo.repoDid, 'sh.tangled.repo.issue:repoDid'),
+					getBacklinks(repo.repoDid, 'sh.tangled.repo.issue:repo'),
+				])
+			)
+				.flat()
+				.map((ref) => [`${ref.did}/${ref.collection}/${ref.rkey}`, ref] as const),
+		).values(),
+	);
+	const issues = await hydrateBacklinks<ShTangledRepoIssue.Main>(refs);
+	const numbers = toNumberMap(issues);
+	const states = await Promise.all(issues.map((issue) => getLatestIssueState(issue.uri)));
+
+	return issues
+		.map((issue, index) => ({
+			...issue,
+			number: numbers.get(issue.uri) ?? index + 1,
+			state: states[index],
+		}))
+		.sort((left, right) => right.number - left.number);
+};
+
+export const listIssuesPage = async (
+	repo: RepoContext,
+	options: { offset: number; limit: number; state: 'open' | 'closed' },
+): Promise<PaginatedResult<IssueSummary>> =>
+	listBacklinkedRecordsPage<ShTangledRepoIssue.Main, 'open' | 'closed'>(
+		repo.repoDid,
+		['sh.tangled.repo.issue:repoDid', 'sh.tangled.repo.issue:repo'],
+		options,
+		getLatestIssueState,
+	);
+
+export const getIssue = async (repo: RepoContext, issueRef: string): Promise<IssueDetail> => {
+	const issues = await listIssues(repo);
+	const issue = findNumberedRecord(issues, issueRef);
+	if (!issue) {
+		throw new Error(`Issue not found`);
+	}
+
+	const commentRefs = await getBacklinks(issue.uri, 'sh.tangled.repo.issue.comment:issue');
+	const comments = await hydrateBacklinks<ShTangledRepoIssueComment.Main>(commentRefs);
+	comments.sort(sortByCreatedAt);
+
+	return {
+		issue,
+		comments,
+	};
+};
+
+export const listPulls = async (repo: RepoContext): Promise<PullSummary[]> => {
+	const refs = await getBacklinks(repo.repoDid, 'sh.tangled.repo.pull:target.repo');
+	const pulls = await hydrateBacklinks<ShTangledRepoPull.Main>(refs);
+	const numbers = toNumberMap(pulls);
+	const states = await Promise.all(pulls.map((pull) => getLatestPullStatus(pull.uri)));
+
+	return pulls
+		.map((pull, index) => ({
+			...pull,
+			number: numbers.get(pull.uri) ?? index + 1,
+			state: states[index],
+		}))
+		.sort((left, right) => right.number - left.number);
+};
+
+export const listPullsPage = async (
+	repo: RepoContext,
+	options: { offset: number; limit: number; state: 'open' | 'closed' | 'merged' },
+): Promise<PaginatedResult<PullSummary>> =>
+	listBacklinkedRecordsPage<ShTangledRepoPull.Main, 'open' | 'closed' | 'merged'>(
+		repo.repoDid,
+		'sh.tangled.repo.pull:target.repo',
+		options,
+		getLatestPullStatus,
+	);
+
+export const getPull = async (repo: RepoContext, pullRef: string): Promise<PullDetail> => {
+	const pulls = await listPulls(repo);
+	const pull = findNumberedRecord(pulls, pullRef);
+	if (!pull) {
+		throw new Error(`Pull request not found`);
+	}
+
+	const commentRefs = await getBacklinks(pull.uri, 'sh.tangled.repo.pull.comment:pull');
+	const comments = await hydrateBacklinks<ShTangledRepoPullComment.Main>(commentRefs);
+	comments.sort(sortByCreatedAt);
+
+	return {
+		pull,
+		comments,
+	};
+};
+
+export const fetchPullRoundPatch = async (
+	pull: PullSummary,
+	roundIndex: number,
+): Promise<string> => {
+	const round = pull.value.rounds[roundIndex];
+	if (!round) {
+		throw new Error(`Round ${roundIndex + 1} not found`);
+	}
+
+	const cid = extractBlobCid(round.patchBlob);
+	if (!cid) {
+		throw new Error(`Missing patch blob CID`);
+	}
+
+	const rpc = getRpc(pull.author.pds);
+	const bytes = await ok(
+		rpc.get('com.atproto.sync.getBlob', {
+			params: {
+				did: pull.author.did,
+				cid,
+			},
+			as: 'bytes',
+		}),
+	);
+
+	return strFromU8(gunzipSync(bytes));
+};
+
+export const createIssue = async (
+	agent: OAuthUserAgent,
+	repo: RepoContext,
+	input: CreateIssueInput,
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledRepoIssue.Main = {
+		$type: 'sh.tangled.repo.issue',
+		repo: repo.repoDid,
+		title: input.title.trim(),
+		body: optionalString(input.body),
+		createdAt: new Date().toISOString(),
+		mentions: extractDids(input.body),
+		references: extractAtUris(input.body),
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: ISSUE_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const createIssueComment = async (
+	agent: OAuthUserAgent,
+	issueUri: ResourceUri,
+	body: string,
+	replyTo?: ResourceUri,
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledRepoIssueComment.Main = {
+		$type: 'sh.tangled.repo.issue.comment',
+		issue: issueUri,
+		body: body.trim(),
+		createdAt: new Date().toISOString(),
+		mentions: extractDids(body),
+		references: extractAtUris(body),
+		...(replyTo ? { replyTo } : {}),
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: ISSUE_COMMENT_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const setIssueState = async (
+	agent: OAuthUserAgent,
+	issueUri: ResourceUri,
+	state: 'open' | 'closed',
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledRepoIssueState.Main = {
+		$type: 'sh.tangled.repo.issue.state',
+		issue: issueUri,
+		state:
+			state === 'closed'
+				? 'sh.tangled.repo.issue.state.closed'
+				: 'sh.tangled.repo.issue.state.open',
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: ISSUE_STATE_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const createPull = async (
+	agent: OAuthUserAgent,
+	repo: RepoContext,
+	input: CreatePullInput,
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const patchBytes = new Uint8Array(gzipSync(strToU8(input.patch)));
+	const patchBlob = new Blob([patchBytes.buffer], {
+		type: 'application/gzip',
+	});
+
+	const uploaded = await ok(
+		rpc.post('com.atproto.repo.uploadBlob', {
+			input: patchBlob,
+		}),
+	);
+
+	const record: ShTangledRepoPull.Main = {
+		$type: 'sh.tangled.repo.pull',
+		title: input.title.trim(),
+		body: optionalString(input.body),
+		target: {
+			repo: repo.repoDid,
+			branch: input.targetBranch,
+		},
+		source: {
+			branch: input.sourceBranch,
+		},
+		rounds: [
+			{
+				createdAt: new Date().toISOString(),
+				patchBlob: uploaded.blob,
+			},
+		],
+		createdAt: new Date().toISOString(),
+		mentions: extractDids(input.body),
+		references: extractAtUris(input.body),
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: PULL_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const createPullComment = async (
+	agent: OAuthUserAgent,
+	pullUri: ResourceUri,
+	body: string,
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledRepoPullComment.Main = {
+		$type: 'sh.tangled.repo.pull.comment',
+		pull: pullUri,
+		body: body.trim(),
+		createdAt: new Date().toISOString(),
+		mentions: extractDids(body),
+		references: extractAtUris(body),
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: PULL_COMMENT_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const setPullStatus = async (
+	agent: OAuthUserAgent,
+	pullUri: ResourceUri,
+	status: 'open' | 'closed' | 'merged',
+): Promise<RecordCreationResult> => {
+	const rpc = createAuthRpc(agent);
+	const record: ShTangledRepoPullStatus.Main = {
+		$type: 'sh.tangled.repo.pull.status',
+		pull: pullUri,
+		status:
+			status === 'merged'
+				? 'sh.tangled.repo.pull.status.merged'
+				: status === 'closed'
+					? 'sh.tangled.repo.pull.status.closed'
+					: 'sh.tangled.repo.pull.status.open',
+	};
+
+	const result = await ok(
+		rpc.post('com.atproto.repo.createRecord', {
+			input: {
+				repo: agent.sub,
+				collection: PULL_STATUS_COLLECTION,
+				record,
+			},
+		}),
+	);
+
+	return {
+		uri: result.uri,
+		rkey: parseAtUri(result.uri).rkey,
+	};
+};
+
+export const decodeBlobText = (blob: BlobResponse): string => {
+	if (!blob.content) {
+		return '';
+	}
+
+	if (blob.encoding === 'base64') {
+		const buffer = Uint8Array.from(atob(blob.content), (char) => char.charCodeAt(0));
+		return new TextDecoder().decode(buffer);
+	}
+
+	return blob.content;
+};
+
+export const buildBlobDataUrl = (blob: BlobResponse): string | null => {
+	if (!blob.content || !blob.mimeType) {
+		return null;
+	}
+
+	if (blob.encoding === 'base64') {
+		return `data:${blob.mimeType};base64,${blob.content}`;
+	}
+
+	return `data:${blob.mimeType};charset=utf-8,${encodeURIComponent(blob.content)}`;
+};
+
+export const resolveAvatarUrl = async (identifier: string): Promise<string | null> => {
+	const actor = await resolveActor(identifier);
+	const tangledProfile = await getOptionalRecord<ShTangledActorProfile.Main>(
+		actor,
+		ACTOR_PROFILE_COLLECTION,
+		'self',
+	);
+	const tangledCid = extractBlobCid(tangledProfile?.avatar);
+	if (tangledCid) {
+		return buildPdsBlobUrl(actor.pds, actor.did, tangledCid);
+	}
+
+	const bskyProfile = await getOptionalRecord<ProfileWithAvatar>(
+		actor,
+		APP_BSKY_PROFILE_COLLECTION,
+		'self',
+	);
+	const bskyCid = extractBlobCid(bskyProfile?.avatar);
+	if (bskyCid) {
+		return buildPdsBlobUrl(actor.pds, actor.did, bskyCid);
+	}
+
+	return null;
+};
+
+export const parseAtUri = (uri: string): { did: Did; collection: Nsid; rkey: string } => {
+	if (!uri.startsWith('at://')) {
+		throw new Error(`Invalid at-uri: ${uri}`);
+	}
+
+	const parts = uri.slice(5).split('/');
+	const [did, collection, ...rkey] = parts;
+	return {
+		did: asDid(did),
+		collection: asNsid(collection),
+		rkey: rkey.join('/'),
+	};
+};
+
+export const extractBlobCid = (blob: unknown): string | null => {
+	if (!blob || typeof blob !== 'object') {
+		return null;
+	}
+
+	const value = blob as Record<string, unknown>;
+	const ref = value.ref;
+
+	if (typeof ref === 'string') {
+		return ref;
+	}
+
+	if (ref && typeof ref === 'object') {
+		const maybeLink = (ref as Record<string, unknown>).$link;
+		if (typeof maybeLink === 'string') {
+			return maybeLink;
+		}
+	}
+
+	const maybeCid = value.cid;
+	return typeof maybeCid === 'string' ? maybeCid : null;
+};
+
+const findNumberedRecord = <T extends { number: number; rkey: string; uri: string }>(
+	records: T[],
+	ref: string,
+): T | undefined => {
+	const trimmed = ref.trim();
+	if (/^\d+$/.test(trimmed)) {
+		const number = Number(trimmed);
+		return records.find((record) => record.number === number);
+	}
+
+	return records.find(
+		(record) =>
+			record.rkey === trimmed ||
+			record.uri === trimmed ||
+			parseAtUri(record.uri).rkey === trimmed,
+	);
+};
+
+const optionalString = (value: string): string | undefined => {
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+};
+
+const uniq = <T extends string>(values: T[]): T[] | undefined => {
+	if (values.length === 0) {
+		return undefined;
+	}
+
+	return [...new Set(values)];
+};
+
+const extractDids = (input: string): Did[] | undefined =>
+	uniq(
+		Array.from(
+			input.matchAll(/\bdid:[a-z0-9]+:[A-Za-z0-9._:%-]+\b/gi),
+			(match) => match[0] as Did,
+		),
+	);
+
+const extractAtUris = (input: string): ResourceUri[] | undefined =>
+	uniq(
+		Array.from(
+			input.matchAll(/\bat:\/\/[^\s<>()]+/gi),
+			(match) => match[0] as ResourceUri,
+		),
+	);
+
+const sortByCreatedAt = <T extends { value: { createdAt?: string } }>(left: T, right: T): number =>
+	new Date(left.value.createdAt ?? 0).getTime() - new Date(right.value.createdAt ?? 0).getTime();
+
+const asActorIdentifier = (value: string): ActorIdentifier => value as ActorIdentifier;
+
+const asDid = (value: string): Did => {
+	if (!value.startsWith('did:')) {
+		throw new Error(`Invalid DID: ${value}`);
+	}
+
+	return value as Did;
+};
+
+const asNsid = (value: string): Nsid => {
+	if (value.split('.').length < 3) {
+		throw new Error(`Invalid NSID: ${value}`);
+	}
+
+	return value as Nsid;
+};
+
+const buildPdsBlobUrl = (pds: string, did: Did, cid: string): string => {
+	const url = new URL('/xrpc/com.atproto.sync.getBlob', normalizeServiceUrl(pds));
+	url.searchParams.set('did', did);
+	url.searchParams.set('cid', cid);
+	return url.toString();
+};
diff --git a/src/lib/api/identity.ts b/src/lib/api/identity.ts
new file mode 100644
index 0000000..8761260
--- /dev/null
+++ b/src/lib/api/identity.ts
@@ -0,0 +1,6 @@
+export {
+	createAuthRpc,
+	identityResolver,
+	resolveActor,
+	resolveAvatarUrl,
+} from './core';
diff --git a/src/lib/api/issues.ts b/src/lib/api/issues.ts
new file mode 100644
index 0000000..fc57fcd
--- /dev/null
+++ b/src/lib/api/issues.ts
@@ -0,0 +1,15 @@
+export {
+	createIssue,
+	createIssueComment,
+	getIssue,
+	listIssues,
+	listIssuesPage,
+	setIssueState,
+} from './core';
+
+export type {
+	CreateIssueInput,
+	IssueComment,
+	IssueDetail,
+	IssueSummary,
+} from './core';
diff --git a/src/lib/api/pulls.ts b/src/lib/api/pulls.ts
new file mode 100644
index 0000000..fa72126
--- /dev/null
+++ b/src/lib/api/pulls.ts
@@ -0,0 +1,16 @@
+export {
+	createPull,
+	createPullComment,
+	fetchPullRoundPatch,
+	getPull,
+	listPulls,
+	listPullsPage,
+	setPullStatus,
+} from './core';
+
+export type {
+	CreatePullInput,
+	PullComment,
+	PullDetail,
+	PullSummary,
+} from './core';
diff --git a/src/lib/api/records.ts b/src/lib/api/records.ts
new file mode 100644
index 0000000..e30528a
--- /dev/null
+++ b/src/lib/api/records.ts
@@ -0,0 +1,10 @@
+export {
+	extractBlobCid,
+	parseAtUri,
+} from './core';
+
+export type {
+	HydratedRecord,
+	PaginatedResult,
+	RecordCreationResult,
+} from './core';
diff --git a/src/lib/api/repos.ts b/src/lib/api/repos.ts
new file mode 100644
index 0000000..9d0413f
--- /dev/null
+++ b/src/lib/api/repos.ts
@@ -0,0 +1,31 @@
+export {
+	buildBlobDataUrl,
+	compareBranches,
+	decodeBlobText,
+	getRepo,
+	getRepoBlob,
+	getRepoBranches,
+	getRepoDefaultBranch,
+	getRepoLanguages,
+	getRepoLog,
+	getRepoTags,
+	getRepoTree,
+	listRepoRecords,
+} from './core';
+
+export type {
+	BlobResponse,
+	BranchEntry,
+	BranchResponse,
+	CommitHeadline,
+	ComparePatch,
+	CompareResponse,
+	DefaultBranchResponse,
+	LanguageResponse,
+	LogResponse,
+	RepoContext,
+	RepoRecord,
+	TagResponse,
+	TreeEntry,
+	TreeResponse,
+} from './core';
diff --git a/src/lib/api/stars.ts b/src/lib/api/stars.ts
new file mode 100644
index 0000000..9638158
--- /dev/null
+++ b/src/lib/api/stars.ts
@@ -0,0 +1,10 @@
+export {
+	createRepoStar,
+	deleteRepoStar,
+	getRepoStarCount,
+	getRepoStarSummary,
+} from './core';
+
+export type {
+	RepoStarSummary,
+} from './core';
diff --git a/src/pages/repo/code-helpers.ts b/src/pages/repo/code-helpers.ts
new file mode 100644
index 0000000..43aeb5e
--- /dev/null
+++ b/src/pages/repo/code-helpers.ts
@@ -0,0 +1,85 @@
+import { createEffect, createSignal, onCleanup } from 'solid-js';
+
+export const LOADING_DELAY_MS = 100;
+
+export const resolveDefaultBranchName = (
+	branches: { is_default?: boolean; reference: { name: string } }[] | undefined,
+): string | undefined =>
+	branches?.find((branch) => branch.is_default)?.reference.name ?? branches?.[0]?.reference.name;
+
+export const resolveRouteRefAndPath = (
+	initialRef: string,
+	initialPath: string,
+	branchNames: string[] | undefined,
+): { ref: string; path: string } => {
+	if (!branchNames || !initialPath) {
+		return { ref: initialRef, path: initialPath };
+	}
+
+	const names = new Set(branchNames);
+	const pathSegments = initialPath.split('/').filter(Boolean);
+	let resolved = { ref: initialRef, path: initialPath };
+
+	for (let index = 0; index < pathSegments.length; index += 1) {
+		const candidate = [initialRef, ...pathSegments.slice(0, index + 1)].join('/');
+		if (names.has(candidate)) {
+			resolved = {
+				ref: candidate,
+				path: pathSegments.slice(index + 1).join('/'),
+			};
+		}
+	}
+
+	return resolved;
+};
+
+export const hasNamedRef = (
+	name: string,
+	branches: { reference: { name: string } }[],
+	tags: { name: string }[],
+): boolean => branches.some((branch) => branch.reference.name === name) || tags.some((tag) => tag.name === name);
+
+export const normalizeLanguages = (
+	languages: Array<{ name: string; percentage: number; size: number; color?: string }>,
+	totalSize?: number,
+): Array<{ name: string; percentage: number; size: number; color?: string }> => {
+	const computedTotalSize = totalSize ?? languages.reduce((sum, language) => sum + language.size, 0);
+	return languages
+		.map((language) => ({
+			...language,
+			percentage: computedTotalSize > 0 ? (language.size / computedTotalSize) * 100 : language.percentage,
+		}))
+		.sort((left, right) => right.size - left.size || left.name.localeCompare(right.name));
+};
+
+export const useDelayedLoading = (pending: () => boolean, delayMs = LOADING_DELAY_MS) => {
+	const [visible, setVisible] = createSignal(false);
+	let timer: ReturnType<typeof setTimeout> | undefined;
+
+	createEffect(() => {
+		if (pending()) {
+			if (timer === undefined) {
+				timer = setTimeout(() => {
+					timer = undefined;
+					setVisible(true);
+				}, delayMs);
+			}
+			return;
+		}
+
+		if (timer !== undefined) {
+			clearTimeout(timer);
+			timer = undefined;
+		}
+		setVisible(false);
+	});
+
+	onCleanup(() => {
+		if (timer !== undefined) clearTimeout(timer);
+	});
+
+	return visible;
+};
+
+export const shouldAnimateNavigation = (event: MouseEvent) =>
+	event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey && !event.defaultPrevented;
diff --git a/src/pages/repo/code.tsx b/src/pages/repo/code.tsx
index bfbd1b5..636bf8e 100644
--- a/src/pages/repo/code.tsx
+++ b/src/pages/repo/code.tsx
@@ -2,88 +2,13 @@ import clsx from 'clsx';
 import { Download, File, Folder, GitBranch, GitCommitHorizontal, List } from 'lucide-solid';
 import { A, useNavigate, useParams } from '@solidjs/router';
 import { createQuery, keepPreviousData, useQueryClient } from '@tanstack/solid-query';
-import { For, Match, Show, Switch, createEffect, createMemo, createSignal, onCleanup, type Component } from 'solid-js';
+import { For, Match, Show, Switch, createEffect, createMemo, createSignal, type Component } from 'solid-js';
 import { buildBlobDataUrl, decodeBlobText, getRepoBlob, getRepoBranches, getRepoDefaultBranch, getRepoLanguages, getRepoLog, getRepoTags, getRepoTree } from '../../lib/api';
 import { Avatar, ErrorState, PlaceholderAvatar, buttonStyles, cardStyles } from '../../components/common';
 import { CodeView, FileRow, MarkdownBlock, OverviewFileRow, ReadmeCard, RepoTreeSkeleton } from '../../components/repo';
 import { RepoFrame, useRepoQuery } from './shared';
 import { blobHref, countLines, decodeRoutePath, formatBytes, formatLanguagePercent, formatRelativeTime, getErrorMessage, getParentPath, imageLike, isDirectory, joinPath, languageColor, markdownLike, safeDecode, sortedTreeEntries, svgLike, treeHref, videoLike } from '../../lib/repo-utils';
-
-const resolveDefaultBranchName = (branches: { is_default?: boolean; reference: { name: string } }[] | undefined): string | undefined =>
-	branches?.find((branch) => branch.is_default)?.reference.name ?? branches?.[0]?.reference.name;
-
-const resolveRouteRefAndPath = (
-	initialRef: string,
-	initialPath: string,
-	branchNames: string[] | undefined,
-): { ref: string; path: string } => {
-	if (!branchNames || !initialPath) {
-		return { ref: initialRef, path: initialPath };
-	}
-
-	const names = new Set(branchNames);
-	const pathSegments = initialPath.split('/').filter(Boolean);
-	let resolved = { ref: initialRef, path: initialPath };
-
-	for (let index = 0; index < pathSegments.length; index += 1) {
-		const candidate = [initialRef, ...pathSegments.slice(0, index + 1)].join('/');
-		if (names.has(candidate)) {
-			resolved = {
-				ref: candidate,
-				path: pathSegments.slice(index + 1).join('/'),
-			};
-		}
-	}
-
-	return resolved;
-};
-
-const hasNamedRef = (name: string, branches: { reference: { name: string } }[], tags: { name: string }[]): boolean =>
-	branches.some((branch) => branch.reference.name === name) || tags.some((tag) => tag.name === name);
-
-const normalizeLanguages = (
-	languages: Array<{ name: string; percentage: number; size: number; color?: string }>,
-	totalSize?: number,
-): Array<{ name: string; percentage: number; size: number; color?: string }> => {
-	const computedTotalSize = totalSize ?? languages.reduce((sum, language) => sum + language.size, 0);
-	return languages
-		.map((language) => ({
-			...language,
-			percentage: computedTotalSize > 0 ? (language.size / computedTotalSize) * 100 : language.percentage,
-		}))
-		.sort((left, right) => right.size - left.size || left.name.localeCompare(right.name));
-};
-
-const LOADING_DELAY_MS = 100;
-
-const useDelayedLoading = (pending: () => boolean, delayMs = LOADING_DELAY_MS) => {
-	const [visible, setVisible] = createSignal(false);
-	let timer: ReturnType<typeof setTimeout> | undefined;
-
-	createEffect(() => {
-		if (pending()) {
-			if (timer === undefined) {
-				timer = setTimeout(() => {
-					timer = undefined;
-					setVisible(true);
-				}, delayMs);
-			}
-			return;
-		}
-
-		if (timer !== undefined) {
-			clearTimeout(timer);
-			timer = undefined;
-		}
-		setVisible(false);
-	});
-
-	onCleanup(() => {
-		if (timer !== undefined) clearTimeout(timer);
-	});
-
-	return visible;
-};
+import { LOADING_DELAY_MS, hasNamedRef, normalizeLanguages, resolveDefaultBranchName, resolveRouteRefAndPath, shouldAnimateNavigation, useDelayedLoading } from './code-helpers';
 
 const PathBreadcrumbs: Component<{
 	repo: Parameters<typeof treeHref>[0];
@@ -154,9 +79,6 @@ const LoadingFilePath: Component<{
 	);
 };
 
-const shouldAnimateNavigation = (event: MouseEvent) =>
-	event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey && !event.defaultPrevented;
-
 const RepoCodePageLegacy: Component = () => {
 	const params = useParams();
 	const navigate = useNavigate();
diff --git a/src/pages/repo/issues-helpers.ts b/src/pages/repo/issues-helpers.ts
new file mode 100644
index 0000000..905d082
--- /dev/null
+++ b/src/pages/repo/issues-helpers.ts
@@ -0,0 +1,44 @@
+import type { IssueComment } from '../../lib/api';
+
+export type IssueCommentThread = {
+	item: IssueComment;
+	replies: IssueComment[];
+};
+
+export const buildIssueCommentThreads = (comments: IssueComment[]): IssueCommentThread[] => {
+	const byUri = new Map(comments.map((comment) => [comment.uri, comment]));
+	const topLevel: IssueComment[] = [];
+	const repliesByRoot = new Map<string, IssueComment[]>();
+
+	const findRoot = (comment: IssueComment): IssueComment | null => {
+		let current = comment;
+		const visited = new Set<string>([comment.uri]);
+
+		while (current.value.replyTo) {
+			const parent = byUri.get(current.value.replyTo);
+			if (!parent || visited.has(parent.uri)) {
+				return current === comment ? null : current;
+			}
+
+			current = parent;
+			visited.add(current.uri);
+		}
+
+		return current;
+	};
+
+	for (const comment of comments) {
+		const root = findRoot(comment);
+		if (!root || root.uri === comment.uri) {
+			topLevel.push(comment);
+			continue;
+		}
+
+		repliesByRoot.set(root.uri, [...(repliesByRoot.get(root.uri) ?? []), comment]);
+	}
+
+	return topLevel.map((item) => ({
+		item,
+		replies: repliesByRoot.get(item.uri) ?? [],
+	}));
+};
diff --git a/src/pages/repo/issues.tsx b/src/pages/repo/issues.tsx
index 0830c27..ff147e7 100644
--- a/src/pages/repo/issues.tsx
+++ b/src/pages/repo/issues.tsx
@@ -4,55 +4,13 @@ import { A, useNavigate, useParams, useSearchParams } from '@solidjs/router';
 import { createQuery, useQueryClient } from '@tanstack/solid-query';
 import type { ResourceUri } from '@atcute/lexicons/syntax';
 import { For, Match, Show, Switch, createMemo, createSignal, type Component } from 'solid-js';
-import { createIssue, createIssueComment, getIssue, listIssuesPage, parseAtUri, resolveActor, setIssueState, type IssueComment, type RepoContext } from '../../lib/api';
+import { createIssue, createIssueComment, getIssue, listIssuesPage, parseAtUri, resolveActor, setIssueState, type RepoContext } from '../../lib/api';
 import { useAuth } from '../../lib/auth';
 import { Avatar, ErrorState, StateBadge, ToggleButton, buttonStyles, cardStyles, inputStyles, textareaStyles } from '../../components/common';
 import { MarkdownBlock, PaginationControls, RepoListSkeleton, RepoThreadSkeleton } from '../../components/repo';
 import { RepoFrame, issueQueryKey, issuesQueryKey, useRepoQuery } from './shared';
 import { REPO_LIST_PAGE_LIMIT, formatRelativeTime, getErrorMessage, issueHref, parseIntegerSearchParam, uniqueCommenters } from '../../lib/repo-utils';
-
-type IssueCommentThread = {
-	item: IssueComment;
-	replies: IssueComment[];
-};
-
-const buildIssueCommentThreads = (comments: IssueComment[]): IssueCommentThread[] => {
-	const byUri = new Map(comments.map((comment) => [comment.uri, comment]));
-	const topLevel: IssueComment[] = [];
-	const repliesByRoot = new Map<string, IssueComment[]>();
-
-	const findRoot = (comment: IssueComment): IssueComment | null => {
-		let current = comment;
-		const visited = new Set<string>([comment.uri]);
-
-		while (current.value.replyTo) {
-			const parent = byUri.get(current.value.replyTo);
-			if (!parent || visited.has(parent.uri)) {
-				return current === comment ? null : current;
-			}
-
-			current = parent;
-			visited.add(current.uri);
-		}
-
-		return current;
-	};
-
-	for (const comment of comments) {
-		const root = findRoot(comment);
-		if (!root || root.uri === comment.uri) {
-			topLevel.push(comment);
-			continue;
-		}
-
-		repliesByRoot.set(root.uri, [...(repliesByRoot.get(root.uri) ?? []), comment]);
-	}
-
-	return topLevel.map((item) => ({
-		item,
-		replies: repliesByRoot.get(item.uri) ?? [],
-	}));
-};
+import { buildIssueCommentThreads } from './issues-helpers';
 
 export const IssuesPage: Component = () => {
 	const auth = useAuth();
diff --git a/src/pages/repo/pulls-helpers.ts b/src/pages/repo/pulls-helpers.ts
new file mode 100644
index 0000000..57826ec
--- /dev/null
+++ b/src/pages/repo/pulls-helpers.ts
@@ -0,0 +1,15 @@
+import type { SearchParamValue } from '../../lib/repo-utils';
+
+export type PullStateFilter = 'open' | 'closed' | 'merged';
+
+export const parsePullStateFilter = (value: SearchParamValue): PullStateFilter => {
+	if (value === 'state:closed') {
+		return 'closed';
+	}
+
+	if (value === 'state:merged') {
+		return 'merged';
+	}
+
+	return 'open';
+};
diff --git a/src/pages/repo/pulls.tsx b/src/pages/repo/pulls.tsx
index 7753f3e..1057914 100644
--- a/src/pages/repo/pulls.tsx
+++ b/src/pages/repo/pulls.tsx
@@ -9,16 +9,13 @@ import { Avatar, ErrorState, LoadingState, StateBadge, ToggleButton, buttonStyle
 import { BranchPill, CommentCard, DiffView, MarkdownBlock, PaginationControls, PullDiffView, RepoListSkeleton, RepoThreadSkeleton } from '../../components/repo';
 import { RepoFrame, pullQueryKey, pullsQueryKey, useRepoQuery } from './shared';
 import { REPO_LIST_PAGE_LIMIT, formatRelativeTime, getErrorMessage, parseIntegerSearchParam, pullHref, uniqueCommenters } from '../../lib/repo-utils';
+import { parsePullStateFilter, type PullStateFilter } from './pulls-helpers';
 
 export const PullsPage: Component = () => {
 	const auth = useAuth();
 	const repoQuery = useRepoQuery();
 	const [searchParams, setSearchParams] = useSearchParams();
-	const stateFilter = createMemo<'open' | 'closed' | 'merged'>(() => {
-		if (searchParams.q === 'state:closed') return 'closed';
-		if (searchParams.q === 'state:merged') return 'merged';
-		return 'open';
-	});
+	const stateFilter = createMemo<PullStateFilter>(() => parsePullStateFilter(searchParams.q));
 	const filterQuery = createMemo(() => `state:${stateFilter()}`);
 	const pageOffset = createMemo(() => parseIntegerSearchParam(searchParams.offset, 0, 0));
 	const pageLimit = createMemo(() => parseIntegerSearchParam(searchParams.limit, REPO_LIST_PAGE_LIMIT, 1));
diff --git a/src/pages/repo/shared.tsx b/src/pages/repo/shared.tsx
index 0ee7289..904939a 100644
--- a/src/pages/repo/shared.tsx
+++ b/src/pages/repo/shared.tsx
@@ -1,7 +1,7 @@
 import { CircleDot, GitPullRequest, Globe, LoaderCircle, Rss, SquareChartGantt, Star } from 'lucide-solid';
-import { A, useParams } from '@solidjs/router';
+import { A, type RouteSectionProps, useParams } from '@solidjs/router';
 import { createQuery } from '@tanstack/solid-query';
-import { For, Match, Show, Switch, createEffect, createMemo, createSignal, onCleanup, type Component, type JSX } from 'solid-js';
+import { For, Match, Show, Switch, createContext, createEffect, createMemo, createSignal, onCleanup, useContext, type Component, type JSX } from 'solid-js';
 import { createRepoStar, deleteRepoStar, getRepo, getRepoStarSummary } from '../../lib/api';
 import { useAuth } from '../../lib/auth';
 import { useLiveEvents } from '../../lib/live-events';
@@ -17,7 +17,7 @@ export const pullQueryKey = (repoDid: string, pullRef: string) => ['pull', repoD
 
 type OptimisticStarState = { state: 'starred'; rkey?: string } | { state: 'unstarred'; rkey: string };
 
-export const useRepoQuery = () => {
+const createRepoQuery = () => {
 	const params = useParams();
 	const owner = createMemo(() => params.owner ?? '');
 	const repo = createMemo(() => params.repo ?? '');
@@ -29,6 +29,25 @@ export const useRepoQuery = () => {
 	}));
 };
 
+type RepoQuery = ReturnType<typeof createRepoQuery>;
+
+const RepoQueryContext = createContext<RepoQuery>();
+
+export const RepoLayout: Component<RouteSectionProps> = (props) => {
+	const repoQuery = createRepoQuery();
+
+	return <RepoQueryContext.Provider value={repoQuery}>{props.children}</RepoQueryContext.Provider>;
+};
+
+export const useRepoQuery = () => {
+	const repoQuery = useContext(RepoQueryContext);
+	if (!repoQuery) {
+		throw new Error('useRepoQuery must be used inside RepoLayout');
+	}
+
+	return repoQuery;
+};
+
 export const RepoFrame: Component<{
 	active: 'code' | 'issues' | 'pulls';
 	children: JSX.Element;
diff --git a/src/routes.tsx b/src/routes.tsx
new file mode 100644
index 0000000..100bb7f
--- /dev/null
+++ b/src/routes.tsx
@@ -0,0 +1,37 @@
+import { Route, Router } from '@solidjs/router';
+import type { Component } from 'solid-js';
+
+import { RootShell } from './layout';
+import {
+	BlobPage,
+	IssuePage,
+	IssuesPage,
+	NewIssuePage,
+	NewPullPage,
+	PullPage,
+	PullsPage,
+	RepoCodePage,
+} from './pages/repo';
+import { RepoLayout } from './pages/repo/shared';
+import { HomePage } from './views/home';
+import { NotFoundPage } from './views/not-found';
+import { OAuthCallbackPage } from './views/oauth-callback';
+
+export const AppRoutes: Component = () => (
+	<Router root={RootShell}>
+		<Route path="/" component={HomePage} />
+		<Route path="/oauth/callback" component={OAuthCallbackPage} />
+		<Route path="/:owner/:repo" component={RepoLayout}>
+			<Route path="/" component={RepoCodePage} />
+			<Route path="/issues/new" component={NewIssuePage} />
+			<Route path="/issues/:issueRef" component={IssuePage} />
+			<Route path="/issues" component={IssuesPage} />
+			<Route path="/pulls/new" component={NewPullPage} />
+			<Route path="/pulls/:pullRef" component={PullPage} />
+			<Route path="/pulls" component={PullsPage} />
+			<Route path="/blob/:ref/*path" component={BlobPage} />
+			<Route path="/tree/:ref/*path" component={RepoCodePage} />
+		</Route>
+		<Route path="*404" component={NotFoundPage} />
+	</Router>
+);
diff --git a/src/views/home.tsx b/src/views/home.tsx
new file mode 100644
index 0000000..ec97261
--- /dev/null
+++ b/src/views/home.tsx
@@ -0,0 +1,134 @@
+import clsx from 'clsx';
+import { A, useNavigate } from '@solidjs/router';
+import { createQuery } from '@tanstack/solid-query';
+import { For, Show, createMemo, createSignal, type Component } from 'solid-js';
+
+import { LoadingState, buttonStyles, cardStyles, inputStyles } from '../components/common';
+import { listRepoRecords, resolveActor } from '../lib/api';
+import { useAuth } from '../lib/auth';
+import { formatRelativeTime, loadRecentRepos, parseRepoJump } from '../lib/repo-utils';
+
+const SAMPLE_REPOS = [
+	{ owner: 'mary.my.id', slug: 'atcute' },
+	{ owner: 'mary.my.id', slug: 'boat' },
+	{ owner: 'mary.my.id', slug: 'aglais' },
+];
+
+export const HomePage: Component = () => {
+	const auth = useAuth();
+	const [jump, setJump] = createSignal('');
+	const recentRepos = createMemo(loadRecentRepos);
+	const navigate = useNavigate();
+
+	const ownReposQuery = createQuery(() => ({
+		queryKey: ['own-repos', auth.currentDid()],
+		enabled: Boolean(auth.currentDid()),
+		queryFn: async () => {
+			const actor = await resolveActor(auth.currentDid()!);
+			return listRepoRecords(actor);
+		},
+	}));
+
+	const onSubmit = (event: SubmitEvent) => {
+		event.preventDefault();
+		const parsed = parseRepoJump(jump());
+		if (!parsed) {
+			return;
+		}
+
+		navigate(`/${parsed.owner}/${parsed.repo}`);
+	};
+
+	return (
+		<div class="untangled-home-grid">
+			<div class="flex flex-col gap-4">
+				<div class={cardStyles('p-6')}>
+					<div class="flex items-center gap-3 mb-6">
+						<img src="/static/logos/dolly.svg" alt="" class="size-12" />
+						<div>
+							<h1 class="text-2xl font-bold m-0">untangled</h1>
+							<p class="m-0 text-sm text-gray-500 dark:text-gray-400">tightly-knit social coding</p>
+						</div>
+					</div>
+
+					<form onSubmit={onSubmit} class="flex flex-col gap-3">
+						<label class="text-sm font-medium">repository</label>
+						<div class="flex gap-2">
+							<input
+								value={jump()}
+								onInput={(event) => setJump(event.currentTarget.value)}
+								placeholder="mary.my.id/atcute"
+								class={inputStyles()}
+							/>
+							<button type="submit" class={clsx(buttonStyles('primary'), 'shrink-0')}>
+								open
+							</button>
+						</div>
+					</form>
+
+					<div class="mt-8">
+						<div class="text-sm font-medium mb-3">sample repositories</div>
+						<div class="grid gap-2 sm:grid-cols-2">
+							<For each={SAMPLE_REPOS}>
+								{(repo) => (
+									<A href={`/${repo.owner}/${repo.slug}`} class={cardStyles('p-4 hover:bg-gray-50 dark:hover:bg-gray-700/30 no-underline')}>
+										<div class="font-medium">
+											{repo.owner}/{repo.slug}
+										</div>
+									</A>
+								)}
+							</For>
+						</div>
+					</div>
+				</div>
+			</div>
+
+			<div class="flex flex-col gap-4">
+				<div class={cardStyles('p-6')}>
+					<div class="text-sm font-medium mb-3">recent</div>
+					<Show
+						when={recentRepos().length > 0}
+						fallback={<div class="text-sm text-gray-500 dark:text-gray-400">No recent repositories.</div>}
+					>
+						<div class="flex flex-col gap-2">
+							<For each={recentRepos()}>
+								{(repo) => (
+									<A href={`/${repo.owner}/${repo.slug}`} class="no-underline hover:no-underline rounded border border-gray-200 dark:border-gray-700 px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-700/30">
+										<div class="font-medium">{repo.title}</div>
+										<div class="text-xs text-gray-500 dark:text-gray-400">{formatRelativeTime(repo.updatedAt)}</div>
+									</A>
+								)}
+							</For>
+						</div>
+					</Show>
+				</div>
+
+				<Show when={auth.currentDid()}>
+					<div class={cardStyles('p-6')}>
+						<div class="text-sm font-medium mb-3">your repositories</div>
+						<Show
+							when={!ownReposQuery.isLoading}
+							fallback={<LoadingState label="Loading repositories..." />}
+						>
+							<div class="flex flex-col gap-2">
+								<For each={ownReposQuery.data ?? []}>
+									{(repo) => (
+										<A
+											href={`/${auth.currentDid()}/${repo.value.name?.trim() || repo.rkey}`}
+											class="no-underline hover:no-underline rounded border border-gray-200 dark:border-gray-700 px-4 py-3 hover:bg-gray-50 dark:hover:bg-gray-700/30"
+										>
+											<div class="font-medium">{repo.value.name?.trim() || repo.rkey}</div>
+											<div class="text-xs text-gray-500 dark:text-gray-400">
+												{repo.value.description || repo.value.repoDid}
+											</div>
+										</A>
+									)}
+								</For>
+							</div>
+						</Show>
+					</div>
+				</Show>
+			</div>
+		</div>
+	);
+};
diff --git a/src/views/not-found.tsx b/src/views/not-found.tsx
new file mode 100644
index 0000000..3fbf911
--- /dev/null
+++ b/src/views/not-found.tsx
@@ -0,0 +1,9 @@
+import type { Component } from 'solid-js';
+
+import { cardStyles } from '../components/common';
+
+export const NotFoundPage: Component = () => (
+	<div class={cardStyles('p-10 text-center')}>
+		<h1 class="text-2xl font-bold m-0">not found</h1>
+	</div>
+);
diff --git a/src/views/oauth-callback.tsx b/src/views/oauth-callback.tsx
new file mode 100644
index 0000000..da66bef
--- /dev/null
+++ b/src/views/oauth-callback.tsx
@@ -0,0 +1,27 @@
+import { useNavigate } from '@solidjs/router';
+import { onMount, type Component } from 'solid-js';
+
+import { LoadingState, cardStyles } from '../components/common';
+import { useAuth } from '../lib/auth';
+
+export const OAuthCallbackPage: Component = () => {
+	const auth = useAuth();
+	const navigate = useNavigate();
+
+	onMount(() => {
+		void (async () => {
+			try {
+				const target = await auth.completeSignIn();
+				navigate(target, { replace: true });
+			} catch {
+				// Error is captured in auth state.
+			}
+		})();
+	});
+
+	return (
+		<div class={cardStyles('p-10 text-center')}>
+			<LoadingState label={auth.error() ?? 'Completing OAuth sign-in...'} />
+		</div>
+	);
+};