birdclaw 0.5.1 → 0.7.0

package/src/lib/archive-import.ts

@@ -11,8 +11,11 @@ import {
 import path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
+import { Effect } from "effect";
 import { getBirdclawPaths } from "./config";
 import { getNativeDb } from "./db";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
+import { safeHttpUrl } from "./url-safety";
 
 const execFileAsync = promisify(execFile);
 const ARCHIVE_JSON_PAYLOAD = /=\s*(\[[\s\S]*\]|\{[\s\S]*\})/s;
@@ -58,8 +61,45 @@ export const ARCHIVE_IMPORT_SLICES = [
 
 export type ArchiveImportSlice = (typeof ARCHIVE_IMPORT_SLICES)[number];
 
+export type ImportProgressSlice =
+	| "tweets"
+	| "noteTweets"
+	| "directMessages"
+	| "likes"
+	| "bookmarks"
+	| "media"
+	| "followers"
+	| "following";
+
+export type ImportWritePhase =
+	| "profiles"
+	| "tweets"
+	| "collections"
+	| "dmMessages";
+
+export type ImportProgressEvent =
+	| { kind: "scanned"; entryCount: number }
+	| { kind: "slice-start"; slice: ImportProgressSlice; files: number }
+	| {
+			kind: "slice-file";
+			slice: ImportProgressSlice;
+			processed: number;
+			files: number;
+	  }
+	| { kind: "slice-done"; slice: ImportProgressSlice; count: number }
+	| { kind: "writing" }
+	| { kind: "write-start"; phase: ImportWritePhase; total: number }
+	| {
+			kind: "write-progress";
+			phase: ImportWritePhase;
+			processed: number;
+			total: number;
+	  }
+	| { kind: "done" };
+
 export interface ImportArchiveOptions {
 	select?: ArchiveImportSlice[];
+	onProgress?: (event: ImportProgressEvent) => void;
 }
 
 type ArchiveRecord = Record<string, unknown>;
@@ -108,48 +148,60 @@ function parseArchiveArray(content: string): ArchiveRecord[] {
 		: [];
 }
 
-async function runUnzip(
+function runUnzipEffect(
 	_archivePath: string,
 	args: string[],
 	maxBuffer = 1024 * 1024 * 256,
 ) {
-	const { stdout } = await execFileAsync("unzip", args, {
-		maxBuffer,
-	});
-	return stdout;
+	return tryPromise(() =>
+		execFileAsync("unzip", args, {
+			maxBuffer,
+		}),
+	).pipe(Effect.map(({ stdout }) => stdout));
 }
 
-async function listArchiveEntries(archivePath: string) {
-	const stdout = await runUnzip(
-		archivePath,
-		["-Z1", archivePath],
-		1024 * 1024 * 64,
-	);
-	return stdout
-		.split("\n")
-		.map((item) => item.trim())
-		.filter((item) => item.length > 0);
+function listArchiveEntriesEffect(
+	archivePath: string,
+): Effect.Effect<string[], unknown> {
+	return Effect.gen(function* () {
+		const stdout = yield* runUnzipEffect(
+			archivePath,
+			["-Z1", archivePath],
+			1024 * 1024 * 64,
+		);
+		return stdout
+			.split("\n")
+			.map((item) => item.trim())
+			.filter((item) => item.length > 0);
+	});
 }
 
-async function listArchiveEntryDetails(archivePath: string) {
-	const stdout = await runUnzip(
-		archivePath,
-		["-Z", "-l", archivePath],
-		1024 * 1024 * 64,
-	);
-	return stdout
-		.split("\n")
-		.map((line) => line.trim().split(/\s+/))
-		.filter((parts) => parts.length >= 10 && /^[-d]/.test(parts[0] ?? ""))
-		.map((parts) => ({
-			path: parts.slice(9).join(" "),
-			size: Number(parts[3] ?? 0),
-		}))
-		.filter((entry) => entry.path.length > 0 && Number.isFinite(entry.size));
+function listArchiveEntryDetailsEffect(
+	archivePath: string,
+): Effect.Effect<Array<{ path: string; size: number }>, unknown> {
+	return Effect.gen(function* () {
+		const stdout = yield* runUnzipEffect(
+			archivePath,
+			["-Z", "-l", archivePath],
+			1024 * 1024 * 64,
+		);
+		return stdout
+			.split("\n")
+			.map((line) => line.trim().split(/\s+/))
+			.filter((parts) => parts.length >= 10 && /^[-d]/.test(parts[0] ?? ""))
+			.map((parts) => ({
+				path: parts.slice(9).join(" "),
+				size: Number(parts[3] ?? 0),
+			}))
+			.filter((entry) => entry.path.length > 0 && Number.isFinite(entry.size));
+	});
 }
 
-async function readArchiveEntry(archivePath: string, entryPath: string) {
-	return runUnzip(archivePath, ["-p", archivePath, entryPath]);
+function readArchiveEntryEffect(
+	archivePath: string,
+	entryPath: string,
+): Effect.Effect<string, unknown> {
+	return runUnzipEffect(archivePath, ["-p", archivePath, entryPath]);
 }
 
 function getFirstEntry(entries: string[], pattern: RegExp) {
@@ -216,6 +268,10 @@ function toFiniteNumber(value: unknown) {
 	return Number.isFinite(number) ? number : undefined;
 }
 
+function archiveHttpUrl(value: unknown) {
+	return safeHttpUrl(typeof value === "string" ? value : String(value ?? ""));
+}
+
 function extractTweetEntities(tweet: Record<string, unknown>) {
 	const entities = asRecord(tweet.entities);
 	const urlEntries = [
@@ -225,10 +281,10 @@ function extractTweetEntities(tweet: Record<string, unknown>) {
 	const seenUrls = new Set<string>();
 	const urls = urlEntries
 		.map((entry) => ({
-			url: String(entry.url ?? ""),
-			expandedUrl: String(
-				entry.expanded_url ?? entry.expandedUrl ?? entry.url ?? "",
-			),
+			url: archiveHttpUrl(entry.url) ?? "",
+			expandedUrl:
+				archiveHttpUrl(entry.expanded_url ?? entry.expandedUrl ?? entry.url) ??
+				"",
 			displayUrl: String(
 				entry.display_url ??
 					entry.displayUrl ??
@@ -242,17 +298,13 @@ function extractTweetEntities(tweet: Record<string, unknown>) {
 			description:
 				typeof entry.description === "string" ? entry.description : null,
 			imageUrl:
-				typeof entry.image_url === "string"
-					? entry.image_url
-					: typeof entry.imageUrl === "string"
-						? entry.imageUrl
-						: typeof entry.thumbnail_url === "string"
-							? entry.thumbnail_url
-							: typeof entry.media_url_https === "string"
-								? entry.media_url_https
-								: typeof entry.media_url === "string"
-									? entry.media_url
-									: undefined,
+				archiveHttpUrl(
+					entry.image_url ??
+						entry.imageUrl ??
+						entry.thumbnail_url ??
+						entry.media_url_https ??
+						entry.media_url,
+				) ?? undefined,
 			siteName:
 				typeof entry.site_name === "string"
 					? entry.site_name
@@ -356,12 +408,11 @@ function extractTweetMedia(tweet: Record<string, unknown>) {
 
 	return sourceMedia
 		.map((entry) => {
-			const url = String(
-				entry.media_url_https ?? entry.media_url ?? entry.url ?? "",
-			);
-			const thumbnailUrl = String(
-				entry.media_url_https ?? entry.media_url ?? url,
-			);
+			const url =
+				archiveHttpUrl(entry.media_url_https ?? entry.media_url ?? entry.url) ??
+				"";
+			const thumbnailUrl =
+				archiveHttpUrl(entry.media_url_https ?? entry.media_url ?? url) ?? url;
 			const videoInfo = asRecord(entry.video_info);
 			const durationMs = toFiniteNumber(videoInfo?.duration_millis);
 			const variants = archiveMp4Variants(entry);
@@ -515,66 +566,78 @@ function needsArchiveMediaCopy(destinationPath: string, size: number) {
 	return statSync(destinationPath).size !== size;
 }
 
-async function copyArchiveEntryToFile(
+function copyArchiveEntryToFileEffect(
 	archivePath: string,
 	entryPath: string,
 	destinationPath: string,
 ) {
-	mkdirSync(path.dirname(destinationPath), { recursive: true });
-	const temporaryPath = `${destinationPath}.${process.pid}.${randomUUID()}.tmp`;
-	const child = spawn("unzip", ["-p", archivePath, entryPath], {
-		stdio: ["ignore", "pipe", "pipe"],
-	});
-	let stderr = "";
-	child.stderr.setEncoding("utf8");
-	child.stderr.on("data", (chunk) => {
-		stderr += String(chunk);
-	});
-	const exit = new Promise<number | null>((resolve, reject) => {
-		child.on("error", reject);
-		child.on("close", resolve);
-	});
+	return tryPromise(() => {
+		mkdirSync(path.dirname(destinationPath), { recursive: true });
+		const temporaryPath = `${destinationPath}.${process.pid}.${randomUUID()}.tmp`;
+		const child = spawn("unzip", ["-p", archivePath, entryPath], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let stderr = "";
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk) => {
+			stderr += String(chunk);
+		});
+		const exit = new Promise<number | null>((resolve, reject) => {
+			child.on("error", reject);
+			child.on("close", resolve);
+		});
 
-	try {
-		await pipeline(child.stdout, createWriteStream(temporaryPath));
-		const exitCode = await exit;
-		if (exitCode !== 0) {
-			throw new Error(
-				`Failed to extract ${entryPath}: ${stderr.trim() || `exit ${String(exitCode)}`}`,
-			);
-		}
-		renameSync(temporaryPath, destinationPath);
-	} catch (error) {
-		child.kill();
-		if (existsSync(temporaryPath)) {
-			unlinkSync(temporaryPath);
-		}
-		throw error;
-	}
+		return pipeline(child.stdout, createWriteStream(temporaryPath))
+			.then(() => exit)
+			.then((exitCode) => {
+				if (exitCode !== 0) {
+					throw new Error(
+						`Failed to extract ${entryPath}: ${
+							stderr.trim() || `exit ${String(exitCode)}`
+						}`,
+					);
+				}
+				renameSync(temporaryPath, destinationPath);
+			})
+			.catch((error: unknown) => {
+				child.kill();
+				if (existsSync(temporaryPath)) {
+					unlinkSync(temporaryPath);
+				}
+				throw error;
+			});
+	});
 }
 
-async function extractArchiveMediaFiles(
+function extractArchiveMediaFilesEffect(
 	archivePath: string,
 	selectedKinds: Set<ArchiveMediaKind> | null,
-) {
-	const counts = createArchiveMediaFileCounts();
-	if (selectedKinds?.size === 0) {
+): Effect.Effect<ArchiveMediaFileCounts, unknown> {
+	return Effect.gen(function* () {
+		const counts = createArchiveMediaFileCounts();
+		if (selectedKinds?.size === 0) {
+			return counts;
+		}
+		const entries = yield* listArchiveEntryDetailsEffect(archivePath);
+		for (const entry of entries) {
+			const mediaKind = getArchiveMediaKind(entry.path);
+			if (!mediaKind) continue;
+			if (selectedKinds && !selectedKinds.has(mediaKind.kind)) continue;
+
+			counts[mediaKind.kind] += 1;
+			const destinationPath = getArchiveMediaDestination(
+				entry.path,
+				mediaKind.kind,
+			);
+			if (!needsArchiveMediaCopy(destinationPath, entry.size)) continue;
+			yield* copyArchiveEntryToFileEffect(
+				archivePath,
+				entry.path,
+				destinationPath,
+			);
+		}
 		return counts;
-	}
-	for (const entry of await listArchiveEntryDetails(archivePath)) {
-		const mediaKind = getArchiveMediaKind(entry.path);
-		if (!mediaKind) continue;
-		if (selectedKinds && !selectedKinds.has(mediaKind.kind)) continue;
-
-		counts[mediaKind.kind] += 1;
-		const destinationPath = getArchiveMediaDestination(
-			entry.path,
-			mediaKind.kind,
-		);
-		if (!needsArchiveMediaCopy(destinationPath, entry.size)) continue;
-		await copyArchiveEntryToFile(archivePath, entry.path, destinationPath);
-	}
-	return counts;
+	});
 }
 
 function getArchiveFollowRows(content: string, key: ArchiveFollowKey) {
@@ -594,8 +657,7 @@ function getArchiveFollowRows(content: string, key: ArchiveFollowKey) {
 	return rows;
 }
 
-function clearImportedData() {
-	const db = getNativeDb();
+function clearImportedData(db = getNativeDb()) {
 	db.exec(`
     delete from ai_scores;
     delete from tweet_actions;
@@ -632,894 +694,1062 @@ function clearMentionSyncState(db = getNativeDb()) {
 	).run();
 }
 
-export async function importArchive(
+function importArchiveInternalEffect(
 	archivePath: string,
 	options: ImportArchiveOptions = {},
-): Promise<ImportedArchiveSummary> {
-	const entries = await listArchiveEntries(archivePath);
-	const selection = selectedSlices(options);
-	const includeTweets = includesSlice(selection, "tweets");
-	const includeLikes = includesSlice(selection, "likes");
-	const includeBookmarks = includesSlice(selection, "bookmarks");
-	const includeDirectMessages = includesSlice(selection, "directMessages");
-	const includeProfiles = includesSlice(selection, "profiles");
-	const includeFollowers = includesSlice(selection, "followers");
-	const includeFollowing = includesSlice(selection, "following");
-	const accountEntry = getFirstEntry(entries, /(?:^|\/)data\/account\.js$/i);
-	const profileEntry = getFirstEntry(entries, /(?:^|\/)data\/profile\.js$/i);
-	const tweetEntries = includeTweets
-		? getMatchingEntries(
-				entries,
-				/(?:^|\/)data\/(?:tweets|community-tweet)(?:-part\d+)?\.js$/i,
-			)
-		: [];
-	const noteTweetEntries = includeTweets
-		? getMatchingEntries(entries, /(?:^|\/)data\/note-tweet(?:-part\d+)?\.js$/i)
-		: [];
-	const likeEntries = includeLikes
-		? getMatchingEntries(
-				entries,
-				/(?:^|\/)data\/(?:like|likes)(?:-part\d+)?\.js$/i,
-			)
-		: [];
-	const bookmarkEntries = includeBookmarks
-		? getMatchingEntries(
-				entries,
-				/(?:^|\/)data\/(?:bookmark|bookmarks)(?:-part\d+)?\.js$/i,
-			)
-		: [];
-	const dmEntries = includeDirectMessages
-		? getMatchingEntries(
-				entries,
-				/(?:^|\/)data\/direct-messages(?:-group)?(?:-part\d+)?\.js$/i,
-			)
-		: [];
-	const followerEntries = includeFollowers
-		? getMatchingEntries(entries, /(?:^|\/)data\/follower(?:-part\d+)?\.js$/i)
-		: [];
-	const followingEntries = includeFollowing
-		? getMatchingEntries(entries, /(?:^|\/)data\/following(?:-part\d+)?\.js$/i)
-		: [];
+): Effect.Effect<ImportedArchiveSummary, unknown> {
+	return Effect.gen(function* () {
+		const onProgress = options.onProgress ?? (() => {});
+		const entries = yield* listArchiveEntriesEffect(archivePath);
+		onProgress({ kind: "scanned", entryCount: entries.length });
+		const selection = selectedSlices(options);
+		const includeTweets = includesSlice(selection, "tweets");
+		const includeLikes = includesSlice(selection, "likes");
+		const includeBookmarks = includesSlice(selection, "bookmarks");
+		const includeDirectMessages = includesSlice(selection, "directMessages");
+		const includeProfiles = includesSlice(selection, "profiles");
+		const includeFollowers = includesSlice(selection, "followers");
+		const includeFollowing = includesSlice(selection, "following");
+		const accountEntry = getFirstEntry(entries, /(?:^|\/)data\/account\.js$/i);
+		const profileEntry = getFirstEntry(entries, /(?:^|\/)data\/profile\.js$/i);
+		const tweetEntries = includeTweets
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/(?:tweets|community-tweet)(?:-part\d+)?\.js$/i,
+				)
+			: [];
+		const noteTweetEntries = includeTweets
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/note-tweet(?:-part\d+)?\.js$/i,
+				)
+			: [];
+		const likeEntries = includeLikes
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/(?:like|likes)(?:-part\d+)?\.js$/i,
+				)
+			: [];
+		const bookmarkEntries = includeBookmarks
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/(?:bookmark|bookmarks)(?:-part\d+)?\.js$/i,
+				)
+			: [];
+		const dmEntries = includeDirectMessages
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/direct-messages(?:-group)?(?:-part\d+)?\.js$/i,
+				)
+			: [];
+		const followerEntries = includeFollowers
+			? getMatchingEntries(entries, /(?:^|\/)data\/follower(?:-part\d+)?\.js$/i)
+			: [];
+		const followingEntries = includeFollowing
+			? getMatchingEntries(
+					entries,
+					/(?:^|\/)data\/following(?:-part\d+)?\.js$/i,
+				)
+			: [];
 
-	if (!accountEntry) {
-		throw new Error("Archive missing data/account.js");
-	}
+		if (!accountEntry) {
+			return yield* Effect.fail(new Error("Archive missing data/account.js"));
+		}
 
-	const [accountContent, profileContent] = await Promise.all([
-		readArchiveEntry(archivePath, accountEntry),
-		profileEntry
-			? readArchiveEntry(archivePath, profileEntry)
-			: Promise.resolve("[]"),
-	]);
+		const [accountContent, profileContent] = yield* Effect.all([
+			readArchiveEntryEffect(archivePath, accountEntry),
+			profileEntry
+				? readArchiveEntryEffect(archivePath, profileEntry)
+				: Effect.succeed("[]"),
+		]);
 
-	const accountPayload = buildAccountPayload(
-		parseArchiveArray(accountContent)[0] ?? null,
-		parseArchiveArray(profileContent)[0] ?? null,
-	);
+		const accountPayload = buildAccountPayload(
+			parseArchiveArray(accountContent)[0] ?? null,
+			parseArchiveArray(profileContent)[0] ?? null,
+		);
 
-	const mentionDirectory = new Map<
-		string,
-		{ handle?: string; displayName?: string }
-	>();
-	const tweetRows: Array<{
-		id: string;
-		kind: "home" | "like" | "bookmark";
-		authorProfileId: string;
-		text: string;
-		createdAt: string;
-		isReplied: number;
-		replyToId: string | null;
-		likeCount: number;
-		mediaCount: number;
-		bookmarked: number;
-		liked: number;
-		entitiesJson: string;
-		mediaJson: string;
-		quotedTweetId: string | null;
-	}> = [];
-	const collectionRows: Array<{
-		tweetId: string;
-		kind: "likes" | "bookmarks";
-		collectedAt: string | null;
-		source: string;
-		rawJson: string;
-	}> = [];
-	const tweetRowsById = new Map<string, (typeof tweetRows)[number]>();
-
-	function addTweetRow(row: (typeof tweetRows)[number]) {
-		const existing = tweetRowsById.get(row.id);
-		if (existing) {
-			existing.bookmarked = Math.max(existing.bookmarked, row.bookmarked);
-			existing.liked = Math.max(existing.liked, row.liked);
-			if (!existing.text && row.text) existing.text = row.text;
-			return;
+		const mentionDirectory = new Map<
+			string,
+			{ handle?: string; displayName?: string }
+		>();
+		const tweetRows: Array<{
+			id: string;
+			kind: "home" | "like" | "bookmark";
+			authorProfileId: string;
+			text: string;
+			createdAt: string;
+			isReplied: number;
+			replyToId: string | null;
+			likeCount: number;
+			mediaCount: number;
+			bookmarked: number;
+			liked: number;
+			entitiesJson: string;
+			mediaJson: string;
+			quotedTweetId: string | null;
+		}> = [];
+		const collectionRows: Array<{
+			tweetId: string;
+			kind: "likes" | "bookmarks";
+			collectedAt: string | null;
+			source: string;
+			rawJson: string;
+		}> = [];
+		const tweetRowsById = new Map<string, (typeof tweetRows)[number]>();
+
+		function addTweetRow(row: (typeof tweetRows)[number]) {
+			const existing = tweetRowsById.get(row.id);
+			if (existing) {
+				existing.bookmarked = Math.max(existing.bookmarked, row.bookmarked);
+				existing.liked = Math.max(existing.liked, row.liked);
+				if (!existing.text && row.text) existing.text = row.text;
+				return;
+			}
+			tweetRows.push(row);
+			tweetRowsById.set(row.id, row);
 		}
-		tweetRows.push(row);
-		tweetRowsById.set(row.id, row);
-	}
 
-	for (const entry of tweetEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		for (const wrapper of parseArchiveArray(content)) {
-			const tweet = asRecord(wrapper.tweet);
-			if (!tweet) continue;
-
-			for (const mention of asArray<Record<string, unknown>>(
-				asRecord(tweet.entities)?.user_mentions,
-			)) {
-				const mentionId = String(mention.id_str ?? mention.id ?? "");
-				if (!mentionId) continue;
-				mentionDirectory.set(mentionId, {
-					handle: String(mention.screen_name ?? ""),
-					displayName: String(mention.name ?? mention.screen_name ?? mentionId),
+		if (tweetEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "tweets",
+				files: tweetEntries.length,
+			});
+		}
+		for (const [tweetFileIndex, entry] of tweetEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			for (const wrapper of parseArchiveArray(content)) {
+				const tweet = asRecord(wrapper.tweet);
+				if (!tweet) continue;
+
+				for (const mention of asArray<Record<string, unknown>>(
+					asRecord(tweet.entities)?.user_mentions,
+				)) {
+					const mentionId = String(mention.id_str ?? mention.id ?? "");
+					if (!mentionId) continue;
+					mentionDirectory.set(mentionId, {
+						handle: String(mention.screen_name ?? ""),
+						displayName: String(
+							mention.name ?? mention.screen_name ?? mentionId,
+						),
+					});
+				}
+
+				const replyUserId = String(
+					tweet.in_reply_to_user_id_str ?? tweet.in_reply_to_user_id ?? "",
+				);
+				const replyScreenName = String(tweet.in_reply_to_screen_name ?? "");
+				if (replyUserId && replyScreenName) {
+					mentionDirectory.set(replyUserId, {
+						handle: replyScreenName,
+						displayName: replyScreenName,
+					});
+				}
+
+				addTweetRow({
+					id: String(tweet.id_str ?? tweet.id),
+					kind: "home",
+					authorProfileId: "profile_me",
+					text: String(tweet.full_text ?? tweet.text ?? ""),
+					createdAt: parseTwitterDate(tweet.created_at),
+					isReplied: tweet.in_reply_to_status_id_str ? 1 : 0,
+					replyToId: tweet.in_reply_to_status_id_str
+						? String(tweet.in_reply_to_status_id_str)
+						: null,
+					likeCount: toInt(tweet.favorite_count),
+					mediaCount: getTweetMediaCount(tweet),
+					bookmarked: 0,
+					liked: 0,
+					entitiesJson: JSON.stringify(extractTweetEntities(tweet)),
+					mediaJson: JSON.stringify(extractTweetMedia(tweet)),
+					quotedTweetId: tweet.quoted_status_id_str
+						? String(tweet.quoted_status_id_str)
+						: null,
 				});
 			}
+			onProgress({
+				kind: "slice-file",
+				slice: "tweets",
+				processed: tweetFileIndex + 1,
+				files: tweetEntries.length,
+			});
+		}
+		if (tweetEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "tweets",
+				count: tweetRows.length,
+			});
+		}
 
-			const replyUserId = String(
-				tweet.in_reply_to_user_id_str ?? tweet.in_reply_to_user_id ?? "",
-			);
-			const replyScreenName = String(tweet.in_reply_to_screen_name ?? "");
-			if (replyUserId && replyScreenName) {
-				mentionDirectory.set(replyUserId, {
-					handle: replyScreenName,
-					displayName: replyScreenName,
+		if (noteTweetEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "noteTweets",
+				files: noteTweetEntries.length,
+			});
+		}
+		const tweetRowsBeforeNotes = tweetRows.length;
+		for (const [noteFileIndex, entry] of noteTweetEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			for (const wrapper of parseArchiveArray(content)) {
+				const noteTweet = asRecord(wrapper.noteTweet);
+				if (!noteTweet) continue;
+				const core = asRecord(noteTweet.core);
+				addTweetRow({
+					id: String(noteTweet.noteTweetId ?? noteTweet.id ?? randomUUID()),
+					kind: "home",
+					authorProfileId: "profile_me",
+					text: String(core?.text ?? ""),
+					createdAt: parseTwitterDate(noteTweet.createdAt),
+					isReplied: 0,
+					replyToId: null,
+					likeCount: 0,
+					mediaCount: 0,
+					bookmarked: 0,
+					liked: 0,
+					entitiesJson: "{}",
+					mediaJson: "[]",
+					quotedTweetId: null,
 				});
 			}
-
-			addTweetRow({
-				id: String(tweet.id_str ?? tweet.id),
-				kind: "home",
-				authorProfileId: "profile_me",
-				text: String(tweet.full_text ?? tweet.text ?? ""),
-				createdAt: parseTwitterDate(tweet.created_at),
-				isReplied: tweet.in_reply_to_status_id_str ? 1 : 0,
-				replyToId: tweet.in_reply_to_status_id_str
-					? String(tweet.in_reply_to_status_id_str)
-					: null,
-				likeCount: toInt(tweet.favorite_count),
-				mediaCount: getTweetMediaCount(tweet),
-				bookmarked: 0,
-				liked: 0,
-				entitiesJson: JSON.stringify(extractTweetEntities(tweet)),
-				mediaJson: JSON.stringify(extractTweetMedia(tweet)),
-				quotedTweetId: tweet.quoted_status_id_str
-					? String(tweet.quoted_status_id_str)
-					: null,
+			onProgress({
+				kind: "slice-file",
+				slice: "noteTweets",
+				processed: noteFileIndex + 1,
+				files: noteTweetEntries.length,
 			});
 		}
-	}
-
-	for (const entry of noteTweetEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		for (const wrapper of parseArchiveArray(content)) {
-			const noteTweet = asRecord(wrapper.noteTweet);
-			if (!noteTweet) continue;
-			const core = asRecord(noteTweet.core);
-			addTweetRow({
-				id: String(noteTweet.noteTweetId ?? noteTweet.id ?? randomUUID()),
-				kind: "home",
-				authorProfileId: "profile_me",
-				text: String(core?.text ?? ""),
-				createdAt: parseTwitterDate(noteTweet.createdAt),
-				isReplied: 0,
-				replyToId: null,
-				likeCount: 0,
-				mediaCount: 0,
-				bookmarked: 0,
-				liked: 0,
-				entitiesJson: "{}",
-				mediaJson: "[]",
-				quotedTweetId: null,
+		if (noteTweetEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "noteTweets",
+				count: tweetRows.length - tweetRowsBeforeNotes,
 			});
 		}
-	}
-	const authoredTweetCount = tweetRows.length;
+		const authoredTweetCount = tweetRows.length;
 
-	type MessageRow = {
-		id: string;
-		conversationId: string;
-		senderProfileId: string;
-		text: string;
-		createdAt: string;
-		direction: "inbound" | "outbound";
-		mediaCount: number;
-	};
+		type MessageRow = {
+			id: string;
+			conversationId: string;
+			senderProfileId: string;
+			text: string;
+			createdAt: string;
+			direction: "inbound" | "outbound";
+			mediaCount: number;
+		};
 
-	const profiles = new Map<
-		string,
-		{
+		const profiles = new Map<
+			string,
+			{
+				id: string;
+				handle: string;
+				displayName: string;
+				bio: string;
+				followersCount: number;
+				followingCount: number;
+				publicMetricsJson: string;
+				avatarHue: number;
+				avatarUrl: string | null;
+				location: string | null;
+				url: string | null;
+				verifiedType: string | null;
+				entitiesJson: string;
+				rawJson: string;
+				createdAt: string;
+			}
+		>();
+		type ProfileRow =
+			typeof profiles extends Map<string, infer Value> ? Value : never;
+		const defaultProfileMetadata = {
+			publicMetricsJson: "{}",
+			location: null,
+			url: null,
+			verifiedType: null,
+			entitiesJson: "{}",
+			rawJson: "{}",
+		};
+		const conversations = new Map<
+			string,
+			{
+				id: string;
+				title: string;
+				accountId: string;
+				participantProfileId: string;
+				lastMessageAt: string;
+				unreadCount: number;
+				needsReply: number;
+			}
+		>();
+		const dmMessages: MessageRow[] = [];
+		const followerRows: Array<{ profileId: string; externalUserId: string }> =
+			[];
+		const followingRows: Array<{ profileId: string; externalUserId: string }> =
+			[];
+		const followerIds = new Set<string>();
+		const followingIds = new Set<string>();
+		type ExistingProfileRow = {
 			id: string;
 			handle: string;
-			displayName: string;
+			display_name: string;
 			bio: string;
-			followersCount: number;
-			followingCount: number;
-			publicMetricsJson: string;
-			avatarHue: number;
-			avatarUrl: string | null;
+			followers_count: number;
+			following_count: number;
+			public_metrics_json: string;
+			avatar_hue: number;
+			avatar_url: string | null;
 			location: string | null;
 			url: string | null;
-			verifiedType: string | null;
-			entitiesJson: string;
-			rawJson: string;
-			createdAt: string;
-		}
-	>();
-	type ProfileRow =
-		typeof profiles extends Map<string, infer Value> ? Value : never;
-	const defaultProfileMetadata = {
-		publicMetricsJson: "{}",
-		location: null,
-		url: null,
-		verifiedType: null,
-		entitiesJson: "{}",
-		rawJson: "{}",
-	};
-	const conversations = new Map<
-		string,
-		{
-			id: string;
-			title: string;
-			accountId: string;
-			participantProfileId: string;
-			lastMessageAt: string;
-			unreadCount: number;
-			needsReply: number;
-		}
-	>();
-	const dmMessages: MessageRow[] = [];
-	const followerRows: Array<{ profileId: string; externalUserId: string }> = [];
-	const followingRows: Array<{ profileId: string; externalUserId: string }> =
-		[];
-	const followerIds = new Set<string>();
-	const followingIds = new Set<string>();
-	type ExistingProfileRow = {
-		id: string;
-		handle: string;
-		display_name: string;
-		bio: string;
-		followers_count: number;
-		following_count: number;
-		public_metrics_json: string;
-		avatar_hue: number;
-		avatar_url: string | null;
-		location: string | null;
-		url: string | null;
-		verified_type: string | null;
-		entities_json: string;
-		raw_json: string;
-		created_at: string;
-	};
-	const existingProfiles = new Map(
-		(
-			getNativeDb()
-				.prepare(
-					`
+			verified_type: string | null;
+			entities_json: string;
+			raw_json: string;
+			created_at: string;
+		};
+		const existingProfiles = new Map(
+			(
+				getNativeDb()
+					.prepare(
+						`
 	        select id, handle, display_name, bio, followers_count, following_count,
 	          public_metrics_json, avatar_hue, avatar_url, location, url,
 	          verified_type, entities_json, raw_json, created_at
 	        from profiles
 	      `,
-				)
-				.all() as ExistingProfileRow[]
-		).map((profile) => [profile.id, profile]),
-	);
-	const existingProfilesByHandle = new Map(
-		[...existingProfiles.values()].map((profile) => [
-			profile.handle.toLowerCase(),
-			profile,
-		]),
-	);
-	const existingPrimaryAccount = getNativeDb()
-		.prepare("select handle, external_user_id from accounts where id = ?")
-		.get("acct_primary") as
-		| { handle: string; external_user_id: string | null }
-		| undefined;
-	const profileIdAliases = new Map<string, string>();
-
-	type ArchiveProfileTier =
-		| "archive_follow_stub"
-		| "archive_dm_stub"
-		| "archive_mention_inferred"
-		| "live_or_hydrated";
-	const archiveProfileTierRank: Record<ArchiveProfileTier, number> = {
-		archive_follow_stub: 0,
-		archive_dm_stub: 1,
-		archive_mention_inferred: 2,
-		live_or_hydrated: 3,
-	};
-
-	function classifyExistingProfile(profile: ProfileRow): ArchiveProfileTier {
-		const externalUserId = profile.id.startsWith("profile_user_")
-			? profile.id.slice("profile_user_".length)
-			: "";
-		const fallbackHandle = externalUserId ? `id${externalUserId}` : profile.id;
-		const hasLiveSignals =
-			profile.followersCount > 0 ||
-			profile.followingCount > 0 ||
-			profile.publicMetricsJson.trim() !== "{}" ||
-			profile.avatarUrl !== null ||
-			profile.location !== null ||
-			profile.url !== null ||
-			profile.verifiedType !== null ||
-			profile.entitiesJson.trim() !== "{}" ||
-			profile.rawJson.trim() !== "{}";
-
-		if (hasLiveSignals) return "live_or_hydrated";
-		if (
-			profile.handle === fallbackHandle &&
-			profile.displayName === "" &&
-			profile.bio === ""
-		) {
-			return "archive_follow_stub";
-		}
-		if (profile.bio.startsWith("Imported from archive user ")) {
-			return profile.handle === fallbackHandle &&
-				profile.displayName === fallbackHandle
-				? "archive_dm_stub"
-				: "archive_mention_inferred";
-		}
-		return profile.handle === fallbackHandle && profile.displayName === ""
-			? "archive_follow_stub"
-			: "archive_mention_inferred";
-	}
-
-	function shouldPreserveProfile(
-		existingTier: ArchiveProfileTier,
-		incomingTier: ArchiveProfileTier,
-	) {
-		return (
-			archiveProfileTierRank[existingTier] >=
-			archiveProfileTierRank[incomingTier]
+					)
+					.all() as ExistingProfileRow[]
+			).map((profile) => [profile.id, profile]),
 		);
-	}
-
-	function existingProfileToProfileRow(
-		profile: ExistingProfileRow,
-	): ProfileRow {
-		return {
-			id: profile.id,
-			handle: profile.handle,
-			displayName: profile.display_name,
-			bio: profile.bio,
-			followersCount: profile.followers_count,
-			followingCount: profile.following_count,
-			publicMetricsJson: profile.public_metrics_json,
-			avatarHue: profile.avatar_hue,
-			avatarUrl: profile.avatar_url,
-			location: profile.location,
-			url: profile.url,
-			verifiedType: profile.verified_type,
-			entitiesJson: profile.entities_json,
-			rawJson: profile.raw_json,
-			createdAt: profile.created_at,
+		const existingProfilesByHandle = new Map(
+			[...existingProfiles.values()].map((profile) => [
+				profile.handle.toLowerCase(),
+				profile,
+			]),
+		);
+		const existingPrimaryAccount = getNativeDb()
+			.prepare("select handle, external_user_id from accounts where id = ?")
+			.get("acct_primary") as
+			| { handle: string; external_user_id: string | null }
+			| undefined;
+		const profileIdAliases = new Map<string, string>();
+
+		type ArchiveProfileTier =
+			| "archive_follow_stub"
+			| "archive_dm_stub"
+			| "archive_mention_inferred"
+			| "live_or_hydrated";
+		const archiveProfileTierRank: Record<ArchiveProfileTier, number> = {
+			archive_follow_stub: 0,
+			archive_dm_stub: 1,
+			archive_mention_inferred: 2,
+			live_or_hydrated: 3,
 		};
-	}
 
-	function mergeArchiveProfile(incoming: ProfileRow) {
-		const existingById = existingProfiles.get(incoming.id);
-		const existingByHandle = selection
-			? existingProfilesByHandle.get(incoming.handle.toLowerCase())
-			: undefined;
-		const targetExisting = existingById ?? existingByHandle;
-		const targetId = targetExisting?.id ?? incoming.id;
-		if (targetId !== incoming.id) {
-			profileIdAliases.set(incoming.id, targetId);
+		function classifyExistingProfile(profile: ProfileRow): ArchiveProfileTier {
+			const externalUserId = profile.id.startsWith("profile_user_")
+				? profile.id.slice("profile_user_".length)
+				: "";
+			const fallbackHandle = externalUserId
+				? `id${externalUserId}`
+				: profile.id;
+			const hasLiveSignals =
+				profile.followersCount > 0 ||
+				profile.followingCount > 0 ||
+				profile.publicMetricsJson.trim() !== "{}" ||
+				profile.avatarUrl !== null ||
+				profile.location !== null ||
+				profile.url !== null ||
+				profile.verifiedType !== null ||
+				profile.entitiesJson.trim() !== "{}" ||
+				profile.rawJson.trim() !== "{}";
+
+			if (hasLiveSignals) return "live_or_hydrated";
+			if (
+				profile.handle === fallbackHandle &&
+				profile.displayName === "" &&
+				profile.bio === ""
+			) {
+				return "archive_follow_stub";
+			}
+			if (profile.bio.startsWith("Imported from archive user ")) {
+				return profile.handle === fallbackHandle &&
+					profile.displayName === fallbackHandle
+					? "archive_dm_stub"
+					: "archive_mention_inferred";
+			}
+			return profile.handle === fallbackHandle && profile.displayName === ""
+				? "archive_follow_stub"
+				: "archive_mention_inferred";
 		}
-		const targetIncoming =
-			targetId === incoming.id ? incoming : { ...incoming, id: targetId };
-		const incomingTier = classifyExistingProfile(incoming);
-		const current = profiles.get(targetId);
-		const currentTier = current ? classifyExistingProfile(current) : null;
-		const existingProfile = targetExisting
-			? existingProfileToProfileRow(targetExisting)
-			: null;
-		const existingTier = existingProfile
-			? classifyExistingProfile(existingProfile)
-			: null;
 
-		if (
-			current &&
-			currentTier &&
-			shouldPreserveProfile(currentTier, incomingTier) &&
-			(!existingTier || shouldPreserveProfile(currentTier, existingTier))
+		function shouldPreserveProfile(
+			existingTier: ArchiveProfileTier,
+			incomingTier: ArchiveProfileTier,
 		) {
-			return;
+			return (
+				archiveProfileTierRank[existingTier] >=
+				archiveProfileTierRank[incomingTier]
+			);
 		}
 
-		if (
-			existingProfile &&
-			existingTier &&
-			shouldPreserveProfile(existingTier, incomingTier)
-		) {
-			profiles.set(targetId, existingProfile);
-			return;
+		function existingProfileToProfileRow(
+			profile: ExistingProfileRow,
+		): ProfileRow {
+			return {
+				id: profile.id,
+				handle: profile.handle,
+				displayName: profile.display_name,
+				bio: profile.bio,
+				followersCount: profile.followers_count,
+				followingCount: profile.following_count,
+				publicMetricsJson: profile.public_metrics_json,
+				avatarHue: profile.avatar_hue,
+				avatarUrl: profile.avatar_url,
+				location: profile.location,
+				url: profile.url,
+				verifiedType: profile.verified_type,
+				entitiesJson: profile.entities_json,
+				rawJson: profile.raw_json,
+				createdAt: profile.created_at,
+			};
 		}
 
-		profiles.set(targetId, targetIncoming);
-	}
+		function mergeArchiveProfile(incoming: ProfileRow) {
+			const existingById = existingProfiles.get(incoming.id);
+			const existingByHandle = selection
+				? existingProfilesByHandle.get(incoming.handle.toLowerCase())
+				: undefined;
+			const targetExisting = existingById ?? existingByHandle;
+			const targetId = targetExisting?.id ?? incoming.id;
+			if (targetId !== incoming.id) {
+				profileIdAliases.set(incoming.id, targetId);
+			}
+			const targetIncoming =
+				targetId === incoming.id ? incoming : { ...incoming, id: targetId };
+			const incomingTier = classifyExistingProfile(incoming);
+			const current = profiles.get(targetId);
+			const currentTier = current ? classifyExistingProfile(current) : null;
+			const existingProfile = targetExisting
+				? existingProfileToProfileRow(targetExisting)
+				: null;
+			const existingTier = existingProfile
+				? classifyExistingProfile(existingProfile)
+				: null;
 
-	function resolveProfileId(profileId: string) {
-		return profileIdAliases.get(profileId) ?? profileId;
-	}
+			if (
+				current &&
+				currentTier &&
+				shouldPreserveProfile(currentTier, incomingTier) &&
+				(!existingTier || shouldPreserveProfile(currentTier, existingTier))
+			) {
+				return;
+			}
 
-	function isProfileHandleTakenByOtherId(handle: string, profileId: string) {
-		const normalizedHandle = handle.toLowerCase();
-		const existingProfile = existingProfilesByHandle.get(normalizedHandle);
-		if (existingProfile && existingProfile.id !== profileId) return true;
-		for (const profile of profiles.values()) {
 			if (
-				profile.id !== profileId &&
-				profile.handle.toLowerCase() === normalizedHandle
+				existingProfile &&
+				existingTier &&
+				shouldPreserveProfile(existingTier, incomingTier)
 			) {
-				return true;
+				profiles.set(targetId, existingProfile);
+				return;
 			}
+
+			profiles.set(targetId, targetIncoming);
 		}
-		return false;
-	}
 
-	function uniqueArchiveProfileHandle(baseHandle: string, profileId: string) {
-		if (!isProfileHandleTakenByOtherId(baseHandle, profileId)) {
-			return baseHandle;
+		function resolveProfileId(profileId: string) {
+			return profileIdAliases.get(profileId) ?? profileId;
 		}
-		let index = 1;
-		while (true) {
-			const suffix = index === 1 ? "archive" : `archive_${index}`;
-			const candidate = `${baseHandle}_${suffix}`;
-			if (!isProfileHandleTakenByOtherId(candidate, profileId)) {
-				return candidate;
+
+		function isProfileHandleTakenByOtherId(handle: string, profileId: string) {
+			const normalizedHandle = handle.toLowerCase();
+			const existingProfile = existingProfilesByHandle.get(normalizedHandle);
+			if (existingProfile && existingProfile.id !== profileId) return true;
+			for (const profile of profiles.values()) {
+				if (
+					profile.id !== profileId &&
+					profile.handle.toLowerCase() === normalizedHandle
+				) {
+					return true;
+				}
 			}
-			index += 1;
+			return false;
 		}
-	}
-
-	function addArchiveFollowProfile(profileId: string, externalUserId: string) {
-		if (!profileId) return;
-		const fallbackId =
-			externalUserId || profileId.replace(/^profile_user_/, "");
-		mergeArchiveProfile({
-			id: profileId,
-			handle: fallbackId ? `id${fallbackId}` : profileId,
-			displayName: "",
-			bio: "",
-			followersCount: 0,
-			followingCount: 0,
-			...defaultProfileMetadata,
-			avatarHue: 210,
-			avatarUrl: null,
-			createdAt: accountPayload.createdAt,
-		});
-	}
 
-	function assertSelectedAccountMatchesArchive() {
-		if (!selection || !existingPrimaryAccount) return;
-		const existingExternalUserId = existingPrimaryAccount.external_user_id;
-		if (
-			existingExternalUserId &&
-			existingExternalUserId !== accountPayload.accountId
-		) {
-			throw new Error(
-				`Existing acct_primary (${existingExternalUserId}) does not match archive account ${accountPayload.accountId}`,
-			);
-		}
-		const existingHandle = existingPrimaryAccount.handle
-			.replace(/^@/, "")
-			.toLowerCase();
-		if (
-			!existingExternalUserId &&
-			existingHandle !== accountPayload.username.toLowerCase()
-		) {
-			throw new Error(
-				`Existing acct_primary (@${existingHandle}) does not match archive account @${accountPayload.username}`,
-			);
+		function uniqueArchiveProfileHandle(baseHandle: string, profileId: string) {
+			if (!isProfileHandleTakenByOtherId(baseHandle, profileId)) {
+				return baseHandle;
+			}
+			let index = 1;
+			while (true) {
+				const suffix = index === 1 ? "archive" : `archive_${index}`;
+				const candidate = `${baseHandle}_${suffix}`;
+				if (!isProfileHandleTakenByOtherId(candidate, profileId)) {
+					return candidate;
+				}
+				index += 1;
+			}
 		}
-	}
 
-	assertSelectedAccountMatchesArchive();
-
-	const existingLocalProfile =
-		selection &&
-		(existingProfiles.get("profile_me") ??
-			[...existingProfiles.values()].find(
-				(profile) =>
-					profile.handle.toLowerCase() ===
-					accountPayload.username.toLowerCase(),
-			));
-	const archivedLocalProfile = existingLocalProfile
-		? {
-				...existingProfileToProfileRow(existingLocalProfile),
-				handle: accountPayload.username,
-				displayName: accountPayload.displayName,
-				bio: accountPayload.bio,
-				createdAt: accountPayload.createdAt,
-			}
-		: {
-				id: "profile_me",
-				handle: accountPayload.username,
-				displayName: accountPayload.displayName,
-				bio: accountPayload.bio,
+		function addArchiveFollowProfile(
+			profileId: string,
+			externalUserId: string,
+		) {
+			if (!profileId) return;
+			const fallbackId =
+				externalUserId || profileId.replace(/^profile_user_/, "");
+			mergeArchiveProfile({
+				id: profileId,
+				handle: fallbackId ? `id${fallbackId}` : profileId,
+				displayName: "",
+				bio: "",
 				followersCount: 0,
 				followingCount: 0,
 				...defaultProfileMetadata,
-				avatarHue: 18,
+				avatarHue: 210,
 				avatarUrl: null,
 				createdAt: accountPayload.createdAt,
-			};
-	const localProfile =
-		existingLocalProfile && !includeProfiles
-			? existingProfileToProfileRow(existingLocalProfile)
-			: archivedLocalProfile;
-	profiles.set(localProfile.id, localProfile);
-
-	const existingDmConversationAccounts = new Map(
-		(
-			getNativeDb()
-				.prepare("select id, account_id from dm_conversations")
-				.all() as Array<{ id: string; account_id: string }>
-		).map((row) => [row.id, row.account_id]),
-	);
-	const existingOtherDmMessageIds = new Set(
-		(
-			getNativeDb()
-				.prepare(
-					`
+			});
+		}
+
+		function assertSelectedAccountMatchesArchive() {
+			if (!selection || !existingPrimaryAccount) return;
+			const existingExternalUserId = existingPrimaryAccount.external_user_id;
+			if (
+				existingExternalUserId &&
+				existingExternalUserId !== accountPayload.accountId
+			) {
+				throw new Error(
+					`Existing acct_primary (${existingExternalUserId}) does not match archive account ${accountPayload.accountId}`,
+				);
+			}
+			const existingHandle = existingPrimaryAccount.handle
+				.replace(/^@/, "")
+				.toLowerCase();
+			if (
+				!existingExternalUserId &&
+				existingHandle !== accountPayload.username.toLowerCase()
+			) {
+				throw new Error(
+					`Existing acct_primary (@${existingHandle}) does not match archive account @${accountPayload.username}`,
+				);
+			}
+		}
+
+		assertSelectedAccountMatchesArchive();
+
+		const existingLocalProfile =
+			selection &&
+			(existingProfiles.get("profile_me") ??
+				[...existingProfiles.values()].find(
+					(profile) =>
+						profile.handle.toLowerCase() ===
+						accountPayload.username.toLowerCase(),
+				));
+		const archivedLocalProfile = existingLocalProfile
+			? {
+					...existingProfileToProfileRow(existingLocalProfile),
+					handle: accountPayload.username,
+					displayName: accountPayload.displayName,
+					bio: accountPayload.bio,
+					createdAt: accountPayload.createdAt,
+				}
+			: {
+					id: "profile_me",
+					handle: accountPayload.username,
+					displayName: accountPayload.displayName,
+					bio: accountPayload.bio,
+					followersCount: 0,
+					followingCount: 0,
+					...defaultProfileMetadata,
+					avatarHue: 18,
+					avatarUrl: null,
+					createdAt: accountPayload.createdAt,
+				};
+		const localProfile =
+			existingLocalProfile && !includeProfiles
+				? existingProfileToProfileRow(existingLocalProfile)
+				: archivedLocalProfile;
+		profiles.set(localProfile.id, localProfile);
+
+		const existingDmConversationAccounts = new Map(
+			(
+				getNativeDb()
+					.prepare("select id, account_id from dm_conversations")
+					.all() as Array<{ id: string; account_id: string }>
+			).map((row) => [row.id, row.account_id]),
+		);
+		const existingOtherDmMessageIds = new Set(
+			(
+				getNativeDb()
+					.prepare(
+						`
           select m.id
           from dm_messages m
           join dm_conversations c on c.id = m.conversation_id
           where c.account_id <> 'acct_primary'
         `,
-				)
-				.all() as Array<{ id: string }>
-		).map((row) => row.id),
-	);
-	const archiveDmConversationIdAliases = new Map<string, string>();
-	const archiveDmMessageIdAliases = new Map<string, string>();
-
-	function uniquePrimaryArchiveId(
-		baseId: string,
-		isTakenByOtherAccount: (candidate: string) => boolean,
-		isPending: (candidate: string) => boolean,
-	) {
-		let index = 1;
-		while (true) {
-			const suffix = index === 1 ? "" : `:${index}`;
-			const candidate = `acct_primary:${baseId}${suffix}`;
-			if (!isTakenByOtherAccount(candidate) && !isPending(candidate)) {
-				return candidate;
+					)
+					.all() as Array<{ id: string }>
+			).map((row) => row.id),
+		);
+		const archiveDmConversationIdAliases = new Map<string, string>();
+		const archiveDmMessageIdAliases = new Map<string, string>();
+
+		function uniquePrimaryArchiveId(
+			baseId: string,
+			isTakenByOtherAccount: (candidate: string) => boolean,
+			isPending: (candidate: string) => boolean,
+		) {
+			let index = 1;
+			while (true) {
+				const suffix = index === 1 ? "" : `:${index}`;
+				const candidate = `acct_primary:${baseId}${suffix}`;
+				if (!isTakenByOtherAccount(candidate) && !isPending(candidate)) {
+					return candidate;
+				}
+				index += 1;
 			}
-			index += 1;
 		}
-	}
 
-	function resolveArchiveDmConversationId(conversationId: string) {
-		const existingAlias = archiveDmConversationIdAliases.get(conversationId);
-		if (existingAlias) return existingAlias;
-		if (!selection) {
-			archiveDmConversationIdAliases.set(conversationId, conversationId);
-			return conversationId;
-		}
+		function resolveArchiveDmConversationId(conversationId: string) {
+			const existingAlias = archiveDmConversationIdAliases.get(conversationId);
+			if (existingAlias) return existingAlias;
+			if (!selection) {
+				archiveDmConversationIdAliases.set(conversationId, conversationId);
+				return conversationId;
+			}
 
-		const takenByOtherAccount = (candidate: string) => {
-			const accountId = existingDmConversationAccounts.get(candidate);
-			return accountId !== undefined && accountId !== "acct_primary";
-		};
-		const resolved = takenByOtherAccount(conversationId)
-			? uniquePrimaryArchiveId(
-					conversationId,
-					takenByOtherAccount,
-					(candidate) => conversations.has(candidate),
-				)
-			: conversationId;
-		archiveDmConversationIdAliases.set(conversationId, resolved);
-		return resolved;
-	}
+			const takenByOtherAccount = (candidate: string) => {
+				const accountId = existingDmConversationAccounts.get(candidate);
+				return accountId !== undefined && accountId !== "acct_primary";
+			};
+			const resolved = takenByOtherAccount(conversationId)
+				? uniquePrimaryArchiveId(
+						conversationId,
+						takenByOtherAccount,
+						(candidate) => conversations.has(candidate),
+					)
+				: conversationId;
+			archiveDmConversationIdAliases.set(conversationId, resolved);
+			return resolved;
+		}
 
-	function resolveArchiveDmMessageId(
-		messageId: string,
-		conversationIdChanged: boolean,
-	) {
-		const existingAlias = archiveDmMessageIdAliases.get(messageId);
-		if (existingAlias) return existingAlias;
-		const shouldRemap =
-			selection &&
-			(conversationIdChanged || existingOtherDmMessageIds.has(messageId));
-		const resolved = shouldRemap
-			? uniquePrimaryArchiveId(
-					messageId,
-					(candidate) => existingOtherDmMessageIds.has(candidate),
-					(candidate) => dmMessages.some((message) => message.id === candidate),
-				)
-			: messageId;
-		archiveDmMessageIdAliases.set(messageId, resolved);
-		return resolved;
-	}
+		function resolveArchiveDmMessageId(
+			messageId: string,
+			conversationIdChanged: boolean,
+		) {
+			const existingAlias = archiveDmMessageIdAliases.get(messageId);
+			if (existingAlias) return existingAlias;
+			const shouldRemap =
+				selection &&
+				(conversationIdChanged || existingOtherDmMessageIds.has(messageId));
+			const resolved = shouldRemap
+				? uniquePrimaryArchiveId(
+						messageId,
+						(candidate) => existingOtherDmMessageIds.has(candidate),
+						(candidate) =>
+							dmMessages.some((message) => message.id === candidate),
+					)
+				: messageId;
+			archiveDmMessageIdAliases.set(messageId, resolved);
+			return resolved;
+		}
 
-	for (const entry of dmEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		for (const wrapper of parseArchiveArray(content)) {
-			const dmConversation = asRecord(wrapper.dmConversation);
-			if (!dmConversation) continue;
-
-			const rawConversationId = String(dmConversation.conversationId ?? "");
-			if (!rawConversationId) continue;
-			const conversationId = resolveArchiveDmConversationId(rawConversationId);
-			const conversationIdChanged = conversationId !== rawConversationId;
-
-			const conversationName = String(dmConversation.name ?? "").trim();
-			const participantIds = new Set<string>();
-			const rawMessages = asArray<Record<string, unknown>>(
-				dmConversation.messages,
-			);
+		if (dmEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "directMessages",
+				files: dmEntries.length,
+			});
+		}
+		for (const [dmFileIndex, entry] of dmEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			for (const wrapper of parseArchiveArray(content)) {
+				const dmConversation = asRecord(wrapper.dmConversation);
+				if (!dmConversation) continue;
+
+				const rawConversationId = String(dmConversation.conversationId ?? "");
+				if (!rawConversationId) continue;
+				const conversationId =
+					resolveArchiveDmConversationId(rawConversationId);
+				const conversationIdChanged = conversationId !== rawConversationId;
+
+				const conversationName = String(dmConversation.name ?? "").trim();
+				const participantIds = new Set<string>();
+				const rawMessages = asArray<Record<string, unknown>>(
+					dmConversation.messages,
+				);
 
-			for (const event of rawMessages) {
-				const messageCreate = asRecord(event.messageCreate);
-				if (messageCreate) {
-					const senderId = String(messageCreate.senderId ?? "");
-					const recipientId = String(messageCreate.recipientId ?? "");
-					if (senderId) participantIds.add(senderId);
-					if (recipientId) participantIds.add(recipientId);
-				}
+				for (const event of rawMessages) {
+					const messageCreate = asRecord(event.messageCreate);
+					if (messageCreate) {
+						const senderId = String(messageCreate.senderId ?? "");
+						const recipientId = String(messageCreate.recipientId ?? "");
+						if (senderId) participantIds.add(senderId);
+						if (recipientId) participantIds.add(recipientId);
+					}
 
-				const joinConversation = asRecord(event.joinConversation);
-				if (joinConversation) {
-					for (const userId of asArray<string>(
-						joinConversation.participantsSnapshot,
-					)) {
-						participantIds.add(String(userId));
+					const joinConversation = asRecord(event.joinConversation);
+					if (joinConversation) {
+						for (const userId of asArray<string>(
+							joinConversation.participantsSnapshot,
+						)) {
+							participantIds.add(String(userId));
+						}
 					}
-				}
 
-				const participantsJoin = asRecord(event.participantsJoin);
-				if (participantsJoin) {
-					for (const userId of asArray<string>(participantsJoin.userIds)) {
-						participantIds.add(String(userId));
+					const participantsJoin = asRecord(event.participantsJoin);
+					if (participantsJoin) {
+						for (const userId of asArray<string>(participantsJoin.userIds)) {
+							participantIds.add(String(userId));
+						}
+						const initiatingUserId = String(
+							participantsJoin.initiatingUserId ?? "",
+						);
+						if (initiatingUserId) {
+							participantIds.add(initiatingUserId);
+						}
 					}
-					const initiatingUserId = String(
-						participantsJoin.initiatingUserId ?? "",
-					);
-					if (initiatingUserId) {
-						participantIds.add(initiatingUserId);
+
+					const participantsLeave = asRecord(event.participantsLeave);
+					if (participantsLeave) {
+						for (const userId of asArray<string>(participantsLeave.userIds)) {
+							participantIds.add(String(userId));
+						}
+						const initiatingUserId = String(
+							participantsLeave.initiatingUserId ?? "",
+						);
+						if (initiatingUserId) {
+							participantIds.add(initiatingUserId);
+						}
 					}
 				}
 
-				const participantsLeave = asRecord(event.participantsLeave);
-				if (participantsLeave) {
-					for (const userId of asArray<string>(participantsLeave.userIds)) {
-						participantIds.add(String(userId));
-					}
-					const initiatingUserId = String(
-						participantsLeave.initiatingUserId ?? "",
-					);
-					if (initiatingUserId) {
-						participantIds.add(initiatingUserId);
+				const externalParticipantIds = [...participantIds].filter(
+					(userId) => userId && userId !== accountPayload.accountId,
+				);
+				const isGroup =
+					conversationName.length > 0 || externalParticipantIds.length > 1;
+				const participantProfileId = isGroup
+					? `profile_group_${conversationId}`
+					: `profile_user_${externalParticipantIds[0] ?? conversationId}`;
+
+				if (!profiles.has(participantProfileId)) {
+					if (isGroup) {
+						profiles.set(participantProfileId, {
+							id: participantProfileId,
+							handle: `group-${conversationId}`,
+							displayName:
+								conversationName || `Group DM ${externalParticipantIds.length}`,
+							bio: `Group DM with ${externalParticipantIds.length} participants`,
+							followersCount: 0,
+							followingCount: 0,
+							...defaultProfileMetadata,
+							avatarHue: 220,
+							avatarUrl: null,
+							createdAt: accountPayload.createdAt,
+						});
+					} else {
+						const otherUserId = externalParticipantIds[0] ?? conversationId;
+						const inferred = inferProfileFromDirectory(
+							otherUserId,
+							mentionDirectory,
+						);
+						mergeArchiveProfile({
+							id: participantProfileId,
+							handle: inferred.handle,
+							displayName: inferred.displayName,
+							bio: `Imported from archive user ${otherUserId}`,
+							followersCount: 0,
+							followingCount: 0,
+							...defaultProfileMetadata,
+							avatarHue: 210,
+							avatarUrl: null,
+							createdAt: accountPayload.createdAt,
+						});
 					}
 				}
-			}
 
-			const externalParticipantIds = [...participantIds].filter(
-				(userId) => userId && userId !== accountPayload.accountId,
-			);
-			const isGroup =
-				conversationName.length > 0 || externalParticipantIds.length > 1;
-			const participantProfileId = isGroup
-				? `profile_group_${conversationId}`
-				: `profile_user_${externalParticipantIds[0] ?? conversationId}`;
-
-			if (!profiles.has(participantProfileId)) {
-				if (isGroup) {
-					profiles.set(participantProfileId, {
-						id: participantProfileId,
-						handle: `group-${conversationId}`,
-						displayName:
-							conversationName || `Group DM ${externalParticipantIds.length}`,
-						bio: `Group DM with ${externalParticipantIds.length} participants`,
-						followersCount: 0,
-						followingCount: 0,
-						...defaultProfileMetadata,
-						avatarHue: 220,
-						avatarUrl: null,
-						createdAt: accountPayload.createdAt,
-					});
-				} else {
-					const otherUserId = externalParticipantIds[0] ?? conversationId;
-					const inferred = inferProfileFromDirectory(
-						otherUserId,
-						mentionDirectory,
-					);
-					mergeArchiveProfile({
-						id: participantProfileId,
-						handle: inferred.handle,
-						displayName: inferred.displayName,
-						bio: `Imported from archive user ${otherUserId}`,
-						followersCount: 0,
-						followingCount: 0,
-						...defaultProfileMetadata,
-						avatarHue: 210,
-						avatarUrl: null,
-						createdAt: accountPayload.createdAt,
-					});
-				}
-			}
+				const messageEvents = rawMessages
+					.map((event) => asRecord(event.messageCreate))
+					.filter((event): event is Record<string, unknown> => event !== null)
+					.map((messageCreate) => {
+						const senderId = String(messageCreate.senderId ?? "");
+						const rawMessageId = String(
+							messageCreate.id ?? `${rawConversationId}-${senderId}`,
+						);
+						const senderProfileId =
+							senderId === accountPayload.accountId
+								? localProfile.id
+								: `profile_user_${senderId}`;
+
+						if (senderId && senderId !== accountPayload.accountId) {
+							const inferred = inferProfileFromDirectory(
+								senderId,
+								mentionDirectory,
+							);
+							if (!profiles.has(senderProfileId)) {
+								mergeArchiveProfile({
+									id: senderProfileId,
+									handle: inferred.handle,
+									displayName: inferred.displayName,
+									bio: `Imported from archive user ${senderId}`,
+									followersCount: 0,
+									followingCount: 0,
+									...defaultProfileMetadata,
+									avatarHue: 240,
+									avatarUrl: null,
+									createdAt: accountPayload.createdAt,
+								});
+							}
+						}
 
-			const messageEvents = rawMessages
-				.map((event) => asRecord(event.messageCreate))
-				.filter((event): event is Record<string, unknown> => event !== null)
-				.map((messageCreate) => {
-					const senderId = String(messageCreate.senderId ?? "");
-					const rawMessageId = String(
-						messageCreate.id ?? `${rawConversationId}-${senderId}`,
+						return {
+							id: resolveArchiveDmMessageId(
+								rawMessageId,
+								conversationIdChanged,
+							),
+							conversationId,
+							senderProfileId: resolveProfileId(senderProfileId),
+							text: String(messageCreate.text ?? ""),
+							createdAt: parseTwitterDate(messageCreate.createdAt),
+							direction:
+								senderId === accountPayload.accountId ? "outbound" : "inbound",
+							mediaCount: asArray(messageCreate.mediaUrls).length,
+						} satisfies MessageRow;
+					})
+					.sort((left, right) =>
+						compareIsoTimestamp(left.createdAt, right.createdAt),
 					);
-					const senderProfileId =
-						senderId === accountPayload.accountId
-							? localProfile.id
-							: `profile_user_${senderId}`;
 
-					if (senderId && senderId !== accountPayload.accountId) {
-						const inferred = inferProfileFromDirectory(
-							senderId,
-							mentionDirectory,
-						);
-						if (!profiles.has(senderProfileId)) {
-							mergeArchiveProfile({
-								id: senderProfileId,
-								handle: inferred.handle,
-								displayName: inferred.displayName,
-								bio: `Imported from archive user ${senderId}`,
-								followersCount: 0,
-								followingCount: 0,
-								...defaultProfileMetadata,
-								avatarHue: 240,
-								avatarUrl: null,
-								createdAt: accountPayload.createdAt,
-							});
-						}
-					}
+				if (messageEvents.length === 0) {
+					continue;
+				}
 
-					return {
-						id: resolveArchiveDmMessageId(rawMessageId, conversationIdChanged),
+				const lastMessage = messageEvents.at(-1);
+				if (!lastMessage) continue;
+
+				dmMessages.push(...messageEvents);
+				const resolvedParticipantProfileId =
+					resolveProfileId(participantProfileId);
+				conversations.set(conversationId, {
+					id: conversationId,
+					title:
+						profiles.get(resolvedParticipantProfileId)?.displayName ||
+						conversationName ||
 						conversationId,
-						senderProfileId: resolveProfileId(senderProfileId),
-						text: String(messageCreate.text ?? ""),
-						createdAt: parseTwitterDate(messageCreate.createdAt),
-						direction:
-							senderId === accountPayload.accountId ? "outbound" : "inbound",
-						mediaCount: asArray(messageCreate.mediaUrls).length,
-					} satisfies MessageRow;
-				})
-				.sort((left, right) =>
-					compareIsoTimestamp(left.createdAt, right.createdAt),
-				);
-
-			if (messageEvents.length === 0) {
-				continue;
+					accountId: "acct_primary",
+					participantProfileId: resolvedParticipantProfileId,
+					lastMessageAt: lastMessage.createdAt,
+					unreadCount: 0,
+					needsReply: lastMessage.direction === "inbound" ? 1 : 0,
+				});
 			}
-
-			const lastMessage = messageEvents.at(-1);
-			if (!lastMessage) continue;
-
-			dmMessages.push(...messageEvents);
-			const resolvedParticipantProfileId =
-				resolveProfileId(participantProfileId);
-			conversations.set(conversationId, {
-				id: conversationId,
-				title:
-					profiles.get(resolvedParticipantProfileId)?.displayName ||
-					conversationName ||
-					conversationId,
-				accountId: "acct_primary",
-				participantProfileId: resolvedParticipantProfileId,
-				lastMessageAt: lastMessage.createdAt,
-				unreadCount: 0,
-				needsReply: lastMessage.direction === "inbound" ? 1 : 0,
+			onProgress({
+				kind: "slice-file",
+				slice: "directMessages",
+				processed: dmFileIndex + 1,
+				files: dmEntries.length,
+			});
+		}
+		if (dmEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "directMessages",
+				count: dmMessages.length,
 			});
 		}
-	}
 
-	let likeCount = 0;
-	for (const entry of likeEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		const likes = parseArchiveArray(content);
-		for (const like of likes) {
-			const tweet = extractCollectionTweet(like, "like");
-			if (!tweet) continue;
-			collectionRows.push({
-				tweetId: tweet.id,
-				kind: "likes",
-				collectedAt: tweet.createdAt,
-				source: "archive",
-				rawJson: JSON.stringify(like),
+		if (likeEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "likes",
+				files: likeEntries.length,
 			});
-			addTweetRow({
-				id: tweet.id,
-				kind: "like",
-				authorProfileId: "profile_unknown",
-				text: tweet.text,
-				createdAt: tweet.createdAt,
-				isReplied: 0,
-				replyToId: null,
-				likeCount: tweet.likeCount,
-				mediaCount: 0,
-				bookmarked: 0,
-				liked: 1,
-				entitiesJson: "{}",
-				mediaJson: "[]",
-				quotedTweetId: null,
+		}
+		let likeCount = 0;
+		for (const [likeFileIndex, entry] of likeEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			const likes = parseArchiveArray(content);
+			for (const like of likes) {
+				const tweet = extractCollectionTweet(like, "like");
+				if (!tweet) continue;
+				collectionRows.push({
+					tweetId: tweet.id,
+					kind: "likes",
+					collectedAt: tweet.createdAt,
+					source: "archive",
+					rawJson: JSON.stringify(like),
+				});
+				addTweetRow({
+					id: tweet.id,
+					kind: "like",
+					authorProfileId: "profile_unknown",
+					text: tweet.text,
+					createdAt: tweet.createdAt,
+					isReplied: 0,
+					replyToId: null,
+					likeCount: tweet.likeCount,
+					mediaCount: 0,
+					bookmarked: 0,
+					liked: 1,
+					entitiesJson: "{}",
+					mediaJson: "[]",
+					quotedTweetId: null,
+				});
+			}
+			likeCount += likes.length;
+			onProgress({
+				kind: "slice-file",
+				slice: "likes",
+				processed: likeFileIndex + 1,
+				files: likeEntries.length,
 			});
 		}
-		likeCount += likes.length;
-	}
+		if (likeEntries.length > 0) {
+			onProgress({ kind: "slice-done", slice: "likes", count: likeCount });
+		}
 
-	let bookmarkCount = 0;
-	for (const entry of bookmarkEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		const bookmarks = parseArchiveArray(content);
-		for (const bookmark of bookmarks) {
-			const tweet = extractCollectionTweet(bookmark, "bookmark");
-			if (!tweet) continue;
-			collectionRows.push({
-				tweetId: tweet.id,
-				kind: "bookmarks",
-				collectedAt: tweet.createdAt,
-				source: "archive",
-				rawJson: JSON.stringify(bookmark),
+		if (bookmarkEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "bookmarks",
+				files: bookmarkEntries.length,
 			});
-			addTweetRow({
-				id: tweet.id,
-				kind: "bookmark",
-				authorProfileId: "profile_unknown",
-				text: tweet.text,
-				createdAt: tweet.createdAt,
-				isReplied: 0,
-				replyToId: null,
-				likeCount: tweet.likeCount,
-				mediaCount: 0,
-				bookmarked: 1,
-				liked: 0,
-				entitiesJson: "{}",
-				mediaJson: "[]",
-				quotedTweetId: null,
+		}
+		let bookmarkCount = 0;
+		for (const [bookmarkFileIndex, entry] of bookmarkEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			const bookmarks = parseArchiveArray(content);
+			for (const bookmark of bookmarks) {
+				const tweet = extractCollectionTweet(bookmark, "bookmark");
+				if (!tweet) continue;
+				collectionRows.push({
+					tweetId: tweet.id,
+					kind: "bookmarks",
+					collectedAt: tweet.createdAt,
+					source: "archive",
+					rawJson: JSON.stringify(bookmark),
+				});
+				addTweetRow({
+					id: tweet.id,
+					kind: "bookmark",
+					authorProfileId: "profile_unknown",
+					text: tweet.text,
+					createdAt: tweet.createdAt,
+					isReplied: 0,
+					replyToId: null,
+					likeCount: tweet.likeCount,
+					mediaCount: 0,
+					bookmarked: 1,
+					liked: 0,
+					entitiesJson: "{}",
+					mediaJson: "[]",
+					quotedTweetId: null,
+				});
+			}
+			bookmarkCount += bookmarks.length;
+			onProgress({
+				kind: "slice-file",
+				slice: "bookmarks",
+				processed: bookmarkFileIndex + 1,
+				files: bookmarkEntries.length,
+			});
+		}
+		if (bookmarkEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "bookmarks",
+				count: bookmarkCount,
 			});
 		}
-		bookmarkCount += bookmarks.length;
-	}
 
-	const mediaFileCounts = await extractArchiveMediaFiles(
-		archivePath,
-		selectedArchiveMediaKinds(selection),
-	);
+		onProgress({ kind: "slice-start", slice: "media", files: 0 });
+		const mediaFileCounts = yield* extractArchiveMediaFilesEffect(
+			archivePath,
+			selectedArchiveMediaKinds(selection),
+		);
+		onProgress({
+			kind: "slice-done",
+			slice: "media",
+			count: Object.values(mediaFileCounts).reduce(
+				(total, value) => total + value,
+				0,
+			),
+		});
 
-	for (const entry of followerEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		for (const row of getArchiveFollowRows(content, "follower")) {
-			if (followerIds.has(row.externalUserId)) continue;
-			followerIds.add(row.externalUserId);
-			followerRows.push(row);
+		if (followerEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "followers",
+				files: followerEntries.length,
+			});
+		}
+		for (const [followerFileIndex, entry] of followerEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			for (const row of getArchiveFollowRows(content, "follower")) {
+				if (followerIds.has(row.externalUserId)) continue;
+				followerIds.add(row.externalUserId);
+				followerRows.push(row);
+			}
+			onProgress({
+				kind: "slice-file",
+				slice: "followers",
+				processed: followerFileIndex + 1,
+				files: followerEntries.length,
+			});
+		}
+		if (followerEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "followers",
+				count: followerRows.length,
+			});
 		}
-	}
 
-	for (const entry of followingEntries) {
-		const content = await readArchiveEntry(archivePath, entry);
-		for (const row of getArchiveFollowRows(content, "following")) {
-			if (followingIds.has(row.externalUserId)) continue;
-			followingIds.add(row.externalUserId);
-			followingRows.push(row);
+		if (followingEntries.length > 0) {
+			onProgress({
+				kind: "slice-start",
+				slice: "following",
+				files: followingEntries.length,
+			});
+		}
+		for (const [followingFileIndex, entry] of followingEntries.entries()) {
+			const content = yield* readArchiveEntryEffect(archivePath, entry);
+			for (const row of getArchiveFollowRows(content, "following")) {
+				if (followingIds.has(row.externalUserId)) continue;
+				followingIds.add(row.externalUserId);
+				followingRows.push(row);
+			}
+			onProgress({
+				kind: "slice-file",
+				slice: "following",
+				processed: followingFileIndex + 1,
+				files: followingEntries.length,
+			});
+		}
+		if (followingEntries.length > 0) {
+			onProgress({
+				kind: "slice-done",
+				slice: "following",
+				count: followingRows.length,
+			});
 		}
-	}
 
-	for (const row of [...followerRows, ...followingRows]) {
-		addArchiveFollowProfile(row.profileId, row.externalUserId);
-	}
+		for (const row of [...followerRows, ...followingRows]) {
+			addArchiveFollowProfile(row.profileId, row.externalUserId);
+		}
 
-	const clearedFollowDirections = new Set<ArchiveFollowDirection>();
-	if (includeFollowers && followerEntries.length === 0) {
-		clearedFollowDirections.add("followers");
-	}
-	if (includeFollowing && followingEntries.length === 0) {
-		clearedFollowDirections.add("following");
-	}
-	const retainedFollowProfiles = getNativeDb()
-		.prepare(
-			`
+		const clearedFollowDirections = new Set<ArchiveFollowDirection>();
+		if (includeFollowers && followerEntries.length === 0) {
+			clearedFollowDirections.add("followers");
+		}
+		if (includeFollowing && followingEntries.length === 0) {
+			clearedFollowDirections.add("following");
+		}
+		const retainedFollowProfiles = getNativeDb()
+			.prepare(
+				`
       select direction, profile_id, external_user_id, source, null as snapshot_id, null as snapshot_source
       from follow_edges
       union
@@ -1527,57 +1757,54 @@ export async function importArchive(
       from follow_events ev
       left join follow_snapshots snap on snap.id = ev.snapshot_id
       `,
-		)
-		.all() as Array<{
-		direction: ArchiveFollowDirection;
-		profile_id: string;
-		external_user_id: string;
-		source: string | null;
-		snapshot_id: string | null;
-		snapshot_source: string | null;
-	}>;
-	for (const row of retainedFollowProfiles) {
-		const isClearedArchiveRow =
-			clearedFollowDirections.has(row.direction) &&
-			(row.source === "archive" ||
-				row.snapshot_source === "archive" ||
-				row.snapshot_id ===
-					`follow_snapshot_archive_acct_primary_${row.direction}`);
-		if (isClearedArchiveRow) continue;
-		addArchiveFollowProfile(row.profile_id, row.external_user_id);
-	}
-
-	if (tweetRows.some((tweet) => tweet.authorProfileId === "profile_unknown")) {
-		const unknownProfile = {
-			id: "profile_unknown",
-			handle: selection
-				? uniqueArchiveProfileHandle("unknown", "profile_unknown")
-				: "unknown",
-			displayName: "Unknown",
-			bio: "Imported from archive collection metadata",
-			followersCount: 0,
-			followingCount: 0,
-			...defaultProfileMetadata,
-			avatarHue: 210,
-			avatarUrl: null,
-			createdAt: accountPayload.createdAt,
-		};
-		const existingUnknownProfile = existingProfiles.get("profile_unknown");
-		profiles.set(
-			"profile_unknown",
-			existingUnknownProfile
-				? existingProfileToProfileRow(existingUnknownProfile)
-				: unknownProfile,
-		);
-	}
+			)
+			.all() as Array<{
+			direction: ArchiveFollowDirection;
+			profile_id: string;
+			external_user_id: string;
+			source: string | null;
+			snapshot_id: string | null;
+			snapshot_source: string | null;
+		}>;
+		for (const row of retainedFollowProfiles) {
+			const isClearedArchiveRow =
+				clearedFollowDirections.has(row.direction) &&
+				(row.source === "archive" ||
+					row.snapshot_source === "archive" ||
+					row.snapshot_id ===
+						`follow_snapshot_archive_acct_primary_${row.direction}`);
+			if (isClearedArchiveRow) continue;
+			addArchiveFollowProfile(row.profile_id, row.external_user_id);
+		}
 
-	if (!selection) {
-		clearImportedData();
-		clearMentionSyncState();
-	}
+		if (
+			tweetRows.some((tweet) => tweet.authorProfileId === "profile_unknown")
+		) {
+			const unknownProfile = {
+				id: "profile_unknown",
+				handle: selection
+					? uniqueArchiveProfileHandle("unknown", "profile_unknown")
+					: "unknown",
+				displayName: "Unknown",
+				bio: "Imported from archive collection metadata",
+				followersCount: 0,
+				followingCount: 0,
+				...defaultProfileMetadata,
+				avatarHue: 210,
+				avatarUrl: null,
+				createdAt: accountPayload.createdAt,
+			};
+			const existingUnknownProfile = existingProfiles.get("profile_unknown");
+			profiles.set(
+				"profile_unknown",
+				existingUnknownProfile
+					? existingProfileToProfileRow(existingUnknownProfile)
+					: unknownProfile,
+			);
+		}
 
-	const db = getNativeDb();
-	const insertAccount = db.prepare(`
+		const db = getNativeDb();
+		const insertAccount = db.prepare(`
     insert into accounts (id, name, handle, external_user_id, transport, is_default, created_at)
     values (?, ?, ?, ?, ?, 1, ?)
     on conflict(id) do update set
@@ -1588,11 +1815,11 @@ export async function importArchive(
       is_default = 1,
       created_at = excluded.created_at
   `);
-	const insertAccountIfMissing = db.prepare(`
+		const insertAccountIfMissing = db.prepare(`
     insert or ignore into accounts (id, name, handle, external_user_id, transport, is_default, created_at)
     values (?, ?, ?, ?, ?, 1, ?)
   `);
-	const insertProfile = db.prepare(`
+		const insertProfile = db.prepare(`
 	    insert into profiles (
 	      id, handle, display_name, bio, followers_count, following_count,
 	      public_metrics_json, avatar_hue, avatar_url, location, url, verified_type,
@@ -1615,7 +1842,7 @@ export async function importArchive(
         raw_json = excluded.raw_json,
         created_at = excluded.created_at
 	  `);
-	const insertProfileIfMissing = db.prepare(`
+		const insertProfileIfMissing = db.prepare(`
 	    insert or ignore into profiles (
 	      id, handle, display_name, bio, followers_count, following_count,
 	      public_metrics_json, avatar_hue, avatar_url, location, url, verified_type,
@@ -1623,7 +1850,7 @@ export async function importArchive(
 	    )
 	    values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 	  `);
-	const insertTweet = db.prepare(`
+		const insertTweet = db.prepare(`
     insert into tweets (
       id, account_id, author_profile_id, kind, text, created_at, is_replied,
       reply_to_id, like_count, media_count, bookmarked, liked, entities_json, media_json, quoted_tweet_id
@@ -1667,14 +1894,16 @@ export async function importArchive(
       media_json = case when excluded.media_json <> '[]' then excluded.media_json else tweets.media_json end,
       quoted_tweet_id = coalesce(excluded.quoted_tweet_id, tweets.quoted_tweet_id)
   `);
-	const deleteTweetFts = db.prepare(
-		"delete from tweets_fts where tweet_id = ?",
-	);
-	const insertTweetFts = db.prepare(
-		"insert into tweets_fts (tweet_id, text) values (?, ?)",
-	);
-	const selectTweetFtsText = db.prepare("select text from tweets where id = ?");
-	const insertTimelineEdge = db.prepare(`
+		const deleteTweetFts = db.prepare(
+			"delete from tweets_fts where tweet_id = ?",
+		);
+		const insertTweetFts = db.prepare(
+			"insert into tweets_fts (tweet_id, text) values (?, ?)",
+		);
+		const selectTweetFtsText = db.prepare(
+			"select text from tweets where id = ?",
+		);
+		const insertTimelineEdge = db.prepare(`
     insert into tweet_account_edges (
       account_id, tweet_id, kind, first_seen_at, last_seen_at, seen_count, source,
       raw_json, updated_at
@@ -1684,7 +1913,7 @@ export async function importArchive(
       last_seen_at = max(tweet_account_edges.last_seen_at, excluded.last_seen_at),
       updated_at = max(tweet_account_edges.updated_at, excluded.updated_at)
   `);
-	const insertCollection = db.prepare(`
+		const insertCollection = db.prepare(`
     insert into tweet_collections (
       account_id, tweet_id, kind, collected_at, source, raw_json, updated_at
     ) values (?, ?, ?, ?, ?, ?, ?)
@@ -1700,20 +1929,20 @@ export async function importArchive(
       end,
       updated_at = max(tweet_collections.updated_at, excluded.updated_at)
 	  `);
-	const insertConversation = db.prepare(`
+		const insertConversation = db.prepare(`
     insert into dm_conversations (
       id, account_id, participant_profile_id, title, last_message_at, unread_count, needs_reply
     ) values (?, ?, ?, ?, ?, ?, ?)
   `);
-	const insertMessage = db.prepare(`
+		const insertMessage = db.prepare(`
     insert into dm_messages (
       id, conversation_id, sender_profile_id, text, created_at, direction, is_replied, media_count
     ) values (?, ?, ?, ?, ?, ?, ?, ?)
   `);
-	const insertDmFts = db.prepare(
-		"insert into dm_fts (message_id, text) values (?, ?)",
-	);
-	const insertFollowSnapshot = db.prepare(`
+		const insertDmFts = db.prepare(
+			"insert into dm_fts (message_id, text) values (?, ?)",
+		);
+		const insertFollowSnapshot = db.prepare(`
     insert into follow_snapshots (
       id, account_id, direction, source, status, page_count, result_count,
       started_at, completed_at, raw_meta_json
@@ -1729,21 +1958,21 @@ export async function importArchive(
       completed_at = excluded.completed_at,
       raw_meta_json = excluded.raw_meta_json
   `);
-	const insertFollowSnapshotMember = db.prepare(`
+		const insertFollowSnapshotMember = db.prepare(`
     insert into follow_snapshot_members (
       snapshot_id, profile_id, external_user_id, position
     ) values (?, ?, ?, ?)
   `);
-	const selectFollowSnapshotMembers = db.prepare(`
+		const selectFollowSnapshotMembers = db.prepare(`
     select profile_id, external_user_id
     from follow_snapshot_members
     where snapshot_id = ?
     order by position, profile_id
   `);
-	const deleteFollowSnapshotMembers = db.prepare(
-		"delete from follow_snapshot_members where snapshot_id = ?",
-	);
-	const deleteArchiveFollowEvents = db.prepare(`
+		const deleteFollowSnapshotMembers = db.prepare(
+			"delete from follow_snapshot_members where snapshot_id = ?",
+		);
+		const deleteArchiveFollowEvents = db.prepare(`
     delete from follow_events
     where account_id = ? and direction = ? and (
       snapshot_id = ? or snapshot_id in (
@@ -1752,27 +1981,27 @@ export async function importArchive(
       )
     )
   `);
-	const deleteArchiveFollowSnapshotMembers = db.prepare(`
+		const deleteArchiveFollowSnapshotMembers = db.prepare(`
     delete from follow_snapshot_members
     where snapshot_id in (
       select id from follow_snapshots
       where account_id = ? and direction = ? and source = 'archive'
     )
   `);
-	const deleteArchiveFollowSnapshots = db.prepare(`
+		const deleteArchiveFollowSnapshots = db.prepare(`
     delete from follow_snapshots
     where account_id = ? and direction = ? and source = 'archive'
   `);
-	const deleteArchiveFollowEdges = db.prepare(`
+		const deleteArchiveFollowEdges = db.prepare(`
     delete from follow_edges
     where account_id = ? and direction = ? and source = 'archive'
   `);
-	const selectFollowEdges = db.prepare(`
+		const selectFollowEdges = db.prepare(`
     select profile_id, external_user_id, current
     from follow_edges
     where account_id = ? and direction = ?
   `);
-	const insertFollowEdge = db.prepare(`
+		const insertFollowEdge = db.prepare(`
     insert into follow_edges (
       account_id, direction, profile_id, external_user_id, source, current,
       first_seen_at, last_seen_at, ended_at, updated_at
@@ -1788,25 +2017,25 @@ export async function importArchive(
       ended_at = null,
       updated_at = excluded.updated_at
   `);
-	const endFollowEdge = db.prepare(`
+		const endFollowEdge = db.prepare(`
     update follow_edges
     set current = 0, ended_at = ?, updated_at = ?
     where account_id = ? and direction = ? and profile_id = ?
   `);
-	const insertFollowEvent = db.prepare(`
+		const insertFollowEvent = db.prepare(`
     insert into follow_events (
       id, account_id, direction, profile_id, external_user_id, kind, event_at, snapshot_id
     ) values (?, ?, ?, ?, ?, ?, ?, ?)
   `);
-	const clearSelectedLikes = db.prepare(`
+		const clearSelectedLikes = db.prepare(`
 	    delete from tweet_collections
 	    where account_id = ? and kind = 'likes' and source in ('archive', 'legacy')
 	  `);
-	const clearSelectedBookmarks = db.prepare(`
+		const clearSelectedBookmarks = db.prepare(`
 	    delete from tweet_collections
 	    where account_id = ? and kind = 'bookmarks' and source in ('archive', 'legacy')
 	  `);
-	const clearTweetLikedFlag = db.prepare(`
+		const clearTweetLikedFlag = db.prepare(`
 		    update tweets
 		    set liked = 0
 	    where account_id = ?
@@ -1816,7 +2045,7 @@ export async function importArchive(
 		      where account_id = ? and kind = 'likes' and source in ('archive', 'legacy')
 		    )
 	  `);
-	const clearTweetBookmarkedFlag = db.prepare(`
+		const clearTweetBookmarkedFlag = db.prepare(`
 		    update tweets
 		    set bookmarked = 0
 	    where account_id = ?
@@ -1826,7 +2055,7 @@ export async function importArchive(
 		      where account_id = ? and kind = 'bookmarks' and source in ('archive', 'legacy')
 		    )
 	  `);
-	const clearSelectedArchiveTweetEdges = db.prepare(`
+		const clearSelectedArchiveTweetEdges = db.prepare(`
 	    delete from tweet_account_edges
 	    where account_id = ?
 	      and kind in ('home', 'authored')
@@ -1844,12 +2073,12 @@ export async function importArchive(
 	        )
 	      )
 	  `);
-	const deleteOrphanTweetLinkOccurrences = db.prepare(`
+		const deleteOrphanTweetLinkOccurrences = db.prepare(`
 	    delete from link_occurrences
 	    where source_kind = 'tweet'
       and source_id not in (select id from tweets)
 	  `);
-	const deleteOrphanArchiveCollectionTweets = db.prepare(`
+		const deleteOrphanArchiveCollectionTweets = db.prepare(`
     delete from tweets
     where account_id = ?
       and kind in ('like', 'bookmark')
@@ -1870,7 +2099,7 @@ export async function importArchive(
 	          or referencing_tweet.quoted_tweet_id = tweets.id
 	      )
 	  `);
-	const demoteSelectedArchiveTweetsWithCollections = db.prepare(`
+		const demoteSelectedArchiveTweetsWithCollections = db.prepare(`
     update tweets
     set kind = case
       when exists (
@@ -1911,7 +2140,7 @@ export async function importArchive(
         where account_id = ?
       )
   `);
-	const preserveSelectedArchiveTweetsReferencedElsewhere = db.prepare(`
+		const preserveSelectedArchiveTweetsReferencedElsewhere = db.prepare(`
     update tweets
     set kind = 'archive_stale'
     where account_id = ?
@@ -1988,7 +2217,7 @@ export async function importArchive(
 	          )
 	      )
 	  `);
-	const deleteSelectedArchiveTweetsWithoutCollections = db.prepare(`
+		const deleteSelectedArchiveTweetsWithoutCollections = db.prepare(`
     delete from tweets
     where account_id = ?
 	      and id in (
@@ -2061,11 +2290,11 @@ export async function importArchive(
 	          )
 	      )
 	  `);
-	const deleteOrphanTweetFts = db.prepare(`
+		const deleteOrphanTweetFts = db.prepare(`
     delete from tweets_fts
     where tweet_id not in (select id from tweets)
   `);
-	const clearDmFts = db.prepare(`
+		const clearDmFts = db.prepare(`
     delete from dm_fts
     where message_id in (
       select m.id
@@ -2074,7 +2303,7 @@ export async function importArchive(
       where c.account_id = ?
     )
   `);
-	const clearDmLinkOccurrences = db.prepare(`
+		const clearDmLinkOccurrences = db.prepare(`
     delete from link_occurrences
     where source_kind = 'dm'
       and source_id in (
@@ -2084,362 +2313,435 @@ export async function importArchive(
         where c.account_id = ?
       )
   `);
-	const clearDmMessages = db.prepare(`
+		const clearDmMessages = db.prepare(`
     delete from dm_messages
     where conversation_id in (
       select id from dm_conversations where account_id = ?
     )
   `);
-	const clearDmConversations = db.prepare(
-		"delete from dm_conversations where account_id = ?",
-	);
+		const clearDmConversations = db.prepare(
+			"delete from dm_conversations where account_id = ?",
+		);
 
-	function importFollowRows(
-		direction: ArchiveFollowDirection,
-		rows: Array<{ profileId: string; externalUserId: string }>,
-		entryCount: number,
-		now: string,
-	) {
-		const snapshotId = `follow_snapshot_archive_acct_primary_${direction}`;
-		const existingEdges = new Map(
-			(
-				selectFollowEdges.all("acct_primary", direction) as Array<{
+		function importFollowRows(
+			direction: ArchiveFollowDirection,
+			rows: Array<{ profileId: string; externalUserId: string }>,
+			entryCount: number,
+			now: string,
+		) {
+			const snapshotId = `follow_snapshot_archive_acct_primary_${direction}`;
+			const existingEdges = new Map(
+				(
+					selectFollowEdges.all("acct_primary", direction) as Array<{
+						profile_id: string;
+						external_user_id: string;
+						current: number;
+					}>
+				).map((row) => [row.profile_id, row]),
+			);
+			const existingMemberKey = (
+				selectFollowSnapshotMembers.all(snapshotId) as Array<{
 					profile_id: string;
 					external_user_id: string;
-					current: number;
 				}>
-			).map((row) => [row.profile_id, row]),
-		);
-		const existingMemberKey = (
-			selectFollowSnapshotMembers.all(snapshotId) as Array<{
-				profile_id: string;
-				external_user_id: string;
-			}>
-		)
-			.map(
-				(row, index) =>
-					`${String(index)}:${row.profile_id}:${row.external_user_id}`,
 			)
-			.join("\n");
-		const nextMemberKey = rows
-			.map(
-				(row, index) =>
-					`${String(index)}:${row.profileId}:${row.externalUserId}`,
-			)
-			.join("\n");
-		const membersChanged = existingMemberKey !== nextMemberKey;
-		const currentProfileIds = new Set<string>();
-
-		insertFollowSnapshot.run(
-			snapshotId,
-			"acct_primary",
-			direction,
-			entryCount,
-			rows.length,
-			now,
-			now,
-			JSON.stringify({ archivePath, result_count: rows.length }),
-		);
-
-		if (membersChanged) {
-			deleteFollowSnapshotMembers.run(snapshotId);
-		}
-		rows.forEach((row, index) => {
-			const profileId = resolveProfileId(row.profileId);
-			currentProfileIds.add(profileId);
-			if (membersChanged) {
-				insertFollowSnapshotMember.run(
-					snapshotId,
-					profileId,
-					row.externalUserId,
-					index,
-				);
-			}
+				.map(
+					(row, index) =>
+						`${String(index)}:${row.profile_id}:${row.external_user_id}`,
+				)
+				.join("\n");
+			const nextMemberKey = rows
+				.map(
+					(row, index) =>
+						`${String(index)}:${row.profileId}:${row.externalUserId}`,
+				)
+				.join("\n");
+			const membersChanged = existingMemberKey !== nextMemberKey;
+			const currentProfileIds = new Set<string>();
 
-			const previous = existingEdges.get(profileId);
-			insertFollowEdge.run(
+			insertFollowSnapshot.run(
+				snapshotId,
 				"acct_primary",
 				direction,
-				profileId,
-				row.externalUserId,
-				now,
+				entryCount,
+				rows.length,
 				now,
 				now,
+				JSON.stringify({ archivePath, result_count: rows.length }),
 			);
-			if (!previous || previous.current === 0) {
+
+			if (membersChanged) {
+				deleteFollowSnapshotMembers.run(snapshotId);
+			}
+			rows.forEach((row, index) => {
+				const profileId = resolveProfileId(row.profileId);
+				currentProfileIds.add(profileId);
+				if (membersChanged) {
+					insertFollowSnapshotMember.run(
+						snapshotId,
+						profileId,
+						row.externalUserId,
+						index,
+					);
+				}
+
+				const previous = existingEdges.get(profileId);
+				insertFollowEdge.run(
+					"acct_primary",
+					direction,
+					profileId,
+					row.externalUserId,
+					now,
+					now,
+					now,
+				);
+				if (!previous || previous.current === 0) {
+					insertFollowEvent.run(
+						`follow_event_${randomUUID()}`,
+						"acct_primary",
+						direction,
+						profileId,
+						row.externalUserId,
+						"started",
+						now,
+						snapshotId,
+					);
+				}
+			});
+
+			for (const [profileId, previous] of existingEdges) {
+				if (previous.current === 0 || currentProfileIds.has(profileId)) {
+					continue;
+				}
+				endFollowEdge.run(now, now, "acct_primary", direction, profileId);
 				insertFollowEvent.run(
 					`follow_event_${randomUUID()}`,
 					"acct_primary",
 					direction,
 					profileId,
-					row.externalUserId,
-					"started",
+					previous.external_user_id,
+					"ended",
 					now,
 					snapshotId,
 				);
 			}
-		});
+		}
 
-		for (const [profileId, previous] of existingEdges) {
-			if (previous.current === 0 || currentProfileIds.has(profileId)) {
-				continue;
-			}
-			endFollowEdge.run(now, now, "acct_primary", direction, profileId);
-			insertFollowEvent.run(
-				`follow_event_${randomUUID()}`,
+		function clearArchiveFollowRows(direction: ArchiveFollowDirection) {
+			deleteArchiveFollowEvents.run(
+				"acct_primary",
+				direction,
+				`follow_snapshot_archive_acct_primary_${direction}`,
 				"acct_primary",
 				direction,
-				profileId,
-				previous.external_user_id,
-				"ended",
-				now,
-				snapshotId,
 			);
+			deleteArchiveFollowSnapshotMembers.run("acct_primary", direction);
+			deleteArchiveFollowSnapshots.run("acct_primary", direction);
+			deleteArchiveFollowEdges.run("acct_primary", direction);
 		}
-	}
-
-	function clearArchiveFollowRows(direction: ArchiveFollowDirection) {
-		deleteArchiveFollowEvents.run(
-			"acct_primary",
-			direction,
-			`follow_snapshot_archive_acct_primary_${direction}`,
-			"acct_primary",
-			direction,
-		);
-		deleteArchiveFollowSnapshotMembers.run("acct_primary", direction);
-		deleteArchiveFollowSnapshots.run("acct_primary", direction);
-		deleteArchiveFollowEdges.run("acct_primary", direction);
-	}
 
-	db.transaction(() => {
-		if (selection) {
-			if (includeTweets) {
-				clearAuthoredSyncCursors(db, "acct_primary");
-				demoteSelectedArchiveTweetsWithCollections.run(
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-					"acct_primary",
-				);
-				preserveSelectedArchiveTweetsReferencedElsewhere.run(
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-				);
-				deleteSelectedArchiveTweetsWithoutCollections.run(
-					"acct_primary",
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-				);
-				deleteOrphanTweetFts.run();
-				deleteOrphanTweetLinkOccurrences.run();
-				clearSelectedArchiveTweetEdges.run(
-					"acct_primary",
-					"acct_primary",
-					localProfile.id,
-				);
-			}
-			if (includeLikes) {
-				clearTweetLikedFlag.run("acct_primary", "acct_primary");
-				clearSelectedLikes.run("acct_primary");
-			}
-			if (includeBookmarks) {
-				clearTweetBookmarkedFlag.run("acct_primary", "acct_primary");
-				clearSelectedBookmarks.run("acct_primary");
-			}
-			if (includeLikes || includeBookmarks) {
-				deleteOrphanArchiveCollectionTweets.run("acct_primary");
-				deleteOrphanTweetFts.run();
-				deleteOrphanTweetLinkOccurrences.run();
-			}
-			if (includeDirectMessages) {
-				clearDmLinkOccurrences.run("acct_primary");
-				clearDmFts.run("acct_primary");
-				clearDmMessages.run("acct_primary");
-				clearDmConversations.run("acct_primary");
+		onProgress({ kind: "writing" });
+		const WRITE_PROGRESS_INTERVAL = 1000;
+		function tickWrite(
+			phase: ImportWritePhase,
+			processed: number,
+			total: number,
+		) {
+			if (processed === total || processed % WRITE_PROGRESS_INTERVAL === 0) {
+				onProgress({ kind: "write-progress", phase, processed, total });
 			}
 		}
+		db.transaction(() => {
+			if (!selection) {
+				clearImportedData(db);
+				clearMentionSyncState(db);
+			}
 
-		const writeAccount = selection ? insertAccountIfMissing : insertAccount;
-		writeAccount.run(
-			"acct_primary",
-			accountPayload.displayName,
-			`@${accountPayload.username}`,
-			accountPayload.accountId,
-			"archive",
-			accountPayload.createdAt,
-		);
-
-		const writeProfile =
-			!selection || includeProfiles ? insertProfile : insertProfileIfMissing;
-		for (const profile of profiles.values()) {
-			writeProfile.run(
-				profile.id,
-				profile.handle,
-				profile.displayName,
-				profile.bio,
-				profile.followersCount,
-				profile.followingCount,
-				profile.publicMetricsJson,
-				profile.avatarHue,
-				profile.avatarUrl,
-				profile.location,
-				profile.url,
-				profile.verifiedType,
-				profile.entitiesJson,
-				profile.rawJson,
-				profile.createdAt,
-			);
-		}
+			if (selection) {
+				if (includeTweets) {
+					clearAuthoredSyncCursors(db, "acct_primary");
+					demoteSelectedArchiveTweetsWithCollections.run(
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+						"acct_primary",
+					);
+					preserveSelectedArchiveTweetsReferencedElsewhere.run(
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+					);
+					deleteSelectedArchiveTweetsWithoutCollections.run(
+						"acct_primary",
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+					);
+					deleteOrphanTweetFts.run();
+					deleteOrphanTweetLinkOccurrences.run();
+					clearSelectedArchiveTweetEdges.run(
+						"acct_primary",
+						"acct_primary",
+						localProfile.id,
+					);
+				}
+				if (includeLikes) {
+					clearTweetLikedFlag.run("acct_primary", "acct_primary");
+					clearSelectedLikes.run("acct_primary");
+				}
+				if (includeBookmarks) {
+					clearTweetBookmarkedFlag.run("acct_primary", "acct_primary");
+					clearSelectedBookmarks.run("acct_primary");
+				}
+				if (includeLikes || includeBookmarks) {
+					deleteOrphanArchiveCollectionTweets.run("acct_primary");
+					deleteOrphanTweetFts.run();
+					deleteOrphanTweetLinkOccurrences.run();
+				}
+				if (includeDirectMessages) {
+					clearDmLinkOccurrences.run("acct_primary");
+					clearDmFts.run("acct_primary");
+					clearDmMessages.run("acct_primary");
+					clearDmConversations.run("acct_primary");
+				}
+			}
 
-		for (const tweet of tweetRows) {
-			const authorProfileId =
-				tweet.authorProfileId === "profile_me"
-					? localProfile.id
-					: resolveProfileId(tweet.authorProfileId);
-			insertTweet.run(
-				tweet.id,
+			const writeAccount = selection ? insertAccountIfMissing : insertAccount;
+			writeAccount.run(
 				"acct_primary",
-				authorProfileId,
-				tweet.kind,
-				tweet.text,
-				tweet.createdAt,
-				tweet.isReplied,
-				tweet.replyToId,
-				tweet.likeCount,
-				tweet.mediaCount,
-				tweet.bookmarked,
-				tweet.liked,
-				tweet.entitiesJson,
-				tweet.mediaJson,
-				tweet.quotedTweetId,
+				accountPayload.displayName,
+				`@${accountPayload.username}`,
+				accountPayload.accountId,
+				"archive",
+				accountPayload.createdAt,
 			);
-			deleteTweetFts.run(tweet.id);
-			if (tweet.kind === "home") {
-				insertTimelineEdge.run(
-					"acct_primary",
+
+			const writeProfile =
+				!selection || includeProfiles ? insertProfile : insertProfileIfMissing;
+			const profilesTotal = profiles.size;
+			if (profilesTotal > 0) {
+				onProgress({
+					kind: "write-start",
+					phase: "profiles",
+					total: profilesTotal,
+				});
+			}
+			let profileIndex = 0;
+			for (const profile of profiles.values()) {
+				writeProfile.run(
+					profile.id,
+					profile.handle,
+					profile.displayName,
+					profile.bio,
+					profile.followersCount,
+					profile.followingCount,
+					profile.publicMetricsJson,
+					profile.avatarHue,
+					profile.avatarUrl,
+					profile.location,
+					profile.url,
+					profile.verifiedType,
+					profile.entitiesJson,
+					profile.rawJson,
+					profile.createdAt,
+				);
+				profileIndex += 1;
+				tickWrite("profiles", profileIndex, profilesTotal);
+			}
+
+			if (tweetRows.length > 0) {
+				onProgress({
+					kind: "write-start",
+					phase: "tweets",
+					total: tweetRows.length,
+				});
+			}
+			let tweetWriteIndex = 0;
+			for (const tweet of tweetRows) {
+				const authorProfileId =
+					tweet.authorProfileId === "profile_me"
+						? localProfile.id
+						: resolveProfileId(tweet.authorProfileId);
+				insertTweet.run(
 					tweet.id,
+					"acct_primary",
+					authorProfileId,
 					tweet.kind,
+					tweet.text,
 					tweet.createdAt,
-					tweet.createdAt,
-					new Date().toISOString(),
+					tweet.isReplied,
+					tweet.replyToId,
+					tweet.likeCount,
+					tweet.mediaCount,
+					tweet.bookmarked,
+					tweet.liked,
+					tweet.entitiesJson,
+					tweet.mediaJson,
+					tweet.quotedTweetId,
 				);
+				deleteTweetFts.run(tweet.id);
+				if (tweet.kind === "home") {
+					insertTimelineEdge.run(
+						"acct_primary",
+						tweet.id,
+						tweet.kind,
+						tweet.createdAt,
+						tweet.createdAt,
+						new Date().toISOString(),
+					);
+				}
+				if (authorProfileId === localProfile.id) {
+					insertTimelineEdge.run(
+						"acct_primary",
+						tweet.id,
+						"authored",
+						tweet.createdAt,
+						tweet.createdAt,
+						new Date().toISOString(),
+					);
+				}
+				const storedTweet = selectTweetFtsText.get(tweet.id) as
+					| { text: string }
+					| undefined;
+				insertTweetFts.run(tweet.id, storedTweet?.text ?? tweet.text);
+				tweetWriteIndex += 1;
+				tickWrite("tweets", tweetWriteIndex, tweetRows.length);
+			}
+
+			const importedAt = new Date().toISOString();
+			if (collectionRows.length > 0) {
+				onProgress({
+					kind: "write-start",
+					phase: "collections",
+					total: collectionRows.length,
+				});
 			}
-			if (authorProfileId === localProfile.id) {
-				insertTimelineEdge.run(
+			let collectionIndex = 0;
+			for (const collection of collectionRows) {
+				insertCollection.run(
 					"acct_primary",
-					tweet.id,
-					"authored",
-					tweet.createdAt,
-					tweet.createdAt,
-					new Date().toISOString(),
+					collection.tweetId,
+					collection.kind,
+					collection.collectedAt,
+					collection.source,
+					collection.rawJson,
+					importedAt,
 				);
+				collectionIndex += 1;
+				tickWrite("collections", collectionIndex, collectionRows.length);
 			}
-			const storedTweet = selectTweetFtsText.get(tweet.id) as
-				| { text: string }
-				| undefined;
-			insertTweetFts.run(tweet.id, storedTweet?.text ?? tweet.text);
-		}
 
-		const importedAt = new Date().toISOString();
-		for (const collection of collectionRows) {
-			insertCollection.run(
-				"acct_primary",
-				collection.tweetId,
-				collection.kind,
-				collection.collectedAt,
-				collection.source,
-				collection.rawJson,
-				importedAt,
-			);
-		}
+			for (const conversation of conversations.values()) {
+				insertConversation.run(
+					conversation.id,
+					conversation.accountId,
+					conversation.participantProfileId,
+					conversation.title,
+					conversation.lastMessageAt,
+					conversation.unreadCount,
+					conversation.needsReply,
+				);
+			}
 
-		for (const conversation of conversations.values()) {
-			insertConversation.run(
-				conversation.id,
-				conversation.accountId,
-				conversation.participantProfileId,
-				conversation.title,
-				conversation.lastMessageAt,
-				conversation.unreadCount,
-				conversation.needsReply,
-			);
-		}
+			if (dmMessages.length > 0) {
+				onProgress({
+					kind: "write-start",
+					phase: "dmMessages",
+					total: dmMessages.length,
+				});
+			}
+			let dmWriteIndex = 0;
+			for (const message of dmMessages) {
+				insertMessage.run(
+					message.id,
+					message.conversationId,
+					message.senderProfileId,
+					message.text,
+					message.createdAt,
+					message.direction,
+					message.direction === "outbound" ? 1 : 0,
+					message.mediaCount,
+				);
+				insertDmFts.run(message.id, message.text);
+				dmWriteIndex += 1;
+				tickWrite("dmMessages", dmWriteIndex, dmMessages.length);
+			}
 
-		for (const message of dmMessages) {
-			insertMessage.run(
-				message.id,
-				message.conversationId,
-				message.senderProfileId,
-				message.text,
-				message.createdAt,
-				message.direction,
-				message.direction === "outbound" ? 1 : 0,
-				message.mediaCount,
-			);
-			insertDmFts.run(message.id, message.text);
-		}
+			if (includeFollowers && followerEntries.length > 0) {
+				importFollowRows(
+					"followers",
+					followerRows,
+					followerEntries.length,
+					importedAt,
+				);
+			} else if (includeFollowers) {
+				clearArchiveFollowRows("followers");
+			}
+			if (includeFollowing && followingEntries.length > 0) {
+				importFollowRows(
+					"following",
+					followingRows,
+					followingEntries.length,
+					importedAt,
+				);
+			} else if (includeFollowing) {
+				clearArchiveFollowRows("following");
+			}
+		})();
+		onProgress({ kind: "done" });
 
-		if (includeFollowers && followerEntries.length > 0) {
-			importFollowRows(
-				"followers",
-				followerRows,
-				followerEntries.length,
-				importedAt,
-			);
-		} else if (includeFollowers) {
-			clearArchiveFollowRows("followers");
-		}
-		if (includeFollowing && followingEntries.length > 0) {
-			importFollowRows(
-				"following",
-				followingRows,
-				followingEntries.length,
-				importedAt,
-			);
-		} else if (includeFollowing) {
-			clearArchiveFollowRows("following");
-		}
-	})();
+		return {
+			ok: true,
+			archivePath,
+			account: {
+				id: accountPayload.accountId,
+				handle: accountPayload.username,
+				displayName: accountPayload.displayName,
+			},
+			counts: {
+				tweets: authoredTweetCount,
+				likes: likeCount,
+				bookmarks: bookmarkCount,
+				dmConversations: conversations.size,
+				dmMessages: dmMessages.length,
+				profiles: profiles.size,
+				mediaFiles: mediaFileCounts,
+				followers: followerRows.length,
+				following: followingRows.length,
+			},
+		};
+	});
+}
 
-	return {
-		ok: true,
-		archivePath,
-		account: {
-			id: accountPayload.accountId,
-			handle: accountPayload.username,
-			displayName: accountPayload.displayName,
-		},
-		counts: {
-			tweets: authoredTweetCount,
-			likes: likeCount,
-			bookmarks: bookmarkCount,
-			dmConversations: conversations.size,
-			dmMessages: dmMessages.length,
-			profiles: profiles.size,
-			mediaFiles: mediaFileCounts,
-			followers: followerRows.length,
-			following: followingRows.length,
-		},
-	};
+export function importArchiveEffect(
+	archivePath: string,
+	options: ImportArchiveOptions = {},
+): Effect.Effect<ImportedArchiveSummary, unknown> {
+	return importArchiveInternalEffect(archivePath, options);
+}
+
+export function importArchive(
+	archivePath: string,
+	options: ImportArchiveOptions = {},
+): Promise<ImportedArchiveSummary> {
+	return runEffectPromise(importArchiveEffect(archivePath, options));
 }
 
 export const __test__ = {