diff --git a/apps/web/README.md b/apps/web/README.md
index b3aa3ff..586369b 100644
--- a/apps/web/README.md
+++ b/apps/web/README.md
@@ -162,6 +162,12 @@ The AT-native publishing path is stateless on the Cartesium server:
 - `/cartesium/oauth-client-metadata.json` exposes deployment-specific OAuth
   metadata. `/cartesium/resolve-handle` performs DNS TXT resolution with a
   bounded, public-host-only HTTPS well-known fallback.
+- The account picker searches public actor directories after two typed
+  characters, using Typeahead first and the Bluesky public AppView as a
+  fallback when the primary service is unavailable. Suggestions are optional;
+  users may still enter a handle or DID manually. A selected suggestion only
+  supplies the handle to the existing OAuth flow; its returned DID is not used
+  as an authentication authority.
 
 Set `CARTESIUM_PUBLICATION_V1_COLLECTION` to the production NSID selected for
 Cartesium publication V1 records. Set `CARTESIUM_PUBLICATION_V2_COLLECTION`
diff --git a/apps/web/src/lib/components/AtprotoSignInDialog.svelte b/apps/web/src/lib/components/AtprotoSignInDialog.svelte
new file mode 100644
index 0000000..a69840f
--- /dev/null
+++ b/apps/web/src/lib/components/AtprotoSignInDialog.svelte
@@ -0,0 +1,370 @@
+<script lang="ts">
+	import { tick } from 'svelte';
+
+	import {
+		ACTOR_SUGGESTION_MIN_LENGTH,
+		normalizeActorSuggestionQuery,
+		searchActorSuggestions,
+		type ActorSuggestion
+	} from '$lib/publishing/handle-suggestions';
+
+	let {
+		open = false,
+		purpose = 'signin',
+		dark = false,
+		busy = false,
+		error = '',
+		onconfirm,
+		onclose
+	}: {
+		open?: boolean;
+		purpose?: 'signin' | 'publish';
+		dark?: boolean;
+		busy?: boolean;
+		error?: string;
+		onconfirm: (identifier: string) => void | Promise<void>;
+		onclose: () => void;
+	} = $props();
+
+	let inputElement = $state<HTMLInputElement | undefined>(undefined);
+	let inputValue = $state('');
+	let suggestions = $state<ActorSuggestion[]>([]);
+	let activeIndex = $state(-1);
+	let loading = $state(false);
+	let searched = $state(false);
+	let suggestionError = $state('');
+	let validationError = $state('');
+	let requestController: AbortController | null = null;
+	let requestToken = 0;
+	let debounceTimer: number | null = null;
+	let wasOpen = false;
+
+	let title = $derived(purpose === 'publish' ? 'Sign in to publish' : 'Sign in with AT Protocol');
+	let submitLabel = $derived(purpose === 'publish' ? 'Continue to publish' : 'Continue');
+	let displayError = $derived(validationError || error);
+	let canSearch = $derived(
+		normalizeActorSuggestionQuery(inputValue).length >= ACTOR_SUGGESTION_MIN_LENGTH &&
+		!normalizeActorSuggestionQuery(inputValue).toLowerCase().startsWith('did:')
+	);
+
+	$effect(() => {
+		if (open && !wasOpen) {
+			inputValue = '';
+			suggestions = [];
+			activeIndex = -1;
+			searched = false;
+			suggestionError = '';
+			validationError = '';
+			void tick().then(() => inputElement?.focus());
+		}
+		if (!open && wasOpen) cancelSearch();
+		wasOpen = open;
+	});
+
+	function handleInput(event: Event) {
+		inputValue = (event.currentTarget as HTMLInputElement).value;
+		validationError = '';
+		suggestionError = '';
+		suggestions = [];
+		activeIndex = -1;
+		searched = false;
+		cancelSearch();
+
+		const query = normalizeActorSuggestionQuery(inputValue);
+		if (
+			query.length < ACTOR_SUGGESTION_MIN_LENGTH ||
+			query.toLowerCase().startsWith('did:')
+		) {
+			return;
+		}
+
+		const token = requestToken;
+		debounceTimer = window.setTimeout(() => void loadSuggestions(query, token), 250);
+	}
+
+	async function loadSuggestions(query: string, token: number) {
+		debounceTimer = null;
+		const controller = new AbortController();
+		requestController = controller;
+		loading = true;
+		try {
+			const result = await searchActorSuggestions(query, { signal: controller.signal });
+			if (token !== requestToken || controller.signal.aborted) return;
+			suggestions = result.actors;
+			activeIndex = -1;
+			searched = true;
+		} catch {
+			if (controller.signal.aborted || token !== requestToken) return;
+			searched = true;
+			suggestionError = 'Suggestions are temporarily unavailable; enter a handle or DID manually.';
+		} finally {
+			if (token === requestToken) loading = false;
+			if (requestController === controller) requestController = null;
+		}
+	}
+
+	function cancelSearch() {
+		if (debounceTimer !== null) {
+			window.clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		requestController?.abort();
+		requestController = null;
+		requestToken += 1;
+		loading = false;
+	}
+
+	function selectSuggestion(suggestion: ActorSuggestion) {
+		inputValue = suggestion.handle;
+		suggestions = [];
+		activeIndex = -1;
+		suggestionError = '';
+		validationError = '';
+		inputElement?.focus();
+	}
+
+	function handleKeydown(event: KeyboardEvent) {
+		if (!open || busy) return;
+		if (event.key === 'Escape') {
+			event.preventDefault();
+			closeDialog();
+			return;
+		}
+		if (event.key === 'ArrowDown' && suggestions.length > 0) {
+			event.preventDefault();
+			activeIndex = (activeIndex + 1) % suggestions.length;
+			return;
+		}
+		if (event.key === 'ArrowUp' && suggestions.length > 0) {
+			event.preventDefault();
+			activeIndex = (activeIndex - 1 + suggestions.length) % suggestions.length;
+			return;
+		}
+		if (event.key === 'Enter' && activeIndex >= 0 && suggestions[activeIndex]) {
+			event.preventDefault();
+			selectSuggestion(suggestions[activeIndex]);
+		}
+	}
+
+	async function submit() {
+		if (busy) return;
+		const identifier = inputValue.trim().replace(/^@/, '');
+		if (!identifier) {
+			validationError = 'Enter an AT Protocol handle or DID.';
+			return;
+		}
+		validationError = '';
+		try {
+			await onconfirm(identifier);
+		} catch (error) {
+			validationError = error instanceof Error ? error.message : 'Could not start sign-in.';
+		}
+	}
+
+	function closeDialog() {
+		if (busy) return;
+		cancelSearch();
+		onclose();
+	}
+
+	function initials(suggestion: ActorSuggestion): string {
+		const source = suggestion.displayName?.trim() || suggestion.handle;
+		return source.slice(0, 1).toUpperCase();
+	}
+</script>
+
+<svelte:window onkeydown={handleKeydown} />
+
+{#if open}
+	<div
+		class:dark
+		class="backdrop"
+	>
+		<div class="dialog" role="dialog" aria-modal="true" aria-labelledby="atproto-signin-title">
+			<header>
+				<div>
+					<h2 id="atproto-signin-title">{title}</h2>
+					<p>Choose your AT Protocol account provider to continue.</p>
+				</div>
+				<button type="button" class="close" aria-label="Close sign-in" onclick={closeDialog} disabled={busy}>×</button>
+			</header>
+
+			<form onsubmit={(event) => { event.preventDefault(); void submit(); }}>
+				<label for="atproto-account-identifier">Handle or DID</label>
+				<input
+					bind:this={inputElement}
+					id="atproto-account-identifier"
+					value={inputValue}
+					autocomplete="username"
+					autocapitalize="none"
+					spellcheck="false"
+					placeholder="alice.bsky.social"
+					aria-autocomplete="list"
+					aria-controls="atproto-account-suggestions"
+					aria-expanded={suggestions.length > 0}
+					aria-activedescendant={activeIndex >= 0 ? `atproto-account-suggestion-${activeIndex}` : undefined}
+					disabled={busy}
+					oninput={handleInput}
+				/>
+				<p class="hint">Suggestions are optional; you can enter a handle or DID directly.</p>
+
+				{#if loading}
+					<p class="suggestion-status" role="status">Searching public actor directories…</p>
+				{:else if suggestionError}
+					<p class="suggestion-status" role="status">{suggestionError}</p>
+				{:else if canSearch && searched && suggestions.length === 0}
+					<p class="suggestion-status" role="status">No suggestions found; manual entry is still available.</p>
+				{/if}
+
+				{#if suggestions.length > 0}
+					<div id="atproto-account-suggestions" class="suggestions" role="listbox" aria-label="Account suggestions">
+						{#each suggestions as suggestion, index (suggestion.did)}
+							<button
+								type="button"
+								class:active={activeIndex === index}
+								class="suggestion"
+								id={`atproto-account-suggestion-${index}`}
+								role="option"
+								aria-selected={activeIndex === index}
+								onmouseenter={() => (activeIndex = index)}
+								onclick={() => selectSuggestion(suggestion)}
+							>
+								<span class="avatar" aria-hidden="true">
+									<span>{initials(suggestion)}</span>
+									{#if suggestion.avatar}
+										<img src={suggestion.avatar} alt="" loading="lazy" />
+									{/if}
+								</span>
+								<span class="suggestion-copy">
+									<strong>{suggestion.displayName || `@${suggestion.handle}`}</strong>
+									<small>@{suggestion.handle}</small>
+								</span>
+							</button>
+						{/each}
+					</div>
+				{/if}
+
+				{#if displayError}<p class="error" role="alert">{displayError}</p>{/if}
+				<footer>
+					<button type="submit" class="primary" disabled={busy}>
+						{busy ? 'Connecting…' : submitLabel}
+					</button>
+					<button type="button" class="secondary" onclick={closeDialog} disabled={busy}>Cancel</button>
+				</footer>
+			</form>
+		</div>
+	</div>
+{/if}
+
+<style>
+	.backdrop {
+		position: fixed;
+		inset: 0;
+		z-index: 120;
+		display: grid;
+		place-items: center;
+		padding: 20px;
+		background: rgb(15 23 42 / 58%);
+	}
+
+	.dialog {
+		width: min(480px, 100%);
+		max-height: calc(100dvh - 40px);
+		overflow: auto;
+		border: 1px solid #cbd5e1;
+		border-radius: 12px;
+		background: #f8fafc;
+		box-shadow: 0 24px 80px rgb(15 23 42 / 35%);
+		color: #0f172a;
+	}
+
+	.dark .dialog { border-color: #475569; background: #111827; color: #e2e8f0; }
+
+	header {
+		display: flex;
+		align-items: flex-start;
+		justify-content: space-between;
+		gap: 12px;
+		padding: 18px 20px 14px;
+		border-bottom: 1px solid #cbd5e1;
+		background: #e2e8f0;
+	}
+
+	.dark header { border-color: #334155; background: #1e293b; }
+	h2 { margin: 0; font-size: 20px; }
+	header p { margin: 4px 0 0; color: #64748b; font-size: 13px; }
+	.dark header p { color: #94a3b8; }
+
+	.close {
+		width: 30px;
+		height: 30px;
+		padding: 0;
+		border: 1px solid #94a3b8;
+		border-radius: 6px;
+		background: transparent;
+		color: inherit;
+		font-size: 22px;
+		line-height: 1;
+		cursor: pointer;
+	}
+
+	form { display: grid; gap: 9px; padding: 18px 20px 20px; }
+	label { color: #475569; font-size: 12px; font-weight: 750; }
+	.dark label { color: #cbd5e1; }
+	input {
+		width: 100%;
+		box-sizing: border-box;
+		padding: 10px 11px;
+		border: 1px solid #94a3b8;
+		border-radius: 7px;
+		background: white;
+		color: #0f172a;
+		font: inherit;
+		font-size: 16px;
+	}
+
+	.dark input { border-color: #64748b; background: #0f172a; color: #f8fafc; }
+	input:focus { border-color: #3b82f6; outline: 2px solid rgb(59 130 246 / 25%); outline-offset: 1px; }
+	input:disabled { opacity: 0.65; }
+	.hint, .suggestion-status { margin: 0; color: #64748b; font-size: 12px; line-height: 1.4; }
+	.dark .hint, .dark .suggestion-status { color: #94a3b8; }
+
+	.suggestions {
+		display: grid;
+		max-height: 250px;
+		overflow: auto;
+		padding: 4px;
+		border: 1px solid #cbd5e1;
+		border-radius: 8px;
+		background: white;
+	}
+
+	.dark .suggestions { border-color: #475569; background: #0f172a; }
+	.suggestion { display: flex; align-items: center; gap: 10px; width: 100%; padding: 8px; border: 0; border-radius: 6px; background: transparent; color: inherit; text-align: left; cursor: pointer; }
+	.suggestion:hover, .suggestion.active, .suggestion:focus-visible { background: #dbeafe; outline: 0; }
+	.dark .suggestion:hover, .dark .suggestion.active, .dark .suggestion:focus-visible { background: #1e3a5f; }
+	.avatar { position: relative; display: grid; width: 32px; height: 32px; flex: 0 0 32px; place-items: center; overflow: hidden; border-radius: 50%; background: #dbeafe; color: #1d4ed8; font-size: 13px; font-weight: 800; }
+	.dark .avatar { background: #1e3a5f; color: #bfdbfe; }
+	.avatar img { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }
+	.suggestion-copy { display: grid; min-width: 0; gap: 2px; }
+	.suggestion-copy strong, .suggestion-copy small { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+	.suggestion-copy strong { font-size: 13px; }
+	.suggestion-copy small { color: #64748b; font-size: 12px; }
+	.dark .suggestion-copy small { color: #94a3b8; }
+	.error { margin: 0; color: #b91c1c; font-size: 13px; }
+	.dark .error { color: #fca5a5; }
+
+	footer { display: flex; justify-content: flex-end; gap: 8px; margin-top: 5px; }
+	footer button { padding: 8px 12px; border: 1px solid #94a3b8; border-radius: 6px; font: inherit; font-size: 13px; font-weight: 700; cursor: pointer; }
+	footer button:disabled, .close:disabled { cursor: default; opacity: 0.55; }
+	.primary { border-color: #2563eb; background: #2563eb; color: white; }
+	.primary:hover:not(:disabled), .primary:focus-visible:not(:disabled) { background: #1d4ed8; }
+	.secondary { background: white; color: #334155; }
+	.dark .secondary { background: #1e293b; color: #e2e8f0; }
+	.secondary:hover:not(:disabled), .secondary:focus-visible:not(:disabled) { border-color: #3b82f6; }
+
+	@media (max-width: 520px) {
+		.backdrop { padding: 10px; }
+		.dialog { max-height: calc(100dvh - 20px); }
+	}
+</style>
diff --git a/apps/web/src/lib/components/Calculator3dShell.svelte b/apps/web/src/lib/components/Calculator3dShell.svelte
index e29bd0b..63caf4c 100644
--- a/apps/web/src/lib/components/Calculator3dShell.svelte
+++ b/apps/web/src/lib/components/Calculator3dShell.svelte
@@ -58,6 +58,7 @@
 	import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 	import type { PublishingOAuth } from '$lib/publishing/oauth';
 	import AppToolbar from './AppToolbar.svelte';
+	import AtprotoSignInDialog from './AtprotoSignInDialog.svelte';
 	import ExpressionPanel3d from './ExpressionPanel3d.svelte';
 	import GraphCanvas3d from './GraphCanvas3d.svelte';
 	import GraphLibrary from './GraphLibrary.svelte';
@@ -109,6 +110,9 @@
 	let accountHandle = $state<string | null>(null);
 	let accountBusy = $state(false);
 	let publishingBusy = $state(false);
+	let signInDialogOpen = $state(false);
+	let signInDialogPurpose = $state<'signin' | 'publish'>('signin');
+	let signInDialogError = $state('');
 	let publishedGraphs = $state<PublishedDocumentSummary[]>([]);
 	let publishedCursor = $state<string | null>(null);
 	let publishedLoading = $state(false);
@@ -389,26 +393,52 @@
 		return account.oauth;
 	}
 
-	async function signInAccount(): Promise<void> {
+	function openAtprotoSignIn(purpose: 'signin' | 'publish' = 'signin') {
+		if (accountBusy || publishingBusy) return;
+		if (purpose === 'signin' && publishingOAuth?.session) {
+			shareStatus = 'Already signed in with AT Protocol';
+			return;
+		}
+		signInDialogPurpose = purpose;
+		signInDialogError = '';
+		signInDialogOpen = true;
+	}
+
+	function closeAtprotoSignIn() {
+		if (accountBusy) return;
+		if (signInDialogPurpose === 'publish') {
+			window.sessionStorage.removeItem(PENDING_PUBLICATION_KEY);
+		}
+		signInDialogOpen = false;
+		signInDialogError = '';
+	}
+
+	async function submitAtprotoSignIn(identifier: string): Promise<void> {
 		if (accountBusy) return;
 		accountBusy = true;
+		signInDialogError = '';
 		try {
 			const oauth = await ensureAtprotoAccount();
 			if (oauth.session) {
+				signInDialogOpen = false;
 				shareStatus = 'Already signed in with AT Protocol';
 				return;
 			}
 			shareStatus = 'Opening AT Protocol authorization…';
-			const started = await beginAtprotoSignIn(oauth, 'signin');
-			if (!started) shareStatus = '';
+			await beginAtprotoSignIn(oauth, identifier, signInDialogPurpose);
 		} catch (error) {
-			shareStatus =
-				error instanceof Error ? error.message : 'Could not sign in with AT Protocol.';
+			const message = error instanceof Error ? error.message : 'Could not sign in with AT Protocol.';
+			signInDialogError = message;
+			shareStatus = message;
 		} finally {
 			accountBusy = false;
 		}
 	}
 
+	function signInAccount(): void {
+		openAtprotoSignIn('signin');
+	}
+
 	async function signOutAccount(): Promise<void> {
 		const oauth = publishingOAuth;
 		if (!oauth?.session || accountBusy) return;
@@ -458,9 +488,10 @@
 					PENDING_PUBLICATION_KEY,
 					JSON.stringify({ document: currentDocument(), presentation })
 				);
-				shareStatus = 'Opening AT Protocol authorization…';
-				const started = await beginAtprotoSignIn(oauth, 'publish');
-				if (!started) window.sessionStorage.removeItem(PENDING_PUBLICATION_KEY);
+				signInDialogPurpose = 'publish';
+				signInDialogError = '';
+				signInDialogOpen = true;
+				shareStatus = '';
 				return;
 			}
 			const preview = await graphCanvas.exportPreviewPng();
@@ -1179,6 +1210,14 @@
 		publicationurl={publicationUrl}
 	/>
 {/if}
+<AtprotoSignInDialog
+	open={signInDialogOpen}
+	purpose={signInDialogPurpose}
+	busy={accountBusy}
+	error={signInDialogError}
+	onconfirm={submitAtprotoSignIn}
+	onclose={closeAtprotoSignIn}
+/>
 
 <style>
 	:global(html), :global(body) { background: #f8fafc; }
diff --git a/apps/web/src/lib/components/CalculatorShell.svelte b/apps/web/src/lib/components/CalculatorShell.svelte
index dd5d104..d01478b 100644
--- a/apps/web/src/lib/components/CalculatorShell.svelte
+++ b/apps/web/src/lib/components/CalculatorShell.svelte
@@ -99,6 +99,7 @@
 import { encodePublishedDocument } from '$lib/document/document-link';
 import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 	import AppToolbar from './AppToolbar.svelte';
+	import AtprotoSignInDialog from './AtprotoSignInDialog.svelte';
 	import AnimationExportDialog from './AnimationExportDialog.svelte';
 	import ExpressionPanel from './ExpressionPanel.svelte';
 	import GraphCanvas from './GraphCanvas.svelte';
@@ -155,6 +156,9 @@ import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 	let publisherHandle = $state<string | null>(null);
 	let publishingError = $state('');
 	let publishingBusy = $state(false);
+	let signInDialogOpen = $state(false);
+	let signInDialogPurpose = $state<'signin' | 'publish'>('signin');
+	let signInDialogError = $state('');
 	let libraryOpen = $state(false);
 	let publishedGraphs = $state<PublishedDocumentSummary[]>([]);
 	let publishedCursor = $state<string | null>(null);
@@ -478,6 +482,48 @@ import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 		return account.oauth;
 	}
 
+	function openAtprotoSignIn(purpose: 'signin' | 'publish' = 'signin') {
+		if (publishingBusy) return;
+		if (purpose === 'signin' && publishingOAuth?.session) {
+			shareStatus = 'Already signed in with AT Protocol';
+			return;
+		}
+		signInDialogPurpose = purpose;
+		signInDialogError = '';
+		signInDialogOpen = true;
+	}
+
+	function closeAtprotoSignIn() {
+		if (publishingBusy) return;
+		if (signInDialogPurpose === 'publish') {
+			window.sessionStorage.removeItem(PENDING_PUBLICATION_KEY);
+		}
+		signInDialogOpen = false;
+		signInDialogError = '';
+	}
+
+	async function submitAtprotoSignIn(identifier: string): Promise<void> {
+		if (publishingBusy) return;
+		publishingBusy = true;
+		signInDialogError = '';
+		try {
+			const oauth = await ensureAtprotoAccount();
+			if (oauth.session) {
+				signInDialogOpen = false;
+				shareStatus = 'Already signed in with AT Protocol';
+				return;
+			}
+			shareStatus = 'Opening AT Protocol authorization…';
+			await beginAtprotoSignIn(oauth, identifier, signInDialogPurpose);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : 'Could not sign in with AT Protocol.';
+			signInDialogError = message;
+			shareStatus = message;
+		} finally {
+			publishingBusy = false;
+		}
+	}
+
 	function currentSnapshot(): GraphSnapshotV1 {
 		return createGraphSnapshot({
 			name: graphName,
@@ -828,9 +874,10 @@ import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 					PENDING_PUBLICATION_KEY,
 					JSON.stringify(currentSnapshot())
 				);
-				shareStatus = 'Opening AT Protocol authorization…';
-				const started = await beginAtprotoSignIn(oauth, 'publish');
-				if (!started) window.sessionStorage.removeItem(PENDING_PUBLICATION_KEY);
+				signInDialogPurpose = 'publish';
+				signInDialogError = '';
+				signInDialogOpen = true;
+				shareStatus = '';
 				return;
 			}
 
@@ -864,24 +911,8 @@ import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 		}
 	}
 
-	async function signInPublisher() {
-		if (publishingBusy) return;
-		publishingBusy = true;
-		try {
-			const oauth = await ensureAtprotoAccount();
-			if (oauth.session) {
-				shareStatus = 'Already signed in with AT Protocol';
-				return;
-			}
-			shareStatus = 'Opening AT Protocol authorization…';
-			const started = await beginAtprotoSignIn(oauth, 'signin');
-			if (!started) shareStatus = '';
-		} catch (error) {
-			shareStatus =
-				error instanceof Error ? error.message : publishingError || 'Could not sign in.';
-		} finally {
-			publishingBusy = false;
-		}
+	function signInPublisher() {
+		openAtprotoSignIn('signin');
 	}
 
 	async function signOutPublisher() {
@@ -1834,6 +1865,15 @@ import { createPublishedDocumentV2 } from '$lib/publication/document-v2';
 			publicationurl={publicationUrl}
 		/>
 	{/if}
+	<AtprotoSignInDialog
+		open={signInDialogOpen}
+		purpose={signInDialogPurpose}
+		dark={appearance.theme === 'dark'}
+		busy={publishingBusy}
+		error={signInDialogError}
+		onconfirm={submitAtprotoSignIn}
+		onclose={closeAtprotoSignIn}
+	/>
 	<AnimationExportDialog
 		open={animationExportOpen}
 		dark={appearance.theme === 'dark'}
diff --git a/apps/web/src/lib/publishing/atproto-account.test.ts b/apps/web/src/lib/publishing/atproto-account.test.ts
index 0f925b0..5743fa6 100644
--- a/apps/web/src/lib/publishing/atproto-account.test.ts
+++ b/apps/web/src/lib/publishing/atproto-account.test.ts
@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import type { PublishingOAuth } from './oauth';
 import {
@@ -14,10 +14,6 @@ function storage(value: string | null = null) {
 }
 
 describe('AT Protocol account helpers', () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
-
 	it('only initializes for a callback or a persisted account session', () => {
 		expect(
 			shouldInitializeAtprotoAccount(new URL('https://example.test/cartesium/3d'), storage())
@@ -36,25 +32,35 @@ describe('AT Protocol account helpers', () => {
 		).toBe(true);
 	});
 
-	it('returns false without starting authorization when the account prompt is cancelled', async () => {
+	it('rejects an empty explicit identifier without starting authorization', async () => {
 		const signIn = vi.fn();
-		vi.stubGlobal('window', { prompt: vi.fn(() => null) });
 		const oauth = {
 			client: { signIn }
 		} as unknown as PublishingOAuth;
 
-		await expect(beginAtprotoSignIn(oauth)).resolves.toBe(false);
+		await expect(beginAtprotoSignIn(oauth, ' @ ')).rejects.toThrow(
+			'Enter an AT Protocol handle or DID.'
+		);
 		expect(signIn).not.toHaveBeenCalled();
 	});
 
 	it('normalizes the account identifier and forwards the requested OAuth state', async () => {
 		const signIn = vi.fn().mockResolvedValue(undefined);
-		vi.stubGlobal('window', { prompt: vi.fn(() => '@alice.test') });
 		const oauth = {
 			client: { signIn }
 		} as unknown as PublishingOAuth;
 
-		await expect(beginAtprotoSignIn(oauth, 'signin')).resolves.toBe(true);
+		await beginAtprotoSignIn(oauth, ' @alice.test ', 'signin');
 		expect(signIn).toHaveBeenCalledWith('alice.test', { state: 'signin' });
 	});
+
+	it('preserves a DID identifier for OAuth', async () => {
+		const signIn = vi.fn().mockResolvedValue(undefined);
+		const oauth = {
+			client: { signIn }
+		} as unknown as PublishingOAuth;
+
+		await beginAtprotoSignIn(oauth, ' did:plc:abcdefghijklmnopqrstuvwxyz ');
+		expect(signIn).toHaveBeenCalledWith('did:plc:abcdefghijklmnopqrstuvwxyz', { state: 'signin' });
+	});
 });
diff --git a/apps/web/src/lib/publishing/atproto-account.ts b/apps/web/src/lib/publishing/atproto-account.ts
index 18d5f95..a0deeee 100644
--- a/apps/web/src/lib/publishing/atproto-account.ts
+++ b/apps/web/src/lib/publishing/atproto-account.ts
@@ -43,14 +43,16 @@ export async function initializeAtprotoAccount(): Promise<AtprotoAccountInitiali
 
 export async function beginAtprotoSignIn(
 	oauth: PublishingOAuth,
+	accountIdentifier: string,
 	state: 'publish' | 'signin' = 'signin'
-): Promise<boolean> {
-	const account = window.prompt('AT Protocol handle or DID:');
-	if (account === null) return false;
-	const identifier = account.trim().replace(/^@/, '');
+): Promise<void> {
+	const identifier = normalizeAtprotoIdentifier(accountIdentifier);
 	if (!identifier) throw new Error('Enter an AT Protocol handle or DID.');
 	await oauth.client.signIn(identifier, { state });
-	return true;
+}
+
+export function normalizeAtprotoIdentifier(value: string): string {
+	return value.trim().replace(/^@/, '');
 }
 
 export async function signOutAtprotoAccount(oauth: PublishingOAuth): Promise<void> {
diff --git a/apps/web/src/lib/publishing/handle-suggestions.test.ts b/apps/web/src/lib/publishing/handle-suggestions.test.ts
new file mode 100644
index 0000000..043d55e
--- /dev/null
+++ b/apps/web/src/lib/publishing/handle-suggestions.test.ts
@@ -0,0 +1,174 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+	searchActorSuggestions,
+	type ActorSuggestion
+} from './handle-suggestions';
+
+const typeaheadEndpoint = 'https://typeahead.example/xrpc/search';
+const blueskyEndpoint = 'https://bsky.example/xrpc/search';
+
+function actor(overrides: Partial<ActorSuggestion> = {}): ActorSuggestion {
+	return {
+		did: 'did:plc:alice',
+		handle: 'alice.example',
+		displayName: 'Alice',
+		...overrides
+	};
+}
+
+function jsonResponse(value: unknown, status = 200): Response {
+	return new Response(JSON.stringify(value), {
+		status,
+		headers: { 'content-type': 'application/json' }
+	});
+}
+
+describe('AT Protocol actor suggestions', () => {
+	it('uses Typeahead first and normalizes the returned actor list', async () => {
+		const fetcher = vi.fn().mockResolvedValue(
+			jsonResponse({
+				actors: [
+					{ ...actor(), avatar: 'https://cdn.example/alice.png' },
+					{ ...actor(), did: 'did:plc:bob', handle: '@bob.example', displayName: null },
+					{ did: 'not-a-did', handle: 'ignored.example' }
+				]
+			})
+		);
+
+		const result = await searchActorSuggestions('@ali', {
+			fetcher,
+			typeaheadEndpoint,
+			blueskyEndpoint
+		});
+
+		expect(result).toEqual({
+			source: 'typeahead',
+			actors: [
+				{ ...actor(), avatar: 'https://cdn.example/alice.png' },
+				{ did: 'did:plc:bob', handle: 'bob.example' }
+			]
+		});
+		expect(fetcher).toHaveBeenCalledTimes(1);
+		const url = new URL(String(fetcher.mock.calls[0][0]));
+		expect(url.origin + url.pathname).toBe(typeaheadEndpoint);
+		expect(url.searchParams.get('q')).toBe('ali');
+		expect(url.searchParams.get('limit')).toBe('8');
+		expect(fetcher.mock.calls[0][1]).toMatchObject({
+			method: 'GET',
+			credentials: 'omit'
+		});
+	});
+
+	it('falls back to Bluesky when Typeahead fails', async () => {
+		const fetcher = vi
+			.fn()
+			.mockResolvedValueOnce(jsonResponse({ error: 'unavailable' }, 503))
+			.mockResolvedValueOnce(jsonResponse({ actors: [actor()] }));
+
+		await expect(
+			searchActorSuggestions('ali', {
+				fetcher,
+				typeaheadEndpoint,
+				blueskyEndpoint
+			})
+		).resolves.toEqual({ source: 'bluesky', actors: [actor()] });
+		expect(fetcher).toHaveBeenCalledTimes(2);
+		expect(String(fetcher.mock.calls[1][0])).toContain(blueskyEndpoint);
+	});
+
+	it('falls back when the primary response is malformed', async () => {
+		const fetcher = vi
+			.fn()
+			.mockResolvedValueOnce(jsonResponse({ results: [] }))
+			.mockResolvedValueOnce(jsonResponse({ actors: [actor()] }));
+
+		await expect(
+			searchActorSuggestions('ali', {
+				fetcher,
+				typeaheadEndpoint,
+				blueskyEndpoint
+			})
+		).resolves.toMatchObject({ source: 'bluesky' });
+	});
+
+	it('falls back when the primary provider times out', async () => {
+		const fetcher = vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+			if (String(input).startsWith(typeaheadEndpoint)) {
+				return new Promise<Response>((_resolve, reject) => {
+					init?.signal?.addEventListener('abort', () => {
+						const error = new Error('timed out');
+						error.name = 'AbortError';
+						reject(error);
+					});
+				});
+			}
+			return Promise.resolve(jsonResponse({ actors: [actor()] }));
+		});
+
+		await expect(
+			searchActorSuggestions('ali', {
+				fetcher,
+				typeaheadEndpoint,
+				blueskyEndpoint,
+				timeoutMs: 5
+			})
+		).resolves.toEqual({ source: 'bluesky', actors: [actor()] });
+		expect(fetcher).toHaveBeenCalledTimes(2);
+	});
+
+	it('does not query the backup for a valid empty primary result', async () => {
+		const fetcher = vi.fn().mockResolvedValue(jsonResponse({ actors: [] }));
+
+		await expect(
+			searchActorSuggestions('missing', {
+				fetcher,
+				typeaheadEndpoint,
+				blueskyEndpoint
+			})
+		).resolves.toEqual({ source: 'typeahead', actors: [] });
+		expect(fetcher).toHaveBeenCalledTimes(1);
+	});
+
+	it('does not query for short input, empty input, or a DID', async () => {
+		const fetcher = vi.fn();
+
+		await expect(searchActorSuggestions('a', { fetcher })).resolves.toEqual({
+			source: 'none',
+			actors: []
+		});
+		await expect(searchActorSuggestions('  ', { fetcher })).resolves.toEqual({
+			source: 'none',
+			actors: []
+		});
+		await expect(
+			searchActorSuggestions('did:plc:alice', { fetcher })
+		).resolves.toEqual({ source: 'none', actors: [] });
+		expect(fetcher).not.toHaveBeenCalled();
+	});
+
+	it('propagates caller cancellation without trying the backup', async () => {
+		const controller = new AbortController();
+		const fetcher = vi.fn((_input: RequestInfo | URL, init?: RequestInit) => {
+			return new Promise<Response>((_resolve, reject) => {
+				init?.signal?.addEventListener('abort', () => {
+					const error = new Error('aborted');
+					error.name = 'AbortError';
+					reject(error);
+				});
+			});
+		});
+
+		const request = searchActorSuggestions('ali', {
+			fetcher,
+			signal: controller.signal,
+			typeaheadEndpoint,
+			blueskyEndpoint,
+			timeoutMs: 100
+		});
+		controller.abort();
+
+		await expect(request).rejects.toMatchObject({ name: 'AbortError' });
+		expect(fetcher).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/apps/web/src/lib/publishing/handle-suggestions.ts b/apps/web/src/lib/publishing/handle-suggestions.ts
new file mode 100644
index 0000000..8dcfeab
--- /dev/null
+++ b/apps/web/src/lib/publishing/handle-suggestions.ts
@@ -0,0 +1,193 @@
+export const TYPEAHEAD_ACTOR_SEARCH_ENDPOINT =
+	'https://typeahead.waow.tech/xrpc/app.bsky.actor.searchActorsTypeahead';
+export const BLUESKY_ACTOR_SEARCH_ENDPOINT =
+	'https://public.api.bsky.app/xrpc/app.bsky.actor.searchActorsTypeahead';
+export const ACTOR_SUGGESTION_LIMIT = 8;
+export const ACTOR_SUGGESTION_MIN_LENGTH = 2;
+export const ACTOR_SUGGESTION_TIMEOUT_MS = 3_000;
+
+export interface ActorSuggestion {
+	did: string;
+	handle: string;
+	displayName?: string;
+	avatar?: string;
+}
+
+export type ActorSuggestionSource = 'none' | 'typeahead' | 'bluesky';
+
+export interface ActorSuggestionResult {
+	actors: ActorSuggestion[];
+	source: ActorSuggestionSource;
+}
+
+export interface ActorSuggestionSearchOptions {
+	fetcher?: typeof globalThis.fetch;
+	signal?: AbortSignal;
+	typeaheadEndpoint?: string;
+	blueskyEndpoint?: string;
+	limit?: number;
+	timeoutMs?: number;
+}
+
+export function normalizeActorSuggestionQuery(value: string): string {
+	return value.trim().replace(/^@/, '').trim();
+}
+
+export async function searchActorSuggestions(
+	query: string,
+	options: ActorSuggestionSearchOptions = {}
+): Promise<ActorSuggestionResult> {
+	const normalizedQuery = normalizeActorSuggestionQuery(query);
+	if (
+		normalizedQuery.length < ACTOR_SUGGESTION_MIN_LENGTH ||
+		normalizedQuery.toLowerCase().startsWith('did:')
+	) {
+		return { actors: [], source: 'none' };
+	}
+
+	const limit = clampLimit(options.limit ?? ACTOR_SUGGESTION_LIMIT);
+	const requestOptions = {
+		fetcher: options.fetcher ?? globalThis.fetch,
+		signal: options.signal,
+		limit,
+		timeoutMs: options.timeoutMs ?? ACTOR_SUGGESTION_TIMEOUT_MS
+	};
+
+	try {
+		return {
+			actors: await fetchActorSuggestions(
+				options.typeaheadEndpoint ?? TYPEAHEAD_ACTOR_SEARCH_ENDPOINT,
+				normalizedQuery,
+				requestOptions
+			),
+			source: 'typeahead'
+		};
+	} catch (error) {
+		if (isAbortError(error) || options.signal?.aborted) throw error;
+	}
+
+	return {
+		actors: await fetchActorSuggestions(
+			options.blueskyEndpoint ?? BLUESKY_ACTOR_SEARCH_ENDPOINT,
+			normalizedQuery,
+			requestOptions
+		),
+		source: 'bluesky'
+	};
+}
+
+interface FetchActorSuggestionsOptions {
+	fetcher: typeof globalThis.fetch;
+	signal?: AbortSignal;
+	limit: number;
+	timeoutMs: number;
+}
+
+async function fetchActorSuggestions(
+	endpoint: string,
+	query: string,
+	options: FetchActorSuggestionsOptions
+): Promise<ActorSuggestion[]> {
+	const url = new URL(endpoint);
+	url.searchParams.set('q', query);
+	url.searchParams.set('limit', String(options.limit));
+
+	if (options.signal?.aborted) throw createAbortError();
+
+	const controller = new AbortController();
+	let timedOut = false;
+	const abortFromCaller = () => controller.abort();
+	options.signal?.addEventListener('abort', abortFromCaller, { once: true });
+	const timeout = setTimeout(() => {
+		timedOut = true;
+		controller.abort();
+	}, options.timeoutMs);
+
+	try {
+		const response = await options.fetcher(url, {
+			method: 'GET',
+			headers: { accept: 'application/json' },
+			credentials: 'omit',
+			signal: controller.signal
+		});
+		if (!response.ok) {
+			throw new Error(`Actor search provider returned HTTP ${response.status}.`);
+		}
+		return parseActorSuggestions(await response.json(), options.limit);
+	} catch (error) {
+		if (options.signal?.aborted) throw createAbortError();
+		if (timedOut) throw new Error('Actor search provider timed out.');
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		options.signal?.removeEventListener('abort', abortFromCaller);
+	}
+}
+
+function parseActorSuggestions(value: unknown, limit: number): ActorSuggestion[] {
+	if (!isRecord(value) || !Array.isArray(value.actors)) {
+		throw new Error('Actor search provider returned an invalid response.');
+	}
+
+	const actors: ActorSuggestion[] = [];
+	const seenDids = new Set<string>();
+	for (const candidate of value.actors) {
+		if (!isRecord(candidate)) continue;
+		const did = typeof candidate.did === 'string' ? candidate.did.trim() : '';
+		const handle =
+			typeof candidate.handle === 'string'
+				? candidate.handle.trim().replace(/^@/, '')
+				: '';
+		if (!/^did:[^\s]+$/i.test(did) || !isUsableHandle(handle) || seenDids.has(did)) continue;
+		seenDids.add(did);
+		actors.push({
+			did,
+			handle,
+			...(usableString(candidate.displayName) ? { displayName: candidate.displayName.trim() } : {}),
+			...(usableAvatar(candidate.avatar) ? { avatar: candidate.avatar } : {})
+		});
+		if (actors.length === limit) break;
+	}
+
+	if (value.actors.length > 0 && actors.length === 0) {
+		throw new Error('Actor search provider returned no valid actors.');
+	}
+	return actors;
+}
+
+function clampLimit(value: number): number {
+	if (!Number.isFinite(value)) return ACTOR_SUGGESTION_LIMIT;
+	return Math.max(1, Math.min(100, Math.floor(value)));
+}
+
+function isUsableHandle(value: string): boolean {
+	return value.length > 0 && value.length <= 253 && !/\s/.test(value);
+}
+
+function usableString(value: unknown): value is string {
+	return typeof value === 'string' && value.trim().length > 0;
+}
+
+function usableAvatar(value: unknown): value is string {
+	if (!usableString(value)) return false;
+	try {
+		const url = new URL(value);
+		return url.protocol === 'https:' || url.protocol === 'http:';
+	} catch {
+		return false;
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isAbortError(error: unknown): boolean {
+	return error instanceof Error && error.name === 'AbortError';
+}
+
+function createAbortError(): Error {
+	const error = new Error('Actor search was cancelled.');
+	error.name = 'AbortError';
+	return error;
+}