diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 3e181ab..3a521e8 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -1,3 +1,5 @@
+import java.util.Properties
+
 plugins {
 	id("com.android.application")
 	id("kotlin-android")
@@ -54,6 +56,33 @@ android {
 		setProperty("archivesBaseName", "$applicationId-$versionName")
 	}
 
+	signingConfigs {
+		// A release build has to be signed to be installable at all. Put your own key details in
+		// keystore.properties (storeFile, storePassword, keyAlias, keyPassword) to sign with those;
+		// without that file this falls back to the standard debug key, which is fine for a build only
+		// ever sideloaded onto your own phone and has the advantage of installing over an existing
+		// debug build rather than making you uninstall and lose your imported stickers.
+		// Do not hand a debug-signed APK to anyone else.
+		create("sideload") {
+			val properties = Properties()
+			val keystoreFile = rootProject.file("keystore.properties")
+			if (keystoreFile.exists()) {
+				keystoreFile.inputStream().use { properties.load(it) }
+			}
+			if (properties.isEmpty) {
+				storeFile = File(System.getProperty("user.home"), ".android/debug.keystore")
+				storePassword = "android"
+				keyAlias = "androiddebugkey"
+				keyPassword = "android"
+			} else {
+				storeFile = rootProject.file(properties.getProperty("storeFile"))
+				storePassword = properties.getProperty("storePassword")
+				keyAlias = properties.getProperty("keyAlias")
+				keyPassword = properties.getProperty("keyPassword")
+			}
+		}
+	}
+
 	buildTypes {
 		getByName("debug") {
 			versionNameSuffix = "-debug"
@@ -61,6 +90,7 @@ android {
 		getByName("release") {
 			proguardFiles("proguard-android-optimize.txt", "proguard-rules.pro")
 			isMinifyEnabled = false
+			signingConfig = signingConfigs.getByName("sideload")
 		}
 	}
 
@@ -84,6 +114,7 @@ dependencies {
 	implementation("androidx.gridlayout:gridlayout:1.0.0")
 	implementation("io.noties.markwon:core:4.6.2")
 	implementation("com.elvishew:xlog:1.11.1")
+	testImplementation("junit:junit:4.13.2")
 	androidTestImplementation("junit:junit:4.13.2")
 	androidTestImplementation("androidx.test:core:1.6.1")
 	androidTestImplementation("androidx.test.ext:junit:1.2.1")
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/ImageKeyboard.kt b/app/src/main/java/com/fredhappyface/ewesticker/ImageKeyboard.kt
index 0dc9736..6c9ecf5 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/ImageKeyboard.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/ImageKeyboard.kt
@@ -2,9 +2,12 @@ package com.fredhappyface.ewesticker
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.content.res.Configuration
 import android.inputmethodservice.InputMethodService
+import android.net.Uri
 import android.os.Build
 import android.os.Build.VERSION.SDK_INT
+import android.provider.DocumentsContract
 import android.view.GestureDetector
 import android.view.HapticFeedbackConstants
 import android.view.MotionEvent
@@ -12,6 +15,7 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputMethodManager
+import android.widget.HorizontalScrollView
 import android.widget.ImageButton
 import android.widget.LinearLayout
 import android.widget.RelativeLayout
@@ -22,27 +26,59 @@ import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import coil.Coil
 import coil.ImageLoader
+import coil.decode.BitmapFactoryDecoder
 import coil.decode.GifDecoder
 import coil.decode.ImageDecoderDecoder
 import coil.decode.SvgDecoder
 import coil.decode.VideoFrameDecoder
 import coil.imageLoader
 import coil.load
+import coil.memory.MemoryCache
 import com.elvishew.xlog.XLog
+import com.fredhappyface.ewesticker.adapter.AllPacksAdapter
 import com.fredhappyface.ewesticker.adapter.StickerPackAdapter
 import com.fredhappyface.ewesticker.model.StickerPack
 import com.fredhappyface.ewesticker.utilities.Cache
+import com.fredhappyface.ewesticker.utilities.StickerKeySet
+import com.fredhappyface.ewesticker.utilities.SourceListing
 import com.fredhappyface.ewesticker.utilities.StickerClickListener
 import com.fredhappyface.ewesticker.utilities.StickerSender
 import com.fredhappyface.ewesticker.utilities.Toaster
 import com.fredhappyface.ewesticker.utilities.startLogger
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.io.File
 import kotlin.math.abs
 import kotlin.math.min
 
+/** Tag of the synthetic tab holding starred stickers */
+private const val FAVOURITES_PACK = "__favourites__"
+
+/** Tag of the synthetic tab holding recently sent stickers */
+private const val RECENT_PACK = "__recentSticker__"
+
+/** Ceiling on how much of the source tree is walked when checking a pack is really empty */
+private const val MAX_TREE_ENTRIES = 4096
+
+/** Formats the platform's own bitmap decoder can read, so a still frame can be requested */
+private val PLATFORM_DECODABLE =
+	setOf("webp", "gif", "png", "jpg", "jpeg", "heif", "heic", "bmp")
+
+/** How long a delete stays armed before it forgets it was asked */
+private const val DELETE_ARM_MS = 4000L
+
 private const val SWIPE_THRESHOLD = 1
 private const val SWIPE_VELOCITY_THRESHOLD = 1
 
+/** Height the vertical grid starts at before the user has ever dragged the handle. */
+private const val DEFAULT_VERTICAL_HEIGHT = 800
+
+/** Ceiling for a dragged height, as a fraction of the screen, so the target app keeps a strip. */
+private const val MAX_HEIGHT_FRACTION = 0.85f
+
 /**
  * ImageKeyboard class inherits from the InputMethodService class - provides the keyboard
  * functionality
@@ -60,6 +96,9 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	private var iconSize = 0
 	private var insensitiveSort = false
 	private var isPngFallback = true
+	private var continuousScroll = true
+	private var generateGifVariants = false
+	private var animateGrid = false
 
 	//  Constants
 	private lateinit var internalDir: File
@@ -74,6 +113,7 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	//  Caches
 	private var compatCache = Cache()
 	private var recentCache = Cache()
+	private lateinit var favourites: StickerKeySet
 
 	// onStartInput
 	private lateinit var stickerSender: StickerSender
@@ -81,13 +121,35 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	// onCreateInputView
 	private lateinit var keyboardRoot: ViewGroup
 	private lateinit var packsList: ViewGroup
+	private var packsScroller: HorizontalScrollView? = null
 	private lateinit var packContent: ViewGroup
 	private var keyboardHeight = 0
 	private var fullIconSize = 0
 	private var qwertyWidth = 0
 
+	private lateinit var resizeHandle: View
+
+	// Drag state. Each MOVE is measured from where the finger went down rather than from the
+	// previous frame, so the height cannot drift as rounding errors accumulate over a long drag.
+	private var dragStartRawY = 0f
+	private var dragStartHeight = 0
+
+	// The all-packs list, plus where each pack's header sits in it, held highest position first so
+	// that a scroll can find the pack currently in view by taking the first entry at or above it.
+	private var allPacksView: RecyclerView? = null
+	private var packHeaderPositions: Map<String, Int> = emptyMap()
+	private var packHeadersByPosition: List<Pair<Int, String>> = emptyList()
+
 	private lateinit var gestureDetector: GestureDetector
 
+	/**
+	 * The configuration generation this keyboard has applied. MainActivity bumps the stored one
+	 * whenever a preference or the sticker library changes, which is how a running keyboard notices
+	 * without being restarted by hand.
+	 */
+	private var appliedVersion = 0
+	private var rebuildInputView = false
+
 	/**
 	 * When the activity is created...
 	 * - ensure coil can decode (and display) animated images
@@ -102,7 +164,6 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		XLog.i("=".repeat(80))
 		XLog.i("Loaded $packageName:${javaClass.name}")
 
-		val scale = baseContext.resources.displayMetrics.density
 		// Setup coil
 		val imageLoader =
 			ImageLoader.Builder(baseContext)
@@ -115,6 +176,11 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 					add(VideoFrameDecoder.Factory())
 					add(SvgDecoder.Factory())
 				}
+				// Stated rather than inherited: this process draws a grid of several hundred stickers
+				// and the default is a share of an app heap that was never sized with that in mind.
+				.memoryCache {
+					MemoryCache.Builder(baseContext).maxSizePercent(0.25).build()
+				}
 				.build()
 		Coil.setImageLoader(imageLoader)
 		//  Shared Preferences
@@ -125,18 +191,41 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		XLog.i("Loading private shared preferences: ${this.sharedPreferences.all}")
 		XLog.i("Loading backup shared preferences: ${this.backupSharedPreferences.all}")
 
+		this.internalDir = File(filesDir, "stickers")
+		this.toaster = Toaster(baseContext)
+		this.favourites = StickerKeySet(this.backupSharedPreferences, "favourites")
+
+		loadPreferences()
+		loadPacks()
+		this.appliedVersion = this.backupSharedPreferences.getInt("libraryVersion", 0)
+
+		loadCaches()
+		window.window?.navigationBarColor = getColor(R.color.bg)
+	}
+
+	/**
+	 * Read every preference the keyboard acts on, plus the sizing derived from them. Split out of
+	 * onCreate so a running keyboard can pick up a settings change instead of having to be restarted.
+	 */
+	private fun loadPreferences() {
+		val scale = baseContext.resources.displayMetrics.density
 		this.restoreOnClose = this.backupSharedPreferences.getBoolean("restoreOnClose", false)
 		this.vertical = this.backupSharedPreferences.getBoolean("vertical", false)
 		this.scroll = this.backupSharedPreferences.getBoolean("scroll", false)
 		this.vibrate = this.backupSharedPreferences.getBoolean("vibrate", true)
 		this.insensitiveSort = this.backupSharedPreferences.getBoolean("insensitiveSort", false)
 		this.isPngFallback = this.backupSharedPreferences.getBoolean("isPngFallback", true)
+		this.continuousScroll = this.backupSharedPreferences.getBoolean("continuousScroll", true)
+		this.generateGifVariants =
+			this.backupSharedPreferences.getBoolean("generateGifVariants", false)
+		// Off by default: a still frame is memory-cacheable where an AnimatedImageDrawable is not, so
+		// the grid stops re-decoding every animated sticker as it scrolls. Verified on device that the
+		// platform decoder does return a first frame for an animated webp.
+		this.animateGrid = this.backupSharedPreferences.getBoolean("animateGrid", false)
 
 		this.iconsPerX = this.backupSharedPreferences.getInt("iconsPerX", 3)
 		this.totalIconPadding =
 			(resources.getDimension(R.dimen.sticker_padding) * 2 * (this.iconsPerX + 1)).toInt()
-		//  Constants
-		this.internalDir = File(filesDir, "stickers")
 		this.iconSize =
 			(
 				if (this.vertical) {
@@ -145,32 +234,73 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 					(this.backupSharedPreferences.getInt("iconSize", 80) * scale)
 				}
 				).toInt()
-		this.toaster = Toaster(baseContext)
-		//  Load Packs
+	}
+
+	/**
+	 * Scan the imported sticker tree. Rebuilds both collections from scratch rather than adding to
+	 * them, since this now runs more than once per process.
+	 */
+	private fun loadPacks() {
 		this.loadedPacks = HashMap()
 		val packs =
 			this.internalDir.listFiles { obj: File ->
 				obj.isDirectory && !obj.absolutePath.contains("__compatSticker__")
 			}
 				?: arrayOf()
+		var stickers = listOf<File>()
 		for (file in packs) {
 			val pack = StickerPack(file)
 			if (pack.stickerList.isNotEmpty()) {
 				this.loadedPacks[file.name] = pack
 			}
-			this.allStickers += pack.stickerList
+			stickers = stickers + pack.stickerList
 		}
-
+		this.allStickers = stickers
 		XLog.i("Loaded all packs: [${this.loadedPacks.keys.joinToString(", ")}]")
+	}
+
+	/**
+	 * Restore the recents and compat caches, and which pack was last open.
+	 *
+	 * These have to be re-read on a reload, not just at startup: choosing a new sticker directory
+	 * clears them in the settings screen, and a keyboard still holding the old ones writes them
+	 * straight back over that reset in onFinishInput, leaving recents pointing at deleted files for
+	 * good. The existing Cache instances are refilled rather than replaced because StickerSender
+	 * captures compatCache by identity and would otherwise keep writing into an orphan.
+	 */
+	private fun loadCaches() {
 		this.activePack = this.sharedPreferences.getString("activePack", "").toString()
-		//  Caches
-		this.sharedPreferences.getString("recentCache", "")?.let {
-			this.recentCache.fromSharedPref(it)
+		this.recentCache.fromSharedPref(this.sharedPreferences.getString("recentCache", "") ?: "")
+		this.compatCache.fromSharedPref(this.sharedPreferences.getString("compatCache", "") ?: "")
+		XLog.i(
+			"Loaded caches (recents=${this.recentCache.toFiles().size}, " +
+				"compat=${this.compatCache.toFiles().size}, activePack='${this.activePack}')",
+		)
+	}
+
+	/**
+	 * Pick up a settings change or a re-import if one happened since this keyboard last looked. Only
+	 * re-reads from disk when the stored generation actually moved, so focusing a field stays cheap.
+	 */
+	private fun reloadIfConfigurationChanged() {
+		val version = this.backupSharedPreferences.getInt("libraryVersion", 0)
+		if (version == this.appliedVersion) {
+			return
 		}
-		this.sharedPreferences.getString("compatCache", "")?.let {
-			this.compatCache.fromSharedPref(it)
+		XLog.i("Configuration changed (v${this.appliedVersion} -> v$version), reloading")
+		loadPreferences()
+		loadPacks()
+		loadCaches()
+		this.appliedVersion = version
+		// onStartInputView is skipped when an app merely restarts input on a field it already owns,
+		// so a view that is on screen right now would otherwise keep rendering the previous library
+		// and sizing. Replace it here in that case, and defer otherwise.
+		if (isInputViewShown()) {
+			XLog.i("Rebuilding the visible input view for the new configuration")
+			setInputView(onCreateInputView())
+		} else {
+			this.rebuildInputView = true
 		}
-		window.window?.navigationBarColor = getColor(R.color.bg)
 	}
 
 	/**
@@ -187,27 +317,156 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 
 		this.keyboardRoot = keyboardLayout.findViewById(R.id.keyboardRoot)
 		this.packsList = keyboardLayout.findViewById(R.id.packsList)
+		this.packsScroller = keyboardLayout.findViewById(R.id.topHScrollView)
 		this.packContent = keyboardLayout.findViewById(R.id.packContent)
-		this.keyboardHeight =
-			if (this.vertical) {
-				800
-			} else {
-				this.iconSize * this.iconsPerX + this.totalIconPadding
-			}
+		this.resizeHandle = keyboardLayout.findViewById(R.id.resizeHandle)
+		attachResizeHandle()
+		this.keyboardHeight = storedKeyboardHeight()
 		this.packContent.layoutParams?.height = this.keyboardHeight
-		this.fullIconSize =
-			(
-				min(
-					resources.displayMetrics.widthPixels,
-					this.keyboardHeight -
-						resources.getDimensionPixelOffset(R.dimen.text_size_body) * 2,
-				) * 0.95
-				)
-				.toInt()
+		this.fullIconSize = fullIconSizeFor(this.keyboardHeight)
 		createPackIcons()
+		// Whatever this returns is already built from the current configuration, so a pending
+		// rebuild is satisfied; leaving the flag set would inflate the whole keyboard a second time.
+		this.rebuildInputView = false
 		return keyboardLayout
 	}
 
+	/**
+	 * Portrait and landscape keep separate heights. One shared value either overflows the shorter
+	 * screen or wastes most of the taller one, and clamping cannot tell the two apart after the
+	 * fact because it only ever sees the current screen.
+	 */
+	private fun keyboardHeightKey(): String =
+		if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+			"keyboardHeightLandscape"
+		} else {
+			"keyboardHeight"
+		}
+
+	/** What the keyboard was before the user ever dragged it. */
+	private fun defaultKeyboardHeight(): Int =
+		if (this.vertical) {
+			DEFAULT_VERTICAL_HEIGHT
+		} else {
+			this.iconSize * this.iconsPerX + this.totalIconPadding
+		}
+
+	// Two pack rows keeps a row of stickers plus its padding reachable at the smallest size.
+	private fun minKeyboardHeight(): Int =
+		resources.getDimensionPixelOffset(R.dimen.pack_dimens) * 2
+
+	private fun maxKeyboardHeight(): Int =
+		(resources.displayMetrics.heightPixels * MAX_HEIGHT_FRACTION).toInt()
+			.coerceAtLeast(minKeyboardHeight())
+
+	/**
+	 * The height to open at: whatever was last dragged to, else the default. Clamped on the way
+	 * out, because a height stored on one screen can be impossible on another -- a foldable being
+	 * opened, or a display-size change -- and a stale value must never leave the keyboard unusable.
+	 */
+	private fun storedKeyboardHeight(): Int {
+		val stored = this.backupSharedPreferences.getInt(keyboardHeightKey(), 0)
+		val height = if (stored > 0) stored else defaultKeyboardHeight()
+		return height.coerceIn(minKeyboardHeight(), maxKeyboardHeight())
+	}
+
+	/**
+	 * Long-press preview image size for a given keyboard height. The preview surface carries a
+	 * header row and a caption around the image, so the image has to leave room for them or the
+	 * surface grows past the keyboard and clips.
+	 */
+	private fun fullIconSizeFor(height: Int): Int {
+		val previewChrome = resources.getDimensionPixelOffset(R.dimen.pack_dimens) +
+			resources.getDimensionPixelOffset(R.dimen.text_size_body) * 4
+		return (min(resources.displayMetrics.widthPixels, height - previewChrome) * 0.92)
+			.toInt()
+			.coerceAtLeast(resources.getDimensionPixelOffset(R.dimen.pack_dimens))
+	}
+
+	/**
+	 * Drag the handle to resize the keyboard. Guarded end to end: an exception escaping a touch
+	 * listener kills the keyboard mid-typing, so a failure here abandons the gesture instead.
+	 */
+	private fun attachResizeHandle() {
+		this.resizeHandle.setOnTouchListener { view, event ->
+			try {
+				when (event.actionMasked) {
+					MotionEvent.ACTION_DOWN -> {
+						this.dragStartRawY = event.rawY
+						this.dragStartHeight = this.keyboardHeight
+						view.isPressed = true
+						true
+					}
+
+					MotionEvent.ACTION_MOVE -> {
+						// The keyboard grows upward from the bottom of the screen, so a finger
+						// moving towards the top -- a falling rawY -- has to increase the height.
+						applyKeyboardHeight(
+							this.dragStartHeight + (this.dragStartRawY - event.rawY).toInt(),
+						)
+						true
+					}
+
+					MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+						view.isPressed = false
+						// apply(), not commit(): this is the thread drawing the keyboard.
+						this.backupSharedPreferences.edit()
+							.putInt(keyboardHeightKey(), this.keyboardHeight)
+							.apply()
+						if (event.actionMasked == MotionEvent.ACTION_UP) {
+							view.performClick()
+						}
+						true
+					}
+
+					else -> false
+				}
+			} catch (e: Throwable) {
+				XLog.e("Resize gesture failed, abandoning it")
+				XLog.e(e)
+				this.resizeHandle.isPressed = false
+				false
+			}
+		}
+	}
+
+	/** Apply a height mid-drag, bringing everything derived from the old one along with it. */
+	private fun applyKeyboardHeight(target: Int) {
+		val clamped = target.coerceIn(minKeyboardHeight(), maxKeyboardHeight())
+		if (clamped == this.keyboardHeight) {
+			return
+		}
+		this.keyboardHeight = clamped
+		this.packContent.layoutParams?.height = clamped
+		this.packContent.requestLayout()
+		this.fullIconSize = fullIconSizeFor(clamped)
+		resizeSearchResults(clamped)
+	}
+
+	/**
+	 * Keep an open search view's results box in step. Rebuilding the view would be simpler but
+	 * would throw away whatever has been typed, so only the box is resized here; the result cells
+	 * pick up the new size on the next keystroke.
+	 */
+	private fun resizeSearchResults(height: Int) {
+		val results = this.packContent.findViewById<LinearLayout>(R.id.search_results) ?: return
+		val chrome = resources.getDimension(R.dimen.qwerty_row_height) * 5
+		results.layoutParams?.height = (height - chrome)
+			.coerceAtLeast(resources.getDimension(R.dimen.pack_dimens))
+			.toInt()
+		results.requestLayout()
+	}
+
+	/** Install a freshly built input view when the configuration moved under us. */
+	override fun onStartInputView(info: EditorInfo?, restarting: Boolean) {
+		super.onStartInputView(info, restarting)
+		if (this.rebuildInputView) {
+			this.rebuildInputView = false
+			XLog.i("Rebuilding the input view for the new configuration")
+			setInputView(onCreateInputView())
+		}
+	}
+
 	/**
 	 * Disable full-screen mode as content will likely be hidden by the IME.
 	 *
@@ -224,6 +483,14 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	 * @param restarting
 	 */
 	override fun onStartInput(info: EditorInfo?, restarting: Boolean) {
+		// Before building the sender, because it captures isPngFallback and generateGifVariants and
+		// would otherwise stay a session behind a change to either.
+		reloadIfConfigurationChanged()
+		// The outgoing sender may still be finishing a conversion; tell it not to act on a field it
+		// no longer owns.
+		if (this::stickerSender.isInitialized) {
+			this.stickerSender.abandon()
+		}
 		this.stickerSender = StickerSender(
 			this.baseContext,
 			this.toaster,
@@ -233,6 +500,7 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 			this.compatCache,
 			this.imageLoader,
 			this.isPngFallback,
+			this.generateGifVariants,
 		)
 	}
 
@@ -244,6 +512,9 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		editor.putString("compatCache", this.compatCache.toSharedPref())
 		editor.putString("activePack", this.activePack)
 		editor.apply()
+		if (this::stickerSender.isInitialized) {
+			this.stickerSender.abandon()
+		}
 		super.onFinishInput()
 		if (restoreOnClose) {
 			closeKeyboard()
@@ -259,20 +530,15 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	private fun switchPackLayout(packName: String) {
 		XLog.i("Switching pack to '$packName'")
 		this.activePack = packName
-		for (packCard in this.packsList) {
-			val packButton = packCard.findViewById<ImageButton>(R.id.stickerButton)
-			if (packButton.tag == packName) {
-				(packButton as ImageButton).setColorFilter(getColor(R.color.accent_a))
-			} else {
-				(packButton as ImageButton).setColorFilter(getColor(R.color.transparent))
-			}
-		}
+		highlightPackButton(packName)
 
-		val stickers: Array<File>
-		if (packName == "__recentSticker__") {
-			stickers = this.recentCache.toFiles().reversedArray()
-		} else {
-			stickers = loadedPacks[packName]?.stickerList ?: return
+		// Both synthetic tabs are filtered through isFile: they are built from stored paths, and an
+		// import that drops or renames a sticker would otherwise leave a blank cell that still commits
+		// a uri to a file which is not there -- reporting success and delivering nothing.
+		val stickers: Array<File> = when (packName) {
+			FAVOURITES_PACK -> this.favourites.resolve(this.internalDir)
+			RECENT_PACK -> this.recentCache.toFiles().filter { it.isFile }.reversed().toTypedArray()
+			else -> loadedPacks[packName]?.stickerList ?: return
 		}
 		val recyclerView = RecyclerView(this)
 		val adapter = StickerPackAdapter(
@@ -280,7 +546,8 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 			stickers,
 			this,
 			gestureDetector,
-			this.vibrate
+			this.vibrate,
+			this.animateGrid,
 		)
 		val layoutManager = GridLayoutManager(
 			this,
@@ -290,24 +557,167 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		)
 		recyclerView.layoutManager = layoutManager
 		recyclerView.adapter = adapter
+		allPacksView = null
 		packContent.removeAllViewsInLayout()
 		packContent.addView(recyclerView)
 	}
 
 	/**
-	 * Set the current tab to the search page/ view
+	 * Tint the pack bar so that only the given tab reads as selected.
+	 *
+	 * @param tag String tag of the pack button to mark active
 	 */
-	private fun searchView() {
-		XLog.i("Switching to search")
+	private fun highlightPackButton(tag: String) {
+		var activeCard: View? = null
 		for (packCard in this.packsList) {
 			val packButton = packCard.findViewById<ImageButton>(R.id.stickerButton)
-			if (packButton.tag == "__search__") {
-				(packButton as ImageButton).setColorFilter(getColor(R.color.accent_a))
-			} else {
-				(packButton as ImageButton).setColorFilter(getColor(R.color.transparent))
+			val active = packButton.tag == tag
+			// A filled container behind the icon, not a colour filter over it. Tinting recoloured the
+			// sticker artwork itself, which is why a selected pack used to look washed out.
+			packCard.setBackgroundResource(if (active) R.drawable.pack_selected else 0)
+			if (active) {
+				activeCard = packCard
 			}
 		}
 
+		// With a button per pack the bar is several screens wide, so tinting a card means nothing
+		// unless the bar is also brought to it - otherwise the highlight that follows the sticker
+		// list is usually scrolled out of sight. Deferred because a card laid out this frame has no
+		// position yet.
+		val card = activeCard ?: return
+		val scroller = this.packsScroller ?: return
+		scroller.post {
+			val centred = card.left - (scroller.width - card.width) / 2
+			scroller.smoothScrollTo(centred.coerceAtLeast(0), 0)
+		}
+	}
+
+	/** Pack names in the order the pack bar shows them */
+	private fun sortedPackNames(): List<String> =
+		if (this.insensitiveSort) {
+			this.loadedPacks.keys.sortedWith(String.CASE_INSENSITIVE_ORDER)
+		} else {
+			this.loadedPacks.keys.sorted()
+		}
+
+	/**
+	 * Show every pack in one scrollable list, each behind a labelled divider, and optionally jump
+	 * straight to one of them.
+	 *
+	 * @param scrollToPack String? pack to bring to the top, or null to stay at the beginning
+	 */
+	private fun showAllPacks(scrollToPack: String?) {
+		val items = mutableListOf<AllPacksAdapter.Item>()
+		val positions = mutableMapOf<String, Int>()
+		for (packName in sortedPackNames()) {
+			val pack = this.loadedPacks[packName] ?: continue
+			positions[packName] = items.size
+			items.add(AllPacksAdapter.Item.PackHeader(packName))
+			pack.stickerList.forEach { items.add(AllPacksAdapter.Item.Sticker(it)) }
+		}
+		if (items.isEmpty()) {
+			return
+		}
+		this.packHeaderPositions = positions
+		this.packHeadersByPosition = positions.map { it.value to it.key }.sortedByDescending { it.first }
+
+		val adapter =
+			AllPacksAdapter(iconSize, items, this, gestureDetector, this.vibrate, this.animateGrid)
+		val layoutManager = GridLayoutManager(this, iconsPerX, RecyclerView.VERTICAL, false)
+		layoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
+			// A pack label is a divider and a name, so it needs the whole row rather than one cell.
+			override fun getSpanSize(position: Int): Int =
+				if (adapter.isHeader(position)) iconsPerX else 1
+		}
+
+		val recyclerView = RecyclerView(this)
+		recyclerView.layoutManager = layoutManager
+		recyclerView.adapter = adapter
+		recyclerView.addOnScrollListener(
+			object : RecyclerView.OnScrollListener() {
+				/**
+				 * Whether the list is moving because it was dragged. Jumping to a pack settles over
+				 * several layout passes, and treating those as scrolling would walk the remembered
+				 * pack through everything in between and save whichever one it stopped on.
+				 */
+				private var dragged = false
+
+				override fun onScrollStateChanged(view: RecyclerView, state: Int) {
+					when (state) {
+						RecyclerView.SCROLL_STATE_DRAGGING -> dragged = true
+						RecyclerView.SCROLL_STATE_IDLE -> dragged = false
+						else -> Unit // settling after a fling still counts as the user's scroll
+					}
+				}
+
+				override fun onScrolled(view: RecyclerView, dx: Int, dy: Int) {
+					if (!dragged) {
+						return
+					}
+					val first = layoutManager.findFirstVisibleItemPosition()
+					if (first == RecyclerView.NO_POSITION) {
+						return
+					}
+					// Keep the pack bar reflecting whatever is on screen, so scrolling past the end
+					// of a pack moves the highlight along with it.
+					val visiblePack =
+						packHeadersByPosition.firstOrNull { it.first <= first }?.second ?: return
+					if (visiblePack != activePack) {
+						XLog.i("Scrolled into pack '$visiblePack' (row $first)")
+						activePack = visiblePack
+						highlightPackButton(visiblePack)
+					}
+				}
+			},
+		)
+
+		packContent.removeAllViewsInLayout()
+		packContent.addView(recyclerView)
+		this.allPacksView = recyclerView
+
+		val target = scrollToPack ?: sortedPackNames().firstOrNull()
+		if (target != null) {
+			positions[target]?.let { layoutManager.scrollToPositionWithOffset(it, 0) }
+			this.activePack = target
+			highlightPackButton(target)
+		}
+	}
+
+	/**
+	 * Bring a pack to the top of the all-packs list, building that list first if some other tab (the
+	 * recents grid or the search page) is currently showing.
+	 *
+	 * @param packName String pack to scroll to
+	 */
+	private fun jumpToPack(packName: String) {
+		val recyclerView = this.allPacksView
+		if (recyclerView == null || recyclerView.parent !== packContent) {
+			showAllPacks(packName)
+			return
+		}
+		val position = this.packHeaderPositions[packName] ?: return
+		(recyclerView.layoutManager as? GridLayoutManager)?.scrollToPositionWithOffset(position, 0)
+		this.activePack = packName
+		highlightPackButton(packName)
+	}
+
+	/** Show a pack, either by scrolling the combined list to it or by showing it on its own */
+	private fun selectPack(packName: String) {
+		if (this.continuousScroll && this.vertical) {
+			jumpToPack(packName)
+		} else {
+			switchPackLayout(packName)
+		}
+	}
+
+	/**
+	 * Set the current tab to the search page/ view
+	 */
+	private fun searchView() {
+		XLog.i("Switching to search")
+		highlightPackButton("__search__")
+		allPacksView = null
+
 		qwertyWidth = (resources.displayMetrics.widthPixels / 10.4).toInt()
 
 		val qwertyLayout = layoutInflater.inflate(R.layout.qwerty_layout, packContent, false)
@@ -321,20 +731,43 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 						resources.getDimension(R.dimen.qwerty_row_height) * 4
 					)
 
-		searchResults.layoutParams.height = searchResultsHeight.toInt()
+		// Never below one row: with few rows, a small icon size or a large font scale the qwerty rows
+		// can cost more than the whole keyboard height, and everything derived from this went negative.
+		val usableResultsHeight =
+			searchResultsHeight.coerceAtLeast(resources.getDimension(R.dimen.pack_dimens))
+		searchResults.layoutParams.height = usableResultsHeight.toInt()
 
 		fun searchStickers(query: String): List<File> {
-			return this.allStickers.filter { it.name.contains(query, ignoreCase = true) }
+			// Every whitespace-separated token has to appear somewhere in "pack/filename", so word
+			// order does not matter and a pack name narrows the results like any other term.
+			val terms = query.split(' ', '\t').filter { it.isNotBlank() }
+			if (terms.isEmpty()) {
+				return emptyList()
+			}
+			// Results are capped downstream, and matching pack names means one big pack can now fill
+			// that cap on its name alone. Rank a sticker whose own name matches above one that only
+			// matched through its pack, so the obvious hit is never the entry that gets truncated.
+			return this.allStickers.mapNotNull { sticker ->
+				val name = sticker.nameWithoutExtension
+				val pack = sticker.parentFile?.name.orEmpty()
+				val haystack = "$pack/$name"
+				if (!terms.all { haystack.contains(it, ignoreCase = true) }) {
+					return@mapNotNull null
+				}
+				val inName = terms.count { name.contains(it, ignoreCase = true) }
+				sticker to inName
+			}.sortedByDescending { it.second }.map { it.first }
 		}
 
 		fun updateSearchResults(stickers: List<File>) {
 			val recyclerView = RecyclerView(baseContext)
 			val adapter = StickerPackAdapter(
-				(searchResultsHeight * 0.9).toInt(),
+				(usableResultsHeight * 0.9).toInt().coerceAtLeast(1),
 				stickers.take(128).toTypedArray(),
 				this,
 				gestureDetector,
 				this.vibrate,
+				this.animateGrid,
 			)
 			val layoutManager = GridLayoutManager(
 				baseContext,
@@ -436,13 +869,23 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		val packCard = layoutInflater.inflate(R.layout.sticker_card, this.packsList, false)
 		val packButton = packCard.findViewById<ImageButton>(R.id.stickerButton)
 		packButton.tag = tag
-		packButton.setOnClickListener { switchPackLayout(it?.tag as String) }
+		packButton.setOnClickListener { selectPack(it?.tag as String) }
 		this.packsList.addView(packCard)
 		return packButton
 	}
 
 	/** Create the pack icons (image buttons) that when tapped switch the pack (switchPackLayout) */
 	private fun createPackIcons() {
+		buildPackBar()
+		restoreActivePack()
+	}
+
+	/**
+	 * Rebuild the pack bar only. Kept separate from choosing what to show, so that something which
+	 * merely changes the set of buttons -- starring the first sticker, unstarring the last -- does not
+	 * also renavigate and throw away where the user had scrolled to.
+	 */
+	private fun buildPackBar() {
 		this.packsList.removeAllViewsInLayout()
 		// Back button
 		if (this.backupSharedPreferences.getBoolean("showBackButton", true)) {
@@ -462,28 +905,167 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 			}
 		}
 		// Recent
-		val recentPackName = "__recentSticker__"
+		val recentPackName = RECENT_PACK
 		val recentButton = addPackButton(recentPackName)
 		recentButton.load(getDrawable(R.drawable.time))
 		recentButton.setOnClickListener { switchPackLayout(recentPackName) }
+		// Favourites, only once there is something in it -- an always-present empty tab is noise
+		if (!!this.favourites.hasAny(this.internalDir)) {
+			val favouritesButton = addPackButton(FAVOURITES_PACK)
+			favouritesButton.load(getDrawable(R.drawable.star_filled_circle))
+			favouritesButton.setOnClickListener { switchPackLayout(FAVOURITES_PACK) }
+		}
 		// Packs
-		val sortedPackNames = if (this.insensitiveSort) {
-			this.loadedPacks.keys.sortedWith(String.CASE_INSENSITIVE_ORDER)
-		} else {
-			this.loadedPacks.keys.sorted()
-		}.toTypedArray()
+		val sortedPackNames = sortedPackNames().toTypedArray()
 
 		for (sortedPackName in sortedPackNames) {
 			val packButton = addPackButton(sortedPackName)
-			packButton.load(this.loadedPacks[sortedPackName]?.thumbSticker)
-			packButton.setOnClickListener { switchPackLayout(sortedPackName) }
+			val thumb = this.loadedPacks[sortedPackName]?.thumbSticker
+			packButton.load(thumb) {
+				// Always a still frame here regardless of the grid preference: an animated first
+				// sticker would otherwise run an AnimatedImageDrawable in a 40dp button for as long as
+				// the keyboard is open, and never be memory-cached.
+				if (thumb != null && thumb.extension.lowercase() in PLATFORM_DECODABLE) {
+					decoderFactory(BitmapFactoryDecoder.Factory())
+				}
+			}
+			packButton.setOnClickListener { selectPack(sortedPackName) }
 		}
 
+	}
+
+	/**
+	 * Delete a sticker for good: from the source folder it was imported from, from the imported copy,
+	 * and from everything generated off the back of it.
+	 *
+	 * Removing only the imported copy would be undone by the next import, which would copy it back
+	 * from a source that still has it, so the source document goes first and the rest follows only if
+	 * that succeeded.
+	 *
+	 * @param sticker File the imported sticker
+	 * @param onDone (Boolean) -> Unit called on the main thread with whether it went
+	 */
+	private fun deleteSticker(sticker: File, onDone: (Boolean) -> Unit) {
+		val pack = sticker.parentFile?.name
+		if (pack == null) {
+			onDone(false)
+			return
+		}
+		val treePath = this.sharedPreferences.getString("stickerDirPath", null)
+		CoroutineScope(Dispatchers.Main).launch {
+			val deleted = withContext(Dispatchers.IO) {
+				runCatching { removeEverywhere(sticker, pack, treePath) }
+					.getOrElse {
+						if (it is CancellationException) throw it
+						// An escape here would take the keyboard down mid-typing.
+						XLog.e("Failed to delete '${sticker.name}'")
+						XLog.e(it)
+						false
+					}
+			}
+			if (deleted) {
+				// The pack listing was snapshotted at load, so it still holds the deleted file.
+				loadPacks()
+				buildPackBar()
+				refreshContentAfterLibraryChange()
+			}
+			onDone(deleted)
+		}
+	}
+
+	/**
+	 * The actual removal, off the main thread. Returns false without touching the imported copy when
+	 * the source document is still there but could not be deleted, so the two never disagree.
+	 */
+	private fun removeEverywhere(sticker: File, pack: String, treePath: String?): Boolean {
+		if (treePath != null) {
+			val tree = Uri.parse(treePath)
+			// FAILED is not ABSENT: if the lookup could not be completed, deleting the imported copy
+			// would only hide a sticker the next import brings straight back.
+			if (SourceListing.removeDocument(baseContext, tree, pack, sticker.name) ==
+				SourceListing.Removal.FAILED
+			) {
+				return false
+			}
+			// tools/gif-variants.py writes its output as a sibling of the webp. Leaving that behind
+			// means the next import no longer sees a webp of the same name, so the orphan is imported
+			// as a sticker in its own right and the deleted sticker reappears as a GIF.
+			if (sticker.name.endsWith(".webp", ignoreCase = true)) {
+				SourceListing.removeDocument(
+					baseContext,
+					tree,
+					pack,
+					"${sticker.nameWithoutExtension}.gif",
+				)
+			}
+		} else {
+			XLog.w("No sticker directory is set, deleting the imported copy only")
+		}
+
+		// Everything derived from this sticker. Neither has another owner once it is gone, and the
+		// generated GIF in particular cannot be rebuilt from anything.
+		val variant = File(filesDir, "variants/$pack/${sticker.nameWithoutExtension}.gif")
+		val compat = File(internalDir, "__compatSticker__/${sticker.hashCode()}.png")
+		val derived = listOf(variant, compat).count { it.isFile && it.delete() }
+
+		favourites.remove(sticker)
+		recentCache.remove(sticker.absolutePath)
+		val removed = !sticker.exists() || sticker.delete()
+
+		// A pack that just lost its last sticker leaves an empty directory in all three trees.
+		val emptiedPack = File(internalDir, pack).listFiles()?.isEmpty() == true
+		if (emptiedPack) {
+			File(internalDir, pack).delete()
+			File(filesDir, "variants/$pack").takeIf { it.listFiles()?.isEmpty() == true }?.delete()
+			if (treePath != null) {
+				SourceListing.deletePackIfEmpty(baseContext, Uri.parse(treePath), pack, MAX_TREE_ENTRIES)
+			}
+		}
+
+		XLog.i(
+			"Deleted '$pack/${sticker.name}' (copy: $removed, derived files: $derived, " +
+				"pack emptied: $emptiedPack)",
+		)
+		return removed
+	}
+
+	/**
+	 * Redraw the sticker area after the library itself changed.
+	 *
+	 * jumpToPack deliberately reuses an all-packs list that is already built and merely scrolls it,
+	 * which is right when only the selection changed. It is wrong after a sticker is deleted: the
+	 * adapter still holds a cell for a file that has gone, which draws as a blank gap instead of the
+	 * grid closing up. Dropping the reference forces the list to be rebuilt from the reloaded packs.
+	 */
+	private fun refreshContentAfterLibraryChange() {
+		this.allPacksView = null
+		this.packHeaderPositions = emptyMap()
+		this.packHeadersByPosition = emptyList()
+		restoreActivePack()
+	}
+
+	/** Show whichever tab was last open, falling back to the first pack */
+	private fun restoreActivePack() {
+		val sortedPackNames = sortedPackNames().toTypedArray()
+		// The synthetic tabs have to be members here or the keyboard forgets them on every restart and
+		// silently falls back to the first pack.
+		val syntheticTabs = buildList {
+			add(RECENT_PACK)
+			if (favourites.hasAny(internalDir)) add(FAVOURITES_PACK)
+		}
 		val targetPack =
-			if (activePack in sortedPackNames + recentPackName) activePack else sortedPackNames.firstOrNull()
+			if (activePack in sortedPackNames + syntheticTabs) {
+				activePack
+			} else {
+				sortedPackNames.firstOrNull()
+			}
 
 		if (sortedPackNames.isNotEmpty()) {
-			targetPack?.let { switchPackLayout(it) }
+			if (targetPack in syntheticTabs) {
+				switchPackLayout(targetPack!!)
+			} else {
+				targetPack?.let { selectPack(it) }
+			}
 		}
 	}
 
@@ -537,6 +1119,81 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 		val packName = trimString(sticker.parent?.split('/')?.last())
 		fText.text = getString(R.string.sticker_pack_info, stickerName, packName)
 
+		val star = fullStickerLayout.findViewById<ImageButton>(R.id.favouriteButton)
+		fun paintStar() {
+			star.load(
+				getDrawable(
+					if (favourites.contains(sticker)) {
+						R.drawable.star_filled_circle
+					} else {
+						R.drawable.star_circle
+					},
+				),
+			)
+		}
+		paintStar()
+		star.setOnClickListener {
+			val tabWasShown = favourites.hasAny(internalDir)
+			val nowFavourite = favourites.toggle(sticker)
+			paintStar()
+			if (vibrate && SDK_INT >= Build.VERSION_CODES.O_MR1) {
+				it.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_PRESS)
+			}
+			toaster.toast(
+				getString(
+					if (nowFavourite) R.string.favourite_added else R.string.favourite_removed,
+				),
+			)
+			// The tab appears with the first star and goes with the last, so the bar needs rebuilding
+			// then -- but only then, and without renavigating, or starring would scroll the grid back
+			// to the top of the current pack under the preview the user is still looking at.
+			if (tabWasShown != favourites.hasAny(internalDir)) {
+				buildPackBar()
+				highlightPackButton(activePack)
+				// Unstarring the last favourite removes the tab the user may be standing on.
+				if (activePack == FAVOURITES_PACK && !favourites.hasAny(internalDir)) {
+					restoreActivePack()
+				}
+			} else if (activePack == FAVOURITES_PACK) {
+				// Still on the favourites tab, so its contents just changed under us.
+				switchPackLayout(FAVOURITES_PACK)
+			}
+		}
+
+		val deleteButton = fullStickerLayout.findViewById<ImageButton>(R.id.deleteButton)
+		deleteButton.load(getDrawable(R.drawable.delete_circle))
+		var armed = false
+		val disarm = Runnable {
+			armed = false
+			deleteButton.load(getDrawable(R.drawable.delete_circle))
+		}
+		deleteButton.setOnClickListener {
+			if (vibrate && SDK_INT >= Build.VERSION_CODES.O_MR1) {
+				it.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_PRESS)
+			}
+			if (!armed) {
+				// Deleting removes the file from the sticker folder, so it takes two deliberate taps.
+				armed = true
+				deleteButton.load(getDrawable(R.drawable.delete_confirm_circle))
+				toaster.toast(getString(R.string.delete_confirm))
+				deleteButton.postDelayed(disarm, DELETE_ARM_MS)
+				return@setOnClickListener
+			}
+			deleteButton.removeCallbacks(disarm)
+			deleteButton.isEnabled = false
+			deleteSticker(sticker) { deleted ->
+				toaster.toast(
+					getString(if (deleted) R.string.delete_done else R.string.delete_failed),
+				)
+				if (deleted) {
+					keyboardRoot.removeView(fullStickerLayout)
+				} else {
+					deleteButton.isEnabled = true
+					disarm.run()
+				}
+			}
+		}
+
 		// Tap to exit popup
 		fullStickerLayout.setOnClickListener { this.keyboardRoot.removeView(it) }
 		fSticker.setOnClickListener { this.keyboardRoot.removeView(fullStickerLayout) }
@@ -544,22 +1201,26 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 	}
 
 	internal fun switchToPreviousPack() {
-		// Get a list of sorted pack names
-		val sortedPackNames = loadedPacks.keys.sorted()
-		// Find the index of the current active pack
+		// sortedPackNames() rather than keys.sorted(), so swiping visits packs in the same order the
+		// pack bar shows them. With no packs at all the wrap-around below would index [-1].
+		val sortedPackNames = sortedPackNames()
+		if (sortedPackNames.isEmpty()) {
+			return
+		}
 		val currentIndex = sortedPackNames.indexOf(activePack)
-		// Calculate the index of the previous pack, considering wrap-around
 		val previousIndex = if (currentIndex > 0) currentIndex - 1 else sortedPackNames.size - 1
-		val previousPack = sortedPackNames[previousIndex]
-		switchPackLayout(previousPack)
+		selectPack(sortedPackNames[previousIndex])
 	}
 
 	internal fun switchToNextPack() {
-		val sortedPackNames = loadedPacks.keys.sorted()
+		// An empty library would make the modulo below a division by zero.
+		val sortedPackNames = sortedPackNames()
+		if (sortedPackNames.isEmpty()) {
+			return
+		}
 		val currentIndex = sortedPackNames.indexOf(activePack)
 		val nextIndex = (currentIndex + 1) % sortedPackNames.size
-		val nextPack = sortedPackNames[nextIndex]
-		switchPackLayout(nextPack)
+		selectPack(sortedPackNames[nextIndex])
 	}
 
 	private inner class GestureListener : GestureDetector.SimpleOnGestureListener() {
@@ -578,6 +1239,7 @@ class ImageKeyboard : InputMethodService(), StickerClickListener {
 
 			if (
 				scroll &&
+				!(continuousScroll && vertical) &&
 				abs(if (vertical) diffX else diffY) > SWIPE_THRESHOLD &&
 				abs(if (vertical) velocityX else velocityY) > SWIPE_VELOCITY_THRESHOLD
 			) {
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/MainActivity.kt b/app/src/main/java/com/fredhappyface/ewesticker/MainActivity.kt
index 132594e..dabaacb 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/MainActivity.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/MainActivity.kt
@@ -18,12 +18,18 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.lifecycle.lifecycleScope
 import androidx.preference.PreferenceManager
 import com.elvishew.xlog.XLog
+import com.fredhappyface.ewesticker.utilities.GifVariantGenerator
+import com.fredhappyface.ewesticker.utilities.LibraryScanner
 import com.fredhappyface.ewesticker.utilities.StickerImporter
 import com.fredhappyface.ewesticker.utilities.Toaster
 import com.fredhappyface.ewesticker.utilities.startLogger
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.progressindicator.LinearProgressIndicator
 import io.noties.markwon.Markwon
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
@@ -82,9 +88,12 @@ class MainActivity : AppCompatActivity() {
 			findViewById<SeekBar>(R.id.iconSizeSb).isEnabled = !isChecked
 		}
 		toggle(findViewById(R.id.restoreOnClose), "restoreOnClose", false) {}
+		toggle(findViewById(R.id.continuousScroll), "continuousScroll", true) {}
 		toggle(findViewById(R.id.scroll), "scroll", false) {}
 		toggle(findViewById(R.id.insensitive_sort), "insensitiveSort", false) {}
 		toggle(findViewById(R.id.pngFallback), "isPngFallback", true) {}
+		toggle(findViewById(R.id.animateGrid), "animateGrid", false) {}
+		toggle(findViewById(R.id.generateGifs), "generateGifVariants", false) {}
 
 		val versionText: TextView = findViewById(R.id.versionText)
 		var version = getString(R.string.version_text)
@@ -189,6 +198,246 @@ class MainActivity : AppCompatActivity() {
 	 *
 	 * @param ignoredView: View
 	 */
+	/**
+	 * The library operation currently running, if any. Importing, generating and deleting all walk
+	 * the same two trees, so exactly one of them may run at a time: a delete landing in the middle of
+	 * a generation wipes files it is still writing, and a second generation started from a re-enabled
+	 * button converts everything twice into the same place.
+	 */
+	private var libraryJob: Job? = null
+
+	/** The newest stats scan, so a slow earlier one cannot paint over a newer result */
+	private var scanJob: Job? = null
+
+	private val libraryBusy: Boolean
+		get() = libraryJob?.isActive == true
+
+	/** Every control that mutates or reports on the library, so busy state is applied in one place */
+	private fun libraryButtons(): List<Button> = listOfNotNull(
+		findViewById(R.id.updateStickerPackInfoBtn),
+		findViewById(R.id.reloadStickerPackInfoBtn),
+		findViewById(R.id.fullReimportBtn),
+		findViewById(R.id.generateVariantsBtn),
+		findViewById(R.id.deleteVariantsBtn),
+	)
+
+	/**
+	 * Run a library operation, with every button disabled for its duration and restored afterwards
+	 * whatever happens. Refuses to start a second one.
+	 *
+	 * @param progressBar LinearProgressIndicator? shown while the work runs
+	 * @param work suspend () -> Unit the operation itself
+	 */
+	private fun runLibraryOperation(
+		progressBar: LinearProgressIndicator?,
+		work: suspend () -> Unit,
+	) {
+		if (libraryBusy) {
+			XLog.i("A library operation is already running, ignoring this one")
+			return
+		}
+		libraryButtons().forEach { it.isEnabled = false }
+		progressBar?.visibility = View.VISIBLE
+		libraryJob = lifecycleScope.launch(Dispatchers.IO) {
+			try {
+				work()
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: Throwable) {
+				// Without this the exception reaches the uncaught handler and takes the app with it,
+				// leaving the buttons disabled and the progress bar spinning on the way out.
+				XLog.e("A library operation failed")
+				XLog.e(e)
+				withContext(Dispatchers.Main) { toaster.toast(getString(R.string.library_failed)) }
+			} finally {
+				withContext(NonCancellable + Dispatchers.Main) {
+					// Cleared first: a job is still active inside its own finally, so leaving this set
+					// would make the refresh below treat the library as busy and keep every button off.
+					libraryJob = null
+					progressBar?.visibility = View.GONE
+					refreshLibraryStats()
+				}
+			}
+		}
+	}
+
+	override fun onResume() {
+		super.onResume()
+		refreshLibraryStats()
+	}
+
+	/** Re-measure the library and redraw the Library card */
+	private fun refreshLibraryStats() {
+		val summary = findViewById<TextView>(R.id.librarySummary)
+		val animatedLine = findViewById<TextView>(R.id.libraryAnimated)
+		val coverage = findViewById<TextView>(R.id.libraryCoverage)
+		val generate = findViewById<Button>(R.id.generateVariantsBtn)
+		val delete = findViewById<Button>(R.id.deleteVariantsBtn)
+
+		// Every button, not just the two below: runLibraryOperation disables all of them, so this is
+		// the single place that puts them back.
+		val busy = libraryBusy
+		findViewById<Button>(R.id.updateStickerPackInfoBtn).isEnabled = !busy
+		findViewById<Button>(R.id.reloadStickerPackInfoBtn).isEnabled = !busy
+		findViewById<Button>(R.id.fullReimportBtn).isEnabled = !busy
+
+		// Cancel any scan still running: on a slow library an older one can finish after a newer one
+		// and repaint the card with counts that are already out of date.
+		scanJob?.cancel()
+		scanJob = lifecycleScope.launch(Dispatchers.IO) {
+			// Stats every sticker and sniffs each one's header, so not on the main thread.
+			val stats = try {
+				LibraryScanner.scan(filesDir)
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: Throwable) {
+				XLog.e("Could not read the library")
+				XLog.e(e)
+				null
+			}
+			withContext(Dispatchers.Main) {
+				if (stats == null) {
+					summary.text = getString(R.string.library_failed)
+					return@withContext
+				}
+				if (stats.isEmpty) {
+					summary.text = getString(R.string.library_empty)
+					animatedLine.text = ""
+					coverage.text = ""
+					generate.isEnabled = false
+					delete.isEnabled = false
+					return@withContext
+				}
+				summary.text = getString(
+					R.string.library_summary,
+					stats.stickers,
+					stats.packs,
+					LibraryScanner.formatBytes(stats.stickerBytes),
+				)
+				animatedLine.text = getString(
+					R.string.library_animated,
+					stats.animated,
+					stats.withVariant,
+					LibraryScanner.formatBytes(stats.variantBytes),
+				)
+				coverage.text = if (stats.missingVariants > 0) {
+					resources.getQuantityString(
+						R.plurals.library_missing,
+						stats.missingVariants,
+						stats.missingVariants,
+					)
+				} else if (stats.animated > 0) {
+					getString(R.string.library_all_covered)
+				} else {
+					""
+				}
+				// Enablement has to account for work in flight, not just what is on disk: coming back
+				// to this screen mid-generation would otherwise offer both buttons again.
+				generate.isEnabled = stats.missingVariants > 0 && !libraryBusy
+				delete.isEnabled = stats.variantBytes > 0 && !libraryBusy
+			}
+		}
+	}
+
+	/**
+	 * Generate GIF versions for animated stickers that do not have one.
+	 *
+	 * Reachable on its own rather than only as a side effect of importing, which used to mean
+	 * re-copying the whole library just to fill in a few missing GIFs.
+	 *
+	 * @param ignoredView: View
+	 */
+	fun generateVariants(ignoredView: View) {
+		val progressBar = findViewById<LinearProgressIndicator>(R.id.libraryProgressIndicator)
+		runLibraryOperation(progressBar) {
+			val result = GifVariantGenerator(baseContext, toaster, progressBar).generate(
+				File(filesDir, "stickers"),
+				File(filesDir, "variants"),
+			)
+			withContext(Dispatchers.Main) {
+				// Three outcomes, not two: a run where every conversion failed used to report that
+				// everything already had a GIF version, directly contradicting the card above it.
+				toaster.toast(
+					when {
+						result.pending == 0 -> getString(R.string.library_nothing_to_generate)
+						result.written == 0 -> getString(R.string.library_generate_failed)
+						result.written < result.pending -> getString(
+							R.string.library_generated_partial,
+							result.written,
+							result.pending,
+						)
+						else -> getString(R.string.library_generated, result.written)
+					},
+				)
+				bumpLibraryVersion()
+			}
+		}
+	}
+
+	/**
+	 * Delete every generated GIF version, after saying what that costs.
+	 *
+	 * @param ignoredView: View
+	 */
+	fun deleteVariants(ignoredView: View) {
+		if (libraryBusy) {
+			return
+		}
+		// Disabled straight away: raising the dialog is asynchronous, so two quick taps used to stack
+		// two of them, the second quoting space the first had already freed.
+		findViewById<Button>(R.id.deleteVariantsBtn).isEnabled = false
+		lifecycleScope.launch(Dispatchers.IO) {
+			val stats = LibraryScanner.scan(filesDir)
+			withContext(Dispatchers.Main) {
+				if (isFinishing || isDestroyed) {
+					return@withContext
+				}
+				MaterialAlertDialogBuilder(this@MainActivity)
+					.setTitle(R.string.library_delete_title)
+					.setMessage(
+						getString(
+							R.string.library_delete_message,
+							LibraryScanner.formatBytes(stats.variantBytes),
+						),
+					)
+					.setNegativeButton(android.R.string.cancel) { _, _ -> refreshLibraryStats() }
+					.setOnCancelListener { refreshLibraryStats() }
+					.setPositiveButton(R.string.library_delete_confirm) { _, _ ->
+						runLibraryOperation(null) {
+							val bytes = LibraryScanner.deleteVariants(filesDir)
+							withContext(Dispatchers.Main) {
+								toaster.toast(
+									getString(
+										R.string.library_deleted,
+										LibraryScanner.formatBytes(bytes),
+									),
+								)
+								bumpLibraryVersion()
+							}
+						}
+					}
+					.show()
+			}
+		}
+	}
+
+	/**
+	 * Rebuild the library from scratch, discarding what was imported before.
+	 *
+	 * The normal import only touches what changed, which is what makes adding a pack quick. This is
+	 * the way back when the imported copy is suspected of being wrong rather than merely stale.
+	 *
+	 * @param ignoredView: View
+	 */
+	fun fullReimport(ignoredView: View) {
+		val stickerDirPath = this.sharedPreferences.getString("stickerDirPath", null)
+		if (stickerDirPath != null) {
+			importStickers(stickerDirPath, fullRebuild = true)
+		} else {
+			this.toaster.toast(getString(R.string.imported_034))
+		}
+	}
+
 	fun reloadStickers(ignoredView: View) {
 		val stickerDirPath = this.sharedPreferences.getString(
 			"stickerDirPath",
@@ -204,17 +453,17 @@ class MainActivity : AppCompatActivity() {
 	}
 
 	/** Import files from storage to internal directory */
-	private fun importStickers(stickerDirPath: String) {
+	private fun importStickers(stickerDirPath: String, fullRebuild: Boolean = false) {
 		toaster.toast(getString(R.string.imported_010))
-		val button = findViewById<Button>(R.id.updateStickerPackInfoBtn)
-		val button2 = findViewById<Button>(R.id.reloadStickerPackInfoBtn)
 		val progressBar = findViewById<LinearProgressIndicator>(R.id.linearProgressIndicator)
-		button.isEnabled = false
-		button2.isEnabled = false
-
-		lifecycleScope.launch(Dispatchers.IO) {
+		runLibraryOperation(progressBar) {
 			val totalStickers =
-				StickerImporter(baseContext, toaster, progressBar).importStickers(stickerDirPath)
+				StickerImporter(
+					baseContext,
+					toaster,
+					progressBar,
+					backupSharedPreferences.getBoolean("generateGifVariants", false),
+				).importStickers(stickerDirPath, fullRebuild)
 
 			withContext(Dispatchers.Main) {
 				if (toaster.messages.size > 0) {
@@ -226,9 +475,8 @@ class MainActivity : AppCompatActivity() {
 				val editor = sharedPreferences.edit()
 				editor.putInt("numStickersImported", totalStickers)
 				editor.apply()
+				bumpLibraryVersion()
 				refreshStickerDirPath()
-				button.isEnabled = true
-				button2.isEnabled = true
 			}
 		}
 	}
@@ -283,7 +531,10 @@ class MainActivity : AppCompatActivity() {
 			this.backupSharedPreferences.getInt(sharedPrefKey, sharedPrefDefault) / multiplier
 		seekBar.setOnSeekBarChangeListener(
 			object : OnSeekBarChangeListener {
-				var progressMultiplier = sharedPrefDefault
+				// Seeded from what is stored, not the default: onProgressChanged only fires when the
+				// value actually moves, so a touch that does not move it used to save the default.
+				var progressMultiplier =
+					backupSharedPreferences.getInt(sharedPrefKey, sharedPrefDefault)
 				override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
 					progressMultiplier = progress * multiplier
 					seekBarLabel.text = progressMultiplier.toString()
@@ -316,8 +567,23 @@ class MainActivity : AppCompatActivity() {
 
 	/** Reusable function to warn about changing preferences */
 	private fun showChangedPrefText() {
+		bumpLibraryVersion()
 		this.toaster.toast(
 			getString(R.string.pref_000),
 		)
 	}
+
+	/**
+	 * Record that something the keyboard reads has changed. A running keyboard compares this against
+	 * the generation it applied and reloads on its next input field, so nothing here needs the user
+	 * to restart the keyboard by hand.
+	 */
+	private fun bumpLibraryVersion() {
+		val editor = this.backupSharedPreferences.edit()
+		editor.putInt(
+			"libraryVersion",
+			this.backupSharedPreferences.getInt("libraryVersion", 0) + 1,
+		)
+		editor.apply()
+	}
 }
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/adapter/AllPacksAdapter.kt b/app/src/main/java/com/fredhappyface/ewesticker/adapter/AllPacksAdapter.kt
new file mode 100644
index 0000000..fd9c4f5
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/adapter/AllPacksAdapter.kt
@@ -0,0 +1,76 @@
+package com.fredhappyface.ewesticker.adapter
+
+import android.view.GestureDetector
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.fredhappyface.ewesticker.R
+import com.fredhappyface.ewesticker.utilities.StickerClickListener
+import com.fredhappyface.ewesticker.view.PackHeaderViewHolder
+import com.fredhappyface.ewesticker.view.StickerPackViewHolder
+import java.io.File
+
+private const val TYPE_HEADER = 0
+private const val TYPE_STICKER = 1
+
+/**
+ * Every pack in one scrollable list, each preceded by a labelled divider.
+ *
+ * The alternative, one pack on screen at a time, means going back to the pack bar to see anything
+ * else. Putting the whole library in a single list lets a scroll carry on past the end of a pack,
+ * while the pack bar becomes a way to jump rather than the only way to move.
+ *
+ * @property iconSize Int side length to draw each sticker at
+ * @property items List<Item> headers and stickers, already in display order
+ */
+class AllPacksAdapter(
+	private val iconSize: Int,
+	private val items: List<Item>,
+	private val listener: StickerClickListener,
+	private val gestureDetector: GestureDetector,
+	private val vibrate: Boolean,
+	private val animate: Boolean,
+) : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
+
+	/** One row of the flattened library: either a pack label or one of its stickers */
+	sealed class Item {
+		class PackHeader(val packName: String) : Item()
+
+		class Sticker(val file: File) : Item()
+	}
+
+	override fun getItemViewType(position: Int): Int = when (items[position]) {
+		is Item.PackHeader -> TYPE_HEADER
+		is Item.Sticker -> TYPE_STICKER
+	}
+
+	override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
+		val inflater = LayoutInflater.from(parent.context)
+		return if (viewType == TYPE_HEADER) {
+			PackHeaderViewHolder(inflater.inflate(R.layout.pack_header, parent, false))
+		} else {
+			StickerPackViewHolder(inflater.inflate(R.layout.sticker_card, parent, false))
+		}
+	}
+
+	override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+		when (val item = items[position]) {
+			is Item.PackHeader -> {
+				holder as PackHeaderViewHolder
+				holder.packName.text = item.packName
+				// A rule above the very first pack would look like a stray line under the pack bar.
+				holder.divider.visibility = if (position == 0) View.GONE else View.VISIBLE
+			}
+
+			is Item.Sticker -> (holder as StickerPackViewHolder)
+				.bindSticker(item.file, iconSize, vibrate, listener, gestureDetector, animate)
+		}
+	}
+
+	override fun getItemCount(): Int = items.size
+
+	/** Is the row at this position a pack label, and so in need of the full row width? */
+	fun isHeader(position: Int): Boolean =
+		position in items.indices && items[position] is Item.PackHeader
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerBinding.kt b/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerBinding.kt
new file mode 100644
index 0000000..3a0a467
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerBinding.kt
@@ -0,0 +1,77 @@
+package com.fredhappyface.ewesticker.adapter
+
+import android.os.Build
+import android.view.GestureDetector
+import android.view.HapticFeedbackConstants
+import coil.decode.BitmapFactoryDecoder
+import coil.load
+import com.fredhappyface.ewesticker.utilities.StickerClickListener
+import com.fredhappyface.ewesticker.view.StickerPackViewHolder
+import java.io.File
+
+/**
+ * Bind a sticker to a thumbnail. Shared so that the single-pack grid and the all-packs list cannot
+ * drift apart in how a sticker responds to being tapped, held or swiped over.
+ *
+ * @param file File the sticker this cell shows
+ * @param iconSize Int side length to draw the thumbnail at
+ * @param vibrate Boolean give haptic feedback when tapped
+ * @param listener StickerClickListener target for taps and long presses
+ * @param gestureDetector GestureDetector consulted so swipes over a sticker still reach the keyboard
+ * @param animate Boolean play animated stickers in the grid rather than showing a still frame
+ */
+internal fun StickerPackViewHolder.bindSticker(
+	file: File,
+	iconSize: Int,
+	vibrate: Boolean,
+	listener: StickerClickListener,
+	gestureDetector: GestureDetector,
+	animate: Boolean,
+) {
+	stickerThumbnail.load(file) {
+		// Without an explicit size coil waits for a layout pass to work one out, and then sizes
+		// against the view rather than the cell we already know the dimensions of. Coerced because
+		// coil rejects a non-positive dimension by throwing, and the search strip can compute a
+		// negative cell size at some combinations of row count, icon size and font scale.
+		size(iconSize.coerceAtLeast(1))
+		if (!animate && usesPlatformDecoder(file)) {
+			// A distinct cache key: without one this still frame and the animated preview of the same
+			// file share an entry, and whichever lands first is served to the other.
+			memoryCacheKey("still:${file.absolutePath}")
+			// An animated result is an AnimatedImageDrawable, which coil never writes to its memory
+			// cache -- only BitmapDrawables go in -- so every rebind while scrolling decodes the
+			// whole container again. Decoding a single frame yields something cacheable.
+			decoderFactory(STILL_FRAME_DECODER)
+		}
+	}
+	stickerThumbnail.layoutParams.height = iconSize
+	stickerThumbnail.layoutParams.width = iconSize
+	stickerThumbnail.tag = file
+	stickerThumbnail.setOnClickListener {
+		val tapped = it.tag as File
+		if (vibrate && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+			it.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_PRESS)
+		}
+		listener.onStickerClicked(tapped)
+	}
+	stickerThumbnail.setOnLongClickListener {
+		listener.onStickerLongClicked(it.tag as File)
+		return@setOnLongClickListener true
+	}
+	stickerThumbnail.setOnTouchListener { _, event ->
+		return@setOnTouchListener gestureDetector.onTouchEvent(event)
+	}
+}
+
+/**
+ * Shared rather than built per bind: each instance carries its own semaphore, so allocating one per
+ * cell removes the process-wide cap on concurrent bitmap decodes that the single instance provides.
+ */
+private val STILL_FRAME_DECODER = BitmapFactoryDecoder.Factory()
+
+/**
+ * Can the platform's own bitmap decoder read this, or does it need one of the decoders registered on
+ * the loader? Forcing BitmapFactory on an svg or a video would leave the cell blank.
+ */
+private fun usesPlatformDecoder(file: File): Boolean =
+	file.extension.lowercase() in setOf("webp", "gif", "png", "jpg", "jpeg", "heif", "heic", "bmp")
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerPackAdapter.kt b/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerPackAdapter.kt
index c44b35c..e44f42e 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerPackAdapter.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/adapter/StickerPackAdapter.kt
@@ -1,12 +1,9 @@
 package com.fredhappyface.ewesticker.adapter
 
-import android.os.Build
 import android.view.GestureDetector
-import android.view.HapticFeedbackConstants
 import android.view.LayoutInflater
 import android.view.ViewGroup
 import androidx.recyclerview.widget.RecyclerView
-import coil.load
 import com.fredhappyface.ewesticker.R
 import com.fredhappyface.ewesticker.utilities.StickerClickListener
 import com.fredhappyface.ewesticker.view.StickerPackViewHolder
@@ -18,6 +15,7 @@ class StickerPackAdapter(
 	private val listener: StickerClickListener,
 	private val gestureDetector: GestureDetector,
 	private val vibrate: Boolean,
+	private val animate: Boolean,
 ) :
 
 	RecyclerView.Adapter<StickerPackViewHolder>() {
@@ -29,26 +27,7 @@ class StickerPackAdapter(
 	}
 
 	override fun onBindViewHolder(holder: StickerPackViewHolder, position: Int) {
-		val stickerFile = stickers[position]
-		holder.stickerThumbnail.load(stickerFile)
-		holder.stickerThumbnail.layoutParams.height = iconSize
-		holder.stickerThumbnail.layoutParams.width = iconSize
-		holder.stickerThumbnail.tag = stickerFile
-		holder.stickerThumbnail.setOnClickListener {
-			val file = it.tag as File
-			if (vibrate && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-				it.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_PRESS)
-			}
-			listener.onStickerClicked(file)
-		}
-		holder.stickerThumbnail.setOnLongClickListener {
-			val file = it.tag as File
-			listener.onStickerLongClicked(file)
-			return@setOnLongClickListener true
-		}
-		holder.stickerThumbnail.setOnTouchListener { _, event ->
-			return@setOnTouchListener gestureDetector.onTouchEvent(event)
-		}
+		holder.bindSticker(stickers[position], iconSize, vibrate, listener, gestureDetector, animate)
 	}
 
 	override fun getItemCount(): Int = stickers.size
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/Cache.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/Cache.kt
index 28da2e5..a24ff27 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/utilities/Cache.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/Cache.kt
@@ -19,13 +19,21 @@ class Cache(private val capacity: Int = 30) {
 	 * @return
 	 */
 	fun add(elem: String): String? {
+		var evicted: String? = null
 		if (data.contains(elem)) {
 			data.remove(elem)
 		} else if (data.size >= capacity) {
-			return data.pollFirst()
+			// Returning here used to skip the insert below, so a full cache dropped an old entry
+			// without keeping the new one and never got back to capacity.
+			evicted = data.pollFirst()
 		}
 		data.offerLast(elem)
-		return null
+		return evicted
+	}
+
+	/** Forget an element, used when the sticker it points at has been deleted */
+	fun remove(elem: String) {
+		data.remove(elem)
 	}
 
 	/**
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifEncoder.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifEncoder.kt
new file mode 100644
index 0000000..4114e40
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifEncoder.kt
@@ -0,0 +1,546 @@
+package com.fredhappyface.ewesticker.utilities
+
+import java.io.OutputStream
+
+/** Largest LZW code width the GIF format allows */
+private const val MAX_CODE_BITS = 12
+
+/** Number of LZW codes available before the dictionary has to be reset */
+private const val MAX_CODES = 1 shl MAX_CODE_BITS
+
+/** Deflated sub-blocks in a GIF data stream carry at most this many bytes */
+private const val MAX_BLOCK_SIZE = 255
+
+/** Alpha at or above this counts as opaque; GIF transparency is all-or-nothing */
+private const val ALPHA_THRESHOLD = 128
+
+/**
+ * Writes an animated GIF, one frame at a time.
+ *
+ * GIF is limited to 256 colours per frame, so every frame is reduced with median cut and then
+ * Floyd-Steinberg dithered against the palette it produced. That is deliberately the same pairing
+ * the reference implementation in tools/gif-variants.py gets from Pillow, so on-device output stays
+ * comparable to what a desktop conversion produces rather than visibly worse.
+ *
+ * Each frame carries its own local colour table, since a palette chosen for the whole animation
+ * would waste entries on colours only a few frames use.
+ *
+ * @property output OutputStream stream to write the GIF to; the caller retains ownership
+ * @property width Int canvas width in pixels
+ * @property height Int canvas height in pixels
+ * @property colors Int how many palette entries a frame may use, 2..256
+ */
+class GifEncoder(
+	private val output: OutputStream,
+	private val width: Int,
+	private val height: Int,
+	private val colors: Int,
+) {
+	private var started = false
+
+	/** Reused row error buffers for dithering, three channels interleaved per pixel */
+	private val currentError = IntArray(width * 3 + 6)
+	private val nextError = IntArray(width * 3 + 6)
+
+	/** Scratch space for the counting sort in sortByChannel, grown as boxes demand and reused */
+	private val bucketOffsets = IntArray(256)
+	private var colourScratch = IntArray(0)
+	private var countScratch = IntArray(0)
+
+	/**
+	 * Add a frame. Pixels are ARGB as returned by Bitmap.getPixels.
+	 *
+	 * @param argb IntArray width * height pixels
+	 * @param delayMs Int how long to show this frame
+	 */
+	fun addFrame(argb: IntArray, delayMs: Int) {
+		if (!started) {
+			writeHeader()
+			started = true
+		}
+
+		val hasTransparency = argb.any { (it ushr 24) < ALPHA_THRESHOLD }
+		val opaqueBudget = if (hasTransparency) colors - 1 else colors
+		val palette = buildPalette(argb, opaqueBudget.coerceAtLeast(1))
+		val transparentIndex = if (hasTransparency) palette.size else -1
+		val entries = palette.size + if (hasTransparency) 1 else 0
+		val tableBits = tableBitsFor(entries)
+
+		val indices = mapPixels(argb, palette, transparentIndex)
+
+		writeGraphicControl(delayMs, transparentIndex)
+		writeImageDescriptor(tableBits)
+		writeColorTable(palette, 1 shl tableBits)
+		writeImageData(indices, maxOf(tableBits, 2))
+	}
+
+	/** Close out the stream. Does not close the underlying OutputStream. */
+	fun finish() {
+		if (!started) {
+			writeHeader()
+			started = true
+		}
+		output.write(0x3B) // trailer
+	}
+
+	// ---- palette selection -------------------------------------------------------------------
+
+	/**
+	 * Reduce the opaque pixels of a frame to at most [target] colours using median cut: start with
+	 * every distinct colour in one box, then repeatedly split the box that spans the most colour
+	 * space, cutting at the median so both halves hold a similar number of pixels.
+	 */
+	private fun buildPalette(argb: IntArray, target: Int): IntArray {
+		val histogram = HashMap<Int, Int>()
+		for (pixel in argb) {
+			if ((pixel ushr 24) >= ALPHA_THRESHOLD) {
+				val rgb = pixel and 0xFFFFFF
+				histogram[rgb] = (histogram[rgb] ?: 0) + 1
+			}
+		}
+		if (histogram.isEmpty()) {
+			return intArrayOf(0)
+		}
+
+		val distinct = IntArray(histogram.size)
+		val counts = IntArray(histogram.size)
+		var at = 0
+		for ((rgb, count) in histogram) {
+			distinct[at] = rgb
+			counts[at] = count
+			at++
+		}
+		if (distinct.size <= target) {
+			return distinct
+		}
+
+		// Boxes are [start, end) ranges over distinct/counts, which get reordered as boxes split.
+		val boxes = ArrayList<IntArray>()
+		boxes.add(intArrayOf(0, distinct.size))
+		while (boxes.size < target) {
+			var chosen = -1
+			var bestScore = -1L
+			for (index in boxes.indices) {
+				val box = boxes[index]
+				if (box[1] - box[0] < 2) {
+					continue
+				}
+				val score = spread(distinct, counts, box[0], box[1])
+				if (score > bestScore) {
+					bestScore = score
+					chosen = index
+				}
+			}
+			if (chosen < 0) {
+				break
+			}
+			val box = boxes[chosen]
+			val channel = widestChannel(distinct, box[0], box[1])
+			sortByChannel(distinct, counts, box[0], box[1], channel)
+			val split = medianIndex(counts, box[0], box[1])
+			if (split <= box[0] || split >= box[1]) {
+				break
+			}
+			boxes[chosen] = intArrayOf(box[0], split)
+			boxes.add(intArrayOf(split, box[1]))
+		}
+
+		return IntArray(boxes.size) { average(distinct, counts, boxes[it][0], boxes[it][1]) }
+	}
+
+	/** How much colour space a box covers, weighted by how many pixels fall in it */
+	private fun spread(distinct: IntArray, counts: IntArray, from: Int, to: Int): Long {
+		var rMin = 255
+		var rMax = 0
+		var gMin = 255
+		var gMax = 0
+		var bMin = 255
+		var bMax = 0
+		var total = 0L
+		for (i in from until to) {
+			val rgb = distinct[i]
+			val r = (rgb shr 16) and 0xFF
+			val g = (rgb shr 8) and 0xFF
+			val b = rgb and 0xFF
+			if (r < rMin) rMin = r
+			if (r > rMax) rMax = r
+			if (g < gMin) gMin = g
+			if (g > gMax) gMax = g
+			if (b < bMin) bMin = b
+			if (b > bMax) bMax = b
+			total += counts[i]
+		}
+		val widest = maxOf(rMax - rMin, gMax - gMin, bMax - bMin)
+		return widest.toLong() * total
+	}
+
+	/** Which channel a box spans most widely: 0 red, 1 green, 2 blue */
+	private fun widestChannel(distinct: IntArray, from: Int, to: Int): Int {
+		var rMin = 255
+		var rMax = 0
+		var gMin = 255
+		var gMax = 0
+		var bMin = 255
+		var bMax = 0
+		for (i in from until to) {
+			val rgb = distinct[i]
+			val r = (rgb shr 16) and 0xFF
+			val g = (rgb shr 8) and 0xFF
+			val b = rgb and 0xFF
+			if (r < rMin) rMin = r
+			if (r > rMax) rMax = r
+			if (g < gMin) gMin = g
+			if (g > gMax) gMax = g
+			if (b < bMin) bMin = b
+			if (b > bMax) bMax = b
+		}
+		val rangeR = rMax - rMin
+		val rangeG = gMax - gMin
+		val rangeB = bMax - bMin
+		return when {
+			rangeR >= rangeG && rangeR >= rangeB -> 0
+			rangeG >= rangeB -> 1
+			else -> 2
+		}
+	}
+
+	/**
+	 * Order a box by one colour channel.
+	 *
+	 * The sort key is a single byte, so this counts occurrences of each of the 256 possible values
+	 * and scatters the entries into place, rather than comparing them. That matters because the very
+	 * first split covers every distinct colour in the frame -- several thousand of them for a
+	 * photographic sticker -- where a quadratic sort dominates the entire conversion.
+	 *
+	 * Scattering left to right within each bucket keeps entries that share a key in their original
+	 * order, exactly as the comparison sort this replaced did, so the box boundaries and the palette
+	 * that falls out of them are unchanged.
+	 */
+	private fun sortByChannel(
+		distinct: IntArray,
+		counts: IntArray,
+		from: Int,
+		to: Int,
+		channel: Int,
+	) {
+		val shift = 16 - channel * 8
+		val length = to - from
+		if (length < 2) {
+			return
+		}
+
+		val offsets = bucketOffsets
+		offsets.fill(0)
+		for (i in from until to) {
+			offsets[(distinct[i] shr shift) and 0xFF]++
+		}
+		var running = 0
+		for (bucket in offsets.indices) {
+			val size = offsets[bucket]
+			offsets[bucket] = running
+			running += size
+		}
+
+		val sortedColours = scratchColours(length)
+		val sortedCounts = scratchCounts(length)
+		for (i in from until to) {
+			val colour = distinct[i]
+			val slot = offsets[(colour shr shift) and 0xFF]++
+			sortedColours[slot] = colour
+			sortedCounts[slot] = counts[i]
+		}
+		sortedColours.copyInto(distinct, from, 0, length)
+		sortedCounts.copyInto(counts, from, 0, length)
+	}
+
+	private fun scratchColours(length: Int): IntArray {
+		if (colourScratch.size < length) {
+			colourScratch = IntArray(length)
+		}
+		return colourScratch
+	}
+
+	private fun scratchCounts(length: Int): IntArray {
+		if (countScratch.size < length) {
+			countScratch = IntArray(length)
+		}
+		return countScratch
+	}
+
+	/** Index that divides a box into two halves of roughly equal pixel population */
+	private fun medianIndex(counts: IntArray, from: Int, to: Int): Int {
+		var total = 0L
+		for (i in from until to) {
+			total += counts[i]
+		}
+		var running = 0L
+		for (i in from until to) {
+			running += counts[i]
+			if (running * 2 >= total) {
+				return (i + 1).coerceAtMost(to - 1)
+			}
+		}
+		return to - 1
+	}
+
+	private fun average(distinct: IntArray, counts: IntArray, from: Int, to: Int): Int {
+		var r = 0L
+		var g = 0L
+		var b = 0L
+		var total = 0L
+		for (i in from until to) {
+			val rgb = distinct[i]
+			val count = counts[i].toLong()
+			r += ((rgb shr 16) and 0xFF) * count
+			g += ((rgb shr 8) and 0xFF) * count
+			b += (rgb and 0xFF) * count
+			total += count
+		}
+		if (total == 0L) {
+			return 0
+		}
+		return (((r / total).toInt() and 0xFF) shl 16) or
+			(((g / total).toInt() and 0xFF) shl 8) or
+			((b / total).toInt() and 0xFF)
+	}
+
+	// ---- dithering ---------------------------------------------------------------------------
+
+	/**
+	 * Map every pixel to a palette index, diffusing the quantisation error of each pixel into its
+	 * neighbours so that gradients do not band. Transparent pixels take the transparent index and
+	 * contribute no error, since nothing was approximated there.
+	 */
+	private fun mapPixels(argb: IntArray, palette: IntArray, transparentIndex: Int): ByteArray {
+		val indices = ByteArray(width * height)
+		currentError.fill(0)
+
+		for (y in 0 until height) {
+			nextError.fill(0)
+			val rowStart = y * width
+			for (x in 0 until width) {
+				val pixel = argb[rowStart + x]
+				if (transparentIndex >= 0 && (pixel ushr 24) < ALPHA_THRESHOLD) {
+					indices[rowStart + x] = transparentIndex.toByte()
+					continue
+				}
+				val base = x * 3 + 3
+				val r = (((pixel shr 16) and 0xFF) + currentError[base]).coerceIn(0, 255)
+				val g = (((pixel shr 8) and 0xFF) + currentError[base + 1]).coerceIn(0, 255)
+				val b = ((pixel and 0xFF) + currentError[base + 2]).coerceIn(0, 255)
+
+				val index = nearest(palette, r, g, b)
+				indices[rowStart + x] = index.toByte()
+
+				val chosen = palette[index]
+				diffuse(x, r - ((chosen shr 16) and 0xFF), 0)
+				diffuse(x, g - ((chosen shr 8) and 0xFF), 1)
+				diffuse(x, b - (chosen and 0xFF), 2)
+			}
+			currentError.indices.forEach { currentError[it] = nextError[it] }
+		}
+		return indices
+	}
+
+	/** Spread one channel's error over the neighbours Floyd-Steinberg reaches */
+	private fun diffuse(x: Int, error: Int, channel: Int) {
+		if (error == 0) {
+			return
+		}
+		val base = x * 3 + 3 + channel
+		currentError[base + 3] += error * 7 / 16
+		nextError[base - 3] += error * 3 / 16
+		nextError[base] += error * 5 / 16
+		nextError[base + 3] += error / 16
+	}
+
+	/**
+	 * Closest palette entry to a colour, by squared distance.
+	 *
+	 * This is an exhaustive scan on purpose. Caching it against a 5-bits-per-channel key was around
+	 * four times faster but cost 1.3dB against the reference implementation, because rounding the
+	 * query colour throws away exactly the small differences dithering works in. Conversion happens
+	 * once per sticker on a spare core, so accuracy is the better trade.
+	 */
+	private fun nearest(palette: IntArray, r: Int, g: Int, b: Int): Int {
+		var best = 0
+		var bestDistance = Int.MAX_VALUE
+		for (i in palette.indices) {
+			val entry = palette[i]
+			val dr = r - ((entry shr 16) and 0xFF)
+			val dg = g - ((entry shr 8) and 0xFF)
+			val db = b - (entry and 0xFF)
+			val distance = dr * dr + dg * dg + db * db
+			if (distance < bestDistance) {
+				bestDistance = distance
+				best = i
+				if (distance == 0) {
+					break
+				}
+			}
+		}
+		return best
+	}
+
+	// ---- container ---------------------------------------------------------------------------
+
+	private fun writeHeader() {
+		output.write("GIF89a".toByteArray(Charsets.US_ASCII))
+		writeShort(width)
+		writeShort(height)
+		output.write(0x70) // no global colour table, 8 bits of colour resolution
+		output.write(0)
+		output.write(0)
+		// Netscape application extension, the only way to say "loop forever" in a GIF
+		output.write(0x21)
+		output.write(0xFF)
+		output.write(0x0B)
+		output.write("NETSCAPE2.0".toByteArray(Charsets.US_ASCII))
+		output.write(0x03)
+		output.write(0x01)
+		writeShort(0) // zero means loop indefinitely
+		output.write(0)
+	}
+
+	private fun writeGraphicControl(delayMs: Int, transparentIndex: Int) {
+		output.write(0x21)
+		output.write(0xF9)
+		output.write(0x04)
+		// Disposal 2 clears the frame back to the background before the next one is drawn, which is
+		// what keeps transparent areas from accumulating over the animation.
+		val transparencyFlag = if (transparentIndex >= 0) 1 else 0
+		output.write((2 shl 2) or transparencyFlag)
+		writeShort(centiseconds(delayMs))
+		output.write(if (transparentIndex >= 0) transparentIndex else 0)
+		output.write(0)
+	}
+
+	private fun writeImageDescriptor(tableBits: Int) {
+		output.write(0x2C)
+		writeShort(0)
+		writeShort(0)
+		writeShort(width)
+		writeShort(height)
+		output.write(0x80 or (tableBits - 1)) // local colour table of 2^tableBits entries
+	}
+
+	private fun writeColorTable(palette: IntArray, entries: Int) {
+		for (i in 0 until entries) {
+			val rgb = if (i < palette.size) palette[i] else 0
+			output.write((rgb shr 16) and 0xFF)
+			output.write((rgb shr 8) and 0xFF)
+			output.write(rgb and 0xFF)
+		}
+	}
+
+	// ---- LZW --------------------------------------------------------------------------------
+
+	private fun writeImageData(indices: ByteArray, minCodeSize: Int) {
+		output.write(minCodeSize)
+		val blocks = BlockWriter(output)
+		val clearCode = 1 shl minCodeSize
+		val endCode = clearCode + 1
+		var codeSize = minCodeSize + 1
+		var nextCode = endCode + 1
+		val dictionary = HashMap<Int, Int>()
+
+		blocks.write(clearCode, codeSize)
+		var prefix = indices[0].toInt() and 0xFF
+		for (i in 1 until indices.size) {
+			val pixel = indices[i].toInt() and 0xFF
+			val key = (prefix shl 8) or pixel
+			val known = dictionary[key]
+			if (known != null) {
+				prefix = known
+				continue
+			}
+			blocks.write(prefix, codeSize)
+			if (nextCode < MAX_CODES) {
+				dictionary[key] = nextCode
+				nextCode++
+				// A decoder only learns an entry on the code after the one that created it, so its
+				// dictionary trails this one by a single code. Widening when nextCode merely reaches
+				// the current ceiling would therefore start emitting wider codes a code before the
+				// decoder starts reading them, which desynchronises the whole stream.
+				if (nextCode > (1 shl codeSize) && codeSize < MAX_CODE_BITS) {
+					codeSize++
+				}
+			} else {
+				blocks.write(clearCode, codeSize)
+				dictionary.clear()
+				codeSize = minCodeSize + 1
+				nextCode = endCode + 1
+			}
+			prefix = pixel
+		}
+		blocks.write(prefix, codeSize)
+		blocks.write(endCode, codeSize)
+		blocks.finish()
+	}
+
+	private fun writeShort(value: Int) {
+		output.write(value and 0xFF)
+		output.write((value shr 8) and 0xFF)
+	}
+
+	private companion object {
+		/** Palette sizes must be a power of two, and GIF has no one-entry colour table */
+		fun tableBitsFor(entries: Int): Int {
+			var bits = 1
+			while ((1 shl bits) < entries && bits < 8) {
+				bits++
+			}
+			return bits
+		}
+
+		/**
+		 * GIF stores delays in hundredths of a second. Zero-delay frames are rendered as fast as a
+		 * viewer feels like, so round anything that would truncate to zero up to a single tick.
+		 */
+		fun centiseconds(delayMs: Int): Int = maxOf(1, (delayMs + 5) / 10)
+	}
+}
+
+/** Packs LZW codes into the length-prefixed sub-blocks a GIF image data stream is made of */
+private class BlockWriter(private val output: OutputStream) {
+	private val block = ByteArray(MAX_BLOCK_SIZE)
+	private var blockLength = 0
+	private var bitBuffer = 0
+	private var bitCount = 0
+
+	fun write(code: Int, codeSize: Int) {
+		bitBuffer = bitBuffer or (code shl bitCount)
+		bitCount += codeSize
+		while (bitCount >= 8) {
+			append(bitBuffer and 0xFF)
+			bitBuffer = bitBuffer ushr 8
+			bitCount -= 8
+		}
+	}
+
+	fun finish() {
+		if (bitCount > 0) {
+			append(bitBuffer and 0xFF)
+			bitBuffer = 0
+			bitCount = 0
+		}
+		flush()
+		output.write(0) // block terminator
+	}
+
+	private fun append(byte: Int) {
+		block[blockLength++] = byte.toByte()
+		if (blockLength == MAX_BLOCK_SIZE) {
+			flush()
+		}
+	}
+
+	private fun flush() {
+		if (blockLength == 0) {
+			return
+		}
+		output.write(blockLength)
+		output.write(block, 0, blockLength)
+		blockLength = 0
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifVariantGenerator.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifVariantGenerator.kt
new file mode 100644
index 0000000..05e8c5e
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/GifVariantGenerator.kt
@@ -0,0 +1,189 @@
+package com.fredhappyface.ewesticker.utilities
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import com.elvishew.xlog.XLog
+import com.fredhappyface.ewesticker.R
+import com.google.android.material.progressindicator.LinearProgressIndicator
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Longest edge of a generated GIF. Matching tools/gif-variants.py keeps on-device output the same
+ * size as a desktop conversion; at full 512 a typical animated sticker is over 4MB, which is too
+ * heavy to send in a chat.
+ */
+private const val MAX_EDGE = 320
+
+/** Palette entries per frame, again matching the reference implementation */
+private const val COLORS = 128
+
+/**
+ * Generates GIF copies of animated webp stickers, on device.
+ *
+ * WhatsApp takes an animated webp directly as a sticker, but apps like Teams advertise image/gif and
+ * nothing else, so a GIF is the only way an animated sticker keeps moving there. This produces those
+ * copies during import, into the variants tree that StickerSender looks in, so nothing has to be
+ * converted on a desktop first.
+ *
+ * Stickers that already have a variant are left alone, which means a GIF generated by
+ * tools/gif-variants.py and imported alongside its webp is used as-is rather than redone.
+ *
+ * @property progressBar LinearProgressIndicator? updated as stickers are converted
+ */
+class GifVariantGenerator(
+	private val context: Context,
+	private val toaster: Toaster,
+	private val progressBar: LinearProgressIndicator?,
+) {
+	private val mainHandler = Handler(Looper.getMainLooper())
+
+	/**
+	 * Convert every animated sticker that has no variant yet.
+	 *
+	 * @param stickersDir File the imported stickers tree
+	 * @param variantsDir File the tree to write GIFs into
+	 * @return Int how many GIFs were written
+	 */
+	/**
+	 * @property pending Int how many stickers needed a variant
+	 * @property written Int how many were produced; a shortfall means conversions failed
+	 */
+	data class Result(val pending: Int, val written: Int)
+
+	suspend fun generate(stickersDir: File, variantsDir: File): Result {
+		val pending = stickersDir.listFiles()
+			?.filter { it.isDirectory }
+			?.flatMap { pack ->
+				pack.listFiles()
+					?.filter { it.isFile && WebpAnimation.isAnimated(it) }
+					?.map { pack.name to it }
+					?: emptyList()
+			}
+			?.filterNot { (pack, sticker) ->
+				File(variantsDir, "$pack/${sticker.nameWithoutExtension}.gif").isFile
+			}
+			?: emptyList()
+
+		if (pending.isEmpty()) {
+			XLog.i("No animated stickers are missing a GIF variant")
+			return Result(0, 0)
+		}
+
+		XLog.i("Generating GIF variants for ${pending.size} animated sticker(s)...")
+		withContext(Dispatchers.Main) {
+			// Converting takes appreciably longer than the copy that precedes it, so say why the
+			// import has not finished yet rather than appearing to hang.
+			toaster.toast(context.getString(R.string.imported_035, pending.size))
+			progressBar?.isIndeterminate = false
+			progressBar?.progress = 0
+		}
+
+		val done = AtomicInteger()
+		val written = AtomicInteger()
+		// Dispatchers.Default is already sized to the number of cores, so this saturates the CPU
+		// without oversubscribing it. Conversion is pure computation, so that is what we want.
+		coroutineScope {
+			pending.map { (pack, sticker) ->
+				async(Dispatchers.Default) {
+					val destination = File(variantsDir, "$pack/${sticker.nameWithoutExtension}.gif")
+					if (convert(sticker, destination)) {
+						written.incrementAndGet()
+					}
+					val finished = done.incrementAndGet()
+					mainHandler.post {
+						progressBar?.progress = finished * 100 / pending.size
+					}
+				}
+			}.awaitAll()
+		}
+
+		XLog.i("Wrote ${written.get()} / ${pending.size} GIF variant(s)")
+		return Result(pending.size, written.get())
+	}
+
+	/**
+	 * Convert one animated webp to a GIF. Writes to a temporary file first so that a conversion
+	 * interrupted part way through cannot leave behind a truncated GIF that later runs would mistake
+	 * for finished work.
+	 *
+	 * @param source File the animated webp
+	 * @param destination File the GIF to write
+	 * @return Boolean true if a GIF was written
+	 */
+	internal fun convert(source: File, destination: File): Boolean {
+		val animation = WebpAnimation.read(source) ?: return false
+		val scale = minOf(1f, MAX_EDGE.toFloat() / maxOf(animation.width, animation.height))
+		val outWidth = maxOf(1, (animation.width * scale).toInt())
+		val outHeight = maxOf(1, (animation.height * scale).toInt())
+
+		val durations = animation.durationsMs
+		var complete = false
+		var partial: File? = null
+		try {
+			destination.parentFile?.mkdirs()
+			// A fixed ".part" name is not safe once conversions can also be started on demand from
+			// the keyboard: two of them for the same sticker would open the same path, and the second
+			// open truncates what the first has already written. Created inside the try because the
+			// parent directory can vanish under us -- an import or a delete running concurrently --
+			// and that must cost this sticker, not the whole batch.
+			// A fixed prefix, because createTempFile rejects one shorter than three characters.
+			partial = File.createTempFile("variant-", ".part", destination.parentFile)
+			partial.outputStream().buffered().use { stream ->
+				val encoder = GifEncoder(stream, outWidth, outHeight, COLORS)
+				val pixels = IntArray(animation.width * animation.height)
+				complete = animation.forEachFrame { index, bitmap ->
+					bitmap.getPixels(pixels, 0, animation.width, 0, 0, animation.width, animation.height)
+					val frame = if (scale < 1f) {
+						ImageResampler.resize(
+							pixels,
+							animation.width,
+							animation.height,
+							outWidth,
+							outHeight,
+						)
+					} else {
+						pixels
+					}
+					encoder.addFrame(frame, durations.getOrElse(index) { 100 })
+				}
+				encoder.finish()
+			}
+			if (!complete) {
+				XLog.e("Gave up converting '${source.name}', some frames would not decode")
+				return false
+			}
+			if (!partial.renameTo(destination)) {
+				XLog.e("Could not move the finished GIF into place for '${source.name}'")
+				return false
+			}
+			XLog.i(
+				"Converted '${source.name}' to ${animation.frameCount} GIF frames " +
+					"(${destination.length() / 1024}KB)",
+			)
+			return true
+		} catch (e: IOException) {
+			XLog.e("Failed to convert '${source.name}' to a GIF")
+			XLog.e(e)
+			return false
+		} catch (e: Throwable) {
+			// One malformed sticker should cost us that sticker, not the whole batch. A bad webp
+			// header can produce a negative array size or an oversized bitmap, neither of which is
+			// an IOException, and these run as children of a scope that cancels on an escape.
+			XLog.e("Failed to convert '${source.name}'")
+			XLog.e(e)
+			return false
+		} finally {
+			if (!complete) {
+				partial?.delete()
+			}
+		}
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImageResampler.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImageResampler.kt
new file mode 100644
index 0000000..c91dc79
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImageResampler.kt
@@ -0,0 +1,172 @@
+package com.fredhappyface.ewesticker.utilities
+
+import kotlin.math.PI
+import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.sin
+
+/** Lobe count of the Lanczos kernel; 3 is what Pillow's LANCZOS filter uses */
+private const val LOBES = 3
+
+/**
+ * Resizes ARGB pixel data with a Lanczos filter.
+ *
+ * Bitmap.createScaledBitmap only offers bilinear filtering, which samples too few source pixels to
+ * shrink an image cleanly and leaves the result softer and slightly aliased. Since the reference
+ * conversion in tools/gif-variants.py downscales with Lanczos, matching its output means matching its
+ * filter rather than settling for what the platform hands out.
+ */
+object ImageResampler {
+	/**
+	 * Resize to the given dimensions. Alpha is premultiplied for the duration so that colour from
+	 * transparent pixels cannot bleed into its neighbours.
+	 *
+	 * @param source IntArray ARGB pixels, sourceWidth * sourceHeight of them
+	 * @return IntArray ARGB pixels, targetWidth * targetHeight of them
+	 */
+	fun resize(
+		source: IntArray,
+		sourceWidth: Int,
+		sourceHeight: Int,
+		targetWidth: Int,
+		targetHeight: Int,
+	): IntArray {
+		if (sourceWidth == targetWidth && sourceHeight == targetHeight) {
+			return source.copyOf()
+		}
+
+		// Premultiplied planes, so each pass is a plain weighted sum.
+		val size = sourceWidth * sourceHeight
+		val a = FloatArray(size)
+		val r = FloatArray(size)
+		val g = FloatArray(size)
+		val b = FloatArray(size)
+		for (i in 0 until size) {
+			val pixel = source[i]
+			val alpha = (pixel ushr 24) / 255f
+			a[i] = alpha
+			r[i] = ((pixel shr 16) and 0xFF) * alpha
+			g[i] = ((pixel shr 8) and 0xFF) * alpha
+			b[i] = (pixel and 0xFF) * alpha
+		}
+
+		val horizontal = Weights.of(sourceWidth, targetWidth)
+		val ha = FloatArray(targetWidth * sourceHeight)
+		val hr = FloatArray(targetWidth * sourceHeight)
+		val hg = FloatArray(targetWidth * sourceHeight)
+		val hb = FloatArray(targetWidth * sourceHeight)
+		for (y in 0 until sourceHeight) {
+			val rowIn = y * sourceWidth
+			val rowOut = y * targetWidth
+			for (x in 0 until targetWidth) {
+				var sa = 0f
+				var sr = 0f
+				var sg = 0f
+				var sb = 0f
+				val from = horizontal.starts[x]
+				val taps = horizontal.weights[x]
+				for (t in taps.indices) {
+					val at = rowIn + from + t
+					val weight = taps[t]
+					sa += a[at] * weight
+					sr += r[at] * weight
+					sg += g[at] * weight
+					sb += b[at] * weight
+				}
+				ha[rowOut + x] = sa
+				hr[rowOut + x] = sr
+				hg[rowOut + x] = sg
+				hb[rowOut + x] = sb
+			}
+		}
+
+		val vertical = Weights.of(sourceHeight, targetHeight)
+		val out = IntArray(targetWidth * targetHeight)
+		for (y in 0 until targetHeight) {
+			val from = vertical.starts[y]
+			val taps = vertical.weights[y]
+			for (x in 0 until targetWidth) {
+				var sa = 0f
+				var sr = 0f
+				var sg = 0f
+				var sb = 0f
+				for (t in taps.indices) {
+					val at = (from + t) * targetWidth + x
+					val weight = taps[t]
+					sa += ha[at] * weight
+					sr += hr[at] * weight
+					sg += hg[at] * weight
+					sb += hb[at] * weight
+				}
+				val alpha = sa.coerceIn(0f, 1f)
+				out[y * targetWidth + x] = if (alpha <= 0f) {
+					0
+				} else {
+					// Undo the premultiply; a filter with negative lobes can overshoot, so clamp.
+					val red = (sr / alpha).coerceIn(0f, 255f)
+					val green = (sg / alpha).coerceIn(0f, 255f)
+					val blue = (sb / alpha).coerceIn(0f, 255f)
+					((alpha * 255f + 0.5f).toInt() shl 24) or
+						((red + 0.5f).toInt() shl 16) or
+						((green + 0.5f).toInt() shl 8) or
+						(blue + 0.5f).toInt()
+				}
+			}
+		}
+		return out
+	}
+
+	/** Per-output-pixel filter taps, clamped to the edges of the source */
+	private class Weights(val starts: IntArray, val weights: Array<FloatArray>) {
+		companion object {
+			fun of(sourceSize: Int, targetSize: Int): Weights {
+				val scale = sourceSize.toDouble() / targetSize
+				// Shrinking widens the kernel so that it still covers every contributing pixel;
+				// enlarging leaves it at its natural width.
+				val filterScale = max(1.0, scale)
+				val support = LOBES * filterScale
+
+				val starts = IntArray(targetSize)
+				val weights = Array(targetSize) { FloatArray(0) }
+				for (out in 0 until targetSize) {
+					val center = (out + 0.5) * scale
+					var from = floor(center - support).toInt()
+					var to = ceil(center + support).toInt()
+					if (from < 0) from = 0
+					if (to > sourceSize) to = sourceSize
+					if (from >= to) {
+						from = (center.toInt()).coerceIn(0, sourceSize - 1)
+						to = from + 1
+					}
+					val taps = FloatArray(to - from)
+					var total = 0.0
+					for (i in from until to) {
+						val value = lanczos((i + 0.5 - center) / filterScale)
+						taps[i - from] = value.toFloat()
+						total += value
+					}
+					if (total != 0.0) {
+						for (i in taps.indices) {
+							taps[i] = (taps[i] / total).toFloat()
+						}
+					}
+					starts[out] = from
+					weights[out] = taps
+				}
+				return Weights(starts, weights)
+			}
+
+			private fun lanczos(x: Double): Double {
+				if (x == 0.0) {
+					return 1.0
+				}
+				if (x <= -LOBES || x >= LOBES) {
+					return 0.0
+				}
+				val piX = PI * x
+				return LOBES * sin(piX) * sin(piX / LOBES) / (piX * piX)
+			}
+		}
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImportManifest.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImportManifest.kt
new file mode 100644
index 0000000..f04246f
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/ImportManifest.kt
@@ -0,0 +1,100 @@
+package com.fredhappyface.ewesticker.utilities
+
+import com.elvishew.xlog.XLog
+import java.io.File
+import java.io.IOException
+
+/** Separator between the three fields of a manifest line; a tab cannot appear in a document id */
+private const val FIELD_SEPARATOR = '\t'
+
+/**
+ * What the last import copied, so the next one can tell an unchanged file from a changed one.
+ *
+ * Without this the importer has nothing to compare against and has to re-copy the whole library
+ * every time, which is what made adding a single pack cost a full rebuild.
+ *
+ * @property entries Map<String, Entry> keyed by "pack/filename"
+ */
+class ImportManifest private constructor(
+	private val entries: MutableMap<String, Entry>,
+) {
+	data class Entry(val size: Long, val modified: Long)
+
+	/** Has this file been imported already, unchanged since? */
+	fun matches(file: SourceFile): Boolean {
+		// Some providers report nothing for size or last-modified. Treating the resulting 0 as a
+		// value would let every such file look unchanged forever, so treat it as unknown instead.
+		if (file.size <= 0L || file.modified <= 0L) {
+			return false
+		}
+		val entry = entries[file.key] ?: return false
+		return entry.size == file.size && entry.modified == file.modified
+	}
+
+	fun record(file: SourceFile) {
+		entries[file.key] = Entry(file.size, file.modified)
+	}
+
+	fun forget(key: String) {
+		entries.remove(key)
+	}
+
+	fun keys(): Set<String> = entries.keys.toSet()
+
+	/**
+	 * Persist. Written to a temporary file and renamed so that an import interrupted while saving
+	 * leaves the previous manifest intact rather than a truncated one, which would silently force a
+	 * full re-copy next time.
+	 */
+	fun save(file: File) {
+		try {
+			val temporary = File(file.parentFile, "${file.name}.tmp")
+			temporary.bufferedWriter().use { writer ->
+				for ((key, entry) in entries) {
+					writer.write(key)
+					writer.write(FIELD_SEPARATOR.code)
+					writer.write(entry.size.toString())
+					writer.write(FIELD_SEPARATOR.code)
+					writer.write(entry.modified.toString())
+					writer.newLine()
+				}
+			}
+			if (!temporary.renameTo(file)) {
+				XLog.e("Could not move the import manifest into place")
+				temporary.delete()
+			}
+		} catch (e: IOException) {
+			XLog.e("Could not save the import manifest")
+			XLog.e(e)
+		}
+	}
+
+	companion object {
+		/** Load, treating anything unreadable or malformed as "nothing imported yet" */
+		fun load(file: File): ImportManifest {
+			val entries = mutableMapOf<String, Entry>()
+			if (!file.isFile) {
+				return ImportManifest(entries)
+			}
+			try {
+				file.forEachLine { line ->
+					val parts = line.split(FIELD_SEPARATOR)
+					if (parts.size == 3) {
+						val size = parts[1].toLongOrNull()
+						val modified = parts[2].toLongOrNull()
+						if (size != null && modified != null) {
+							entries[parts[0]] = Entry(size, modified)
+						}
+					}
+				}
+			} catch (e: IOException) {
+				XLog.e("Could not read the import manifest, treating the library as unimported")
+				XLog.e(e)
+				entries.clear()
+			}
+			return ImportManifest(entries)
+		}
+
+		fun empty(): ImportManifest = ImportManifest(mutableMapOf())
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/LibraryScanner.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/LibraryScanner.kt
new file mode 100644
index 0000000..08521e9
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/LibraryScanner.kt
@@ -0,0 +1,108 @@
+package com.fredhappyface.ewesticker.utilities
+
+import java.io.File
+
+/**
+ * What the imported library actually contains.
+ *
+ * @property packs Int number of sticker packs
+ * @property stickers Int number of stickers across all packs
+ * @property animated Int how many of those stickers carry animation
+ * @property withVariant Int how many animated stickers have a GIF version ready to send
+ * @property stickerBytes Long disk used by the imported stickers
+ * @property variantBytes Long disk used by the generated GIF versions
+ */
+data class LibraryStats(
+	val packs: Int,
+	val stickers: Int,
+	val animated: Int,
+	val withVariant: Int,
+	val stickerBytes: Long,
+	val variantBytes: Long,
+) {
+	/** Animated stickers that would arrive as a still image in a GIF-only app right now */
+	val missingVariants: Int
+		get() = animated - withVariant
+
+	val isEmpty: Boolean
+		get() = stickers == 0
+}
+
+/**
+ * Measures the imported library.
+ *
+ * The settings screen previously reported a path, a date and one total for a library of several
+ * hundred stickers and about a hundred megabytes, which said nothing about how much of it would
+ * actually animate where the user sends it, or where the space had gone.
+ *
+ * Not cheap enough for the main thread: it stats every sticker and reads the first bytes of each to
+ * tell animated from still.
+ */
+object LibraryScanner {
+	fun scan(filesDir: File): LibraryStats {
+		val stickersDir = File(filesDir, "stickers")
+		val variantsDir = File(filesDir, "variants")
+
+		var packs = 0
+		var stickers = 0
+		var animated = 0
+		var withVariant = 0
+		var stickerBytes = 0L
+
+		stickersDir.listFiles()
+			?.filter { it.isDirectory && !it.name.contains("__compatSticker__") }
+			?.forEach { pack ->
+				val files = pack.listFiles()?.filter { it.isFile } ?: emptyList()
+				if (files.isEmpty()) {
+					return@forEach
+				}
+				packs++
+				for (sticker in files) {
+					stickers++
+					stickerBytes += sticker.length()
+					if (WebpAnimation.isAnimated(sticker)) {
+						animated++
+						if (File(variantsDir, "${pack.name}/${sticker.nameWithoutExtension}.gif").isFile) {
+							withVariant++
+						}
+					}
+				}
+			}
+
+		val variantBytes = variantsDir.walkTopDown()
+			.filter { it.isFile }
+			.sumOf { it.length() }
+
+		return LibraryStats(
+			packs = packs,
+			stickers = stickers,
+			animated = animated,
+			withVariant = withVariant,
+			stickerBytes = stickerBytes,
+			variantBytes = variantBytes,
+		)
+	}
+
+	/** Delete every generated GIF, returning how much space that reclaimed */
+	fun deleteVariants(filesDir: File): Long {
+		val variantsDir = File(filesDir, "variants")
+		val freed = variantsDir.walkTopDown().filter { it.isFile }.sumOf { it.length() }
+		variantsDir.deleteRecursively()
+		return freed
+	}
+
+	/** Bytes as something readable next to a sticker count */
+	fun formatBytes(bytes: Long): String {
+		// Thresholds sit just below each boundary so that a value which would round up to 1024 of a
+		// unit is promoted instead of being rendered as "1024 MB".
+		val kb = 1024.0
+		val mb = kb * 1024
+		val gb = mb * 1024
+		return when {
+			bytes >= gb * 0.9995 -> "%.1f GB".format(bytes / gb)
+			bytes >= mb * 0.995 -> "%.0f MB".format(bytes / mb)
+			bytes >= kb * 0.995 -> "%.0f KB".format(bytes / kb)
+			else -> "$bytes B"
+		}
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/SourceListing.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/SourceListing.kt
new file mode 100644
index 0000000..2e78455
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/SourceListing.kt
@@ -0,0 +1,374 @@
+package com.fredhappyface.ewesticker.utilities
+
+import android.content.Context
+import android.net.Uri
+import android.provider.DocumentsContract
+import com.elvishew.xlog.XLog
+
+/**
+ * One file in the user's sticker directory, with the metadata needed to tell an unchanged file from
+ * a changed one.
+ *
+ * @property pack String name of the directory the file sits in
+ * @property size Long size in bytes as reported by the provider
+ * @property modified Long last-modified time in milliseconds as reported by the provider
+ */
+data class SourceFile(
+	val pack: String,
+	val name: String,
+	val mimeType: String?,
+	val size: Long,
+	val modified: Long,
+	val uri: Uri,
+) {
+	/** Identifies this file across imports, and matches the layout of the imported tree */
+	val key: String
+		get() = "$pack/$name"
+
+	val baseName: String
+		get() = name.substringBeforeLast('.')
+}
+
+/**
+ * The outcome of walking a source tree.
+ *
+ * @property files List<SourceFile> everything found
+ * @property complete Boolean false if any directory could not be read, in which case the listing
+ * understates the source and must not be used to decide what to delete
+ */
+data class SourceTree(val files: List<SourceFile>, val complete: Boolean)
+
+/**
+ * Lists a SAF tree with one query per directory.
+ *
+ * DocumentFile caches nothing: listFiles() projects only the document id, and every subsequent
+ * name/type/isFile/length/lastModified read is its own ContentResolver round trip. Walking a library
+ * of a few hundred stickers that way costs thousands of Binder calls and still does not yield the
+ * size and modification time an incremental import has to compare against, which this does in the
+ * same pass.
+ */
+object SourceListing {
+	private val COLUMNS = arrayOf(
+		DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+		DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+		DocumentsContract.Document.COLUMN_MIME_TYPE,
+		DocumentsContract.Document.COLUMN_SIZE,
+		DocumentsContract.Document.COLUMN_LAST_MODIFIED,
+	)
+
+	/**
+	 * Walk every file under a tree uri, breadth first.
+	 *
+	 * @param context Context used for its ContentResolver
+	 * @param treeUri Uri the persisted tree the user granted
+	 * @param limit Int stop after this many files
+	 * @return SourceTree every file found, and whether the walk was complete
+	 */
+	fun list(context: Context, treeUri: Uri, limit: Int): SourceTree {
+		val resolver = context.contentResolver
+		val rootId = try {
+			DocumentsContract.getTreeDocumentId(treeUri)
+		} catch (e: IllegalArgumentException) {
+			XLog.e("'$treeUri' is not a tree uri")
+			XLog.e(e)
+			return SourceTree(emptyList(), complete = false)
+		}
+
+		val results = mutableListOf<SourceFile>()
+		var complete = true
+		// Files sitting directly in the chosen folder belong to a pack named after that folder,
+		// which is what the DocumentFile walk this replaces produced.
+		val queue = ArrayDeque<Pair<String, String>>()
+		queue.addLast(rootId to displayName(context, treeUri, rootId))
+
+		while (queue.isNotEmpty() && results.size < limit) {
+			val (documentId, pack) = queue.removeFirst()
+			val children = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, documentId)
+			try {
+				resolver.query(children, COLUMNS, null, null, null)?.use { cursor ->
+					while (cursor.moveToNext() && results.size < limit) {
+						val id = cursor.getString(0) ?: continue
+						val name = cursor.getString(1) ?: continue
+						// Hidden entries are never stickers. A '.nomedia' is how the sticker folder
+						// is kept out of the gallery, and without this it is rejected as an
+						// unsupported mimetype and toasts on every import; a hidden directory such
+						// as '.thumbnails' would import as a pack in its own right.
+						//
+						// Filtering here rather than in StickerImporter.plan also keeps these out
+						// of the MAX_FILES count, the manifest and pruning. It does not open a
+						// deletion path: deletePackIfEmpty corroborates with settledEmpty, which
+						// counts raw cursor rows, so a directory holding only a hidden file still
+						// reads as non-empty and is never removed.
+						if (name.startsWith(".")) continue
+						val mime = cursor.getString(2)
+						if (mime == DocumentsContract.Document.MIME_TYPE_DIR) {
+							queue.addLast(id to name)
+						} else {
+							results.add(
+								SourceFile(
+									pack = pack,
+									name = name,
+									mimeType = mime,
+									size = cursor.getLong(3),
+									modified = cursor.getLong(4),
+									uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, id),
+								),
+							)
+						}
+					}
+				}
+			} catch (e: Exception) {
+				// A provider can fail on an individual directory. Carrying on gives the user what we
+				// could read, but the caller has to know the listing is short: taken at face value it
+				// looks exactly like the user having deleted that whole pack.
+				XLog.e("Could not list '$documentId', the listing is incomplete")
+				XLog.e(e)
+				complete = false
+			}
+		}
+		return SourceTree(results, complete)
+	}
+
+	/**
+	 * Find one file in the source tree by pack and name.
+	 *
+	 * Used to delete a sticker at its origin: the keyboard only ever holds the imported copy, and
+	 * removing that alone would be undone by the next import, which would copy it straight back.
+	 *
+	 * @return Uri? the document, or null if the tree no longer has it
+	 */
+	/** What happened when asking the source folder to let go of a file */
+	enum class Removal { REMOVED, ABSENT, FAILED }
+
+	/**
+	 * Delete one file from the source tree.
+	 *
+	 * Returns FAILED rather than ABSENT when the lookup itself could not be completed, because the
+	 * caller must not read "I could not find out" as "it is already gone" and go on to delete the
+	 * imported copy -- that would leave the sticker in the source, absent from the app, and back again
+	 * at the next import.
+	 */
+	fun removeDocument(context: Context, treeUri: Uri, pack: String, name: String): Removal {
+		val document = try {
+			findDocument(context, treeUri, pack, name)
+		} catch (e: Exception) {
+			XLog.e("Could not look up '$pack/$name' in the source tree")
+			XLog.e(e)
+			return Removal.FAILED
+		} ?: return Removal.ABSENT
+
+		return try {
+			if (DocumentsContract.deleteDocument(context.contentResolver, document)) {
+				Removal.REMOVED
+			} else {
+				Removal.FAILED
+			}
+		} catch (e: Exception) {
+			XLog.e("The source folder would not let go of '$pack/$name'")
+			XLog.e(e)
+			Removal.FAILED
+		}
+	}
+
+	fun findDocument(context: Context, treeUri: Uri, pack: String, name: String): Uri? {
+		val rootId = try {
+			DocumentsContract.getTreeDocumentId(treeUri)
+		} catch (e: IllegalArgumentException) {
+			XLog.e("'$treeUri' is not a tree uri")
+			XLog.e(e)
+			return null
+		}
+		// Files sitting directly in the chosen folder are filed under that folder's own name.
+		val packId = if (pack == displayName(context, treeUri, rootId)) {
+			rootId
+		} else {
+			childId(context, treeUri, rootId, pack) ?: return null
+		}
+		val fileId = childId(context, treeUri, packId, name) ?: return null
+		return DocumentsContract.buildDocumentUriUsingTree(treeUri, fileId)
+	}
+
+	/**
+	 * Remove a pack directory from the source tree, but only on strong evidence that it is empty.
+	 *
+	 * This is the most dangerous call in the app: DocumentsContract.deleteDocument on a directory
+	 * removes everything beneath it, in the user's own storage, where the generated GIFs have no
+	 * counterpart to restore from. A single zero-row cursor is not evidence -- a provider may return
+	 * an empty cursor that is still loading, which is exactly why StickerImporter.prune refuses to act
+	 * on a listing it cannot corroborate.
+	 *
+	 * So four things must all hold: a complete walk of the tree, no file anywhere in it belonging to
+	 * this pack, exactly one directory of that name, and a settled empty listing for it.
+	 *
+	 * @return Boolean true if the directory was removed
+	 */
+	fun deletePackIfEmpty(context: Context, treeUri: Uri, pack: String, limit: Int): Boolean {
+		val tree = list(context, treeUri, limit)
+		if (!tree.complete) {
+			XLog.w("Not removing '$pack': the tree could not be read in full")
+			return false
+		}
+		if (tree.files.any { it.pack == pack }) {
+			return false
+		}
+
+		val candidates = directoriesNamed(context, treeUri, pack, limit)
+		if (candidates.size != 1) {
+			XLog.w("Not removing '$pack': found ${candidates.size} directories with that name")
+			return false
+		}
+		val packId = candidates.single()
+		if (packId == DocumentsContract.getTreeDocumentId(treeUri)) {
+			// The chosen folder itself, never ours to delete.
+			return false
+		}
+
+		if (!settledEmpty(context, treeUri, packId)) {
+			XLog.w("Not removing '$pack': its listing did not settle as empty")
+			return false
+		}
+
+		return try {
+			val removed = DocumentsContract.deleteDocument(
+				context.contentResolver,
+				DocumentsContract.buildDocumentUriUsingTree(treeUri, packId),
+			)
+			if (removed) {
+				XLog.i("Removed the now-empty pack directory '$pack'")
+			}
+			removed
+		} catch (e: Exception) {
+			XLog.e("Could not remove the empty pack directory '$pack'")
+			XLog.e(e)
+			false
+		}
+	}
+
+	/** Every directory in the tree with this display name, at any depth */
+	private fun directoriesNamed(
+		context: Context,
+		treeUri: Uri,
+		name: String,
+		limit: Int,
+	): List<String> {
+		val rootId = try {
+			DocumentsContract.getTreeDocumentId(treeUri)
+		} catch (e: IllegalArgumentException) {
+			return emptyList()
+		}
+		val found = mutableListOf<String>()
+		val queue = ArrayDeque<String>()
+		queue.addLast(rootId)
+		var visited = 0
+		while (queue.isNotEmpty() && visited < limit) {
+			val parent = queue.removeFirst()
+			visited++
+			val children = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, parent)
+			try {
+				context.contentResolver.query(
+					children,
+					arrayOf(
+						DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+						DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+						DocumentsContract.Document.COLUMN_MIME_TYPE,
+					),
+					null,
+					null,
+					null,
+				)?.use { cursor ->
+					while (cursor.moveToNext()) {
+						if (cursor.getString(2) != DocumentsContract.Document.MIME_TYPE_DIR) {
+							continue
+						}
+						val id = cursor.getString(0) ?: continue
+						if (cursor.getString(1) == name) {
+							found.add(id)
+						}
+						queue.addLast(id)
+					}
+				}
+			} catch (e: Exception) {
+				// A directory we cannot read might be the one we are about to delete, or might hide a
+				// second match; either way this is no longer safe.
+				XLog.e("Could not scan '$parent' while looking for '$name'")
+				XLog.e(e)
+				return emptyList()
+			}
+		}
+		return found
+	}
+
+	/**
+	 * Is this directory empty, asked twice, and never trusting a cursor that says it is still loading.
+	 */
+	private fun settledEmpty(context: Context, treeUri: Uri, documentId: String): Boolean {
+		val children = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, documentId)
+		repeat(2) {
+			val empty = try {
+                context.contentResolver.query(
+                    children,
+                    arrayOf(DocumentsContract.Document.COLUMN_DOCUMENT_ID),
+                    null,
+                    null,
+                    null,
+                )?.use { cursor ->
+					val loading =
+						cursor.extras?.getBoolean(DocumentsContract.EXTRA_LOADING, false) == true
+					!loading && cursor.count == 0
+				} ?: false
+			} catch (e: Exception) {
+				XLog.e("Could not check whether '$documentId' is empty")
+				XLog.e(e)
+				false
+			}
+			if (!empty) {
+				return false
+			}
+		}
+		return true
+	}
+
+	private fun childId(context: Context, treeUri: Uri, parentId: String, name: String): String? {
+		val children = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, parentId)
+		return try {
+			context.contentResolver.query(
+				children,
+				arrayOf(
+					DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+					DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+				),
+				null,
+				null,
+				null,
+			)?.use { cursor ->
+				while (cursor.moveToNext()) {
+					if (cursor.getString(1) == name) {
+						return@use cursor.getString(0)
+					}
+				}
+				null
+			}
+		} catch (e: Exception) {
+			XLog.e("Could not look up '$name' under '$parentId'")
+			XLog.e(e)
+			null
+		}
+	}
+
+	private fun displayName(context: Context, treeUri: Uri, documentId: String): String {
+		val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, documentId)
+		return try {
+			context.contentResolver.query(
+				uri,
+				arrayOf(DocumentsContract.Document.COLUMN_DISPLAY_NAME),
+				null,
+				null,
+				null,
+			)?.use { if (it.moveToFirst()) it.getString(0) else null } ?: "__default__"
+		} catch (e: Exception) {
+			XLog.e("Could not read the name of the root document")
+			XLog.e(e)
+			"__default__"
+		}
+	}
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerImporter.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerImporter.kt
index 3fa04cd..d2b7eb5 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerImporter.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerImporter.kt
@@ -5,180 +5,404 @@ import android.net.Uri
 import android.os.Handler
 import android.os.Looper
 import android.view.View
-import androidx.documentfile.provider.DocumentFile
 import com.elvishew.xlog.XLog
 import com.fredhappyface.ewesticker.R
-
 import com.google.android.material.progressindicator.LinearProgressIndicator
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.IOException
+import java.util.concurrent.atomic.AtomicInteger
 
 private const val MAX_FILES = 4096
 private const val MAX_PACK_SIZE = 128
 private const val BUFFER_SIZE = 64 * 1024 // 64 KB
+private const val MANIFEST_NAME = "import-manifest.tsv"
+
+/**
+ * How many files to copy at once. The previous code launched one coroutine per file, so a library of
+ * several hundred stickers fanned out across every thread Dispatchers.IO would give it, all
+ * contending on the same content provider.
+ */
+private const val COPY_PARALLELISM = 8
+
+/** A file that should end up in the imported tree, and where it goes */
+private class PlannedCopy(val source: SourceFile, val destination: File, val isVariant: Boolean)
 
 /**
- * The StickerImporter class includes a helper function to import stickers from a user-selected
- * stickerDirPath (see importStickers). The class requires the application baseContext and an
- * instance of Toaster (in turn requiring the application baseContext)
+ * Imports the user's sticker directory into app storage.
+ *
+ * The import is incremental: it compares each source file against a manifest of what was copied last
+ * time and only touches what actually changed, then removes anything that disappeared from the
+ * source. Nothing is deleted up front, so the keyboard keeps working throughout and adding one pack
+ * costs one pack's worth of work rather than a full rebuild of the library and every generated GIF.
  *
  * @property context: application baseContext
  * @property toaster: an instance of Toaster (used to store an error state for later reporting to the
  * user)
  * @property progressBar: LinearProgressIndicator that we update as we import stickers
+ * @property generateGifVariants: generate GIF copies of animated stickers after importing, for apps
+ * that accept image/gif but no webp mimetype
  */
 class StickerImporter(
 	private val context: Context,
 	private val toaster: Toaster,
 	private val progressBar: LinearProgressIndicator,
+	private val generateGifVariants: Boolean = false,
 ) {
 	private val supportedMimes = Utils.getSupportedMimes()
-	private val packSizes: MutableMap<String, Int> = mutableMapOf()
-	private var detectedStickers = 0
-	private var totalStickers = 0
-
 	private val mainHandler = Handler(Looper.getMainLooper())
 
-	private fun updateProgressBar(currentProgress: Int, totalStickers: Int) {
-		val progressPercentage = (currentProgress.toFloat() / totalStickers.toFloat()) * 100
-		progressBar.progress = progressPercentage.toInt()
-	}
+	private val stickersDir = File(context.filesDir, "stickers")
+	private val variantsDir = File(context.filesDir, "variants")
+	private val manifestFile = File(context.filesDir, MANIFEST_NAME)
 
 	/**
-	 * Used by the ACTION_OPEN_DOCUMENT_TREE handler function to copy stickers from a
-	 * stickerDirPath to the application internal storage for access later on by the
-	 * keyboard
+	 * Copy stickers from a user-selected directory into app storage.
 	 *
 	 * @param stickerDirPath a URI to the stickers directory to import into EweSticker
+	 * @param fullRebuild discard everything already imported and copy the library again from scratch
+	 * @return Int how many stickers the library now holds
 	 */
-	suspend fun importStickers(stickerDirPath: String): Int {
-		XLog.i("Removing old stickers...")
-		File(context.filesDir, "stickers").deleteRecursively()
+	suspend fun importStickers(stickerDirPath: String, fullRebuild: Boolean = false): Int {
 		withContext(Dispatchers.Main) {
 			progressBar.visibility = View.VISIBLE
 			progressBar.isIndeterminate = true
 		}
 
-		XLog.i("Walking $stickerDirPath...")
-		val leafNodes = fileWalk(DocumentFile.fromTreeUri(context, Uri.parse(stickerDirPath)))
-		if (leafNodes.size > MAX_FILES) {
+		XLog.i("Listing $stickerDirPath...")
+		val tree = withContext(Dispatchers.IO) {
+			SourceListing.list(context, Uri.parse(stickerDirPath), MAX_FILES + 1)
+		}
+		val source = tree.files
+		if (source.isEmpty()) {
+			XLog.w("Found no files in the sticker directory")
+			toaster.setMessage(context.getString(R.string.imported_034))
+			withContext(Dispatchers.Main) { progressBar.visibility = View.GONE }
+			return 0
+		}
+
+		// Deliberately after the listing. Wiping first and then discovering the source cannot be read
+		// -- an unmounted card, a grant that went stale -- would destroy the library and the
+		// device-generated GIFs, which no source can restore, in the one situation where the user
+		// reached for this button precisely because something already looked wrong.
+		if (fullRebuild) {
+			XLog.i("Full rebuild requested, discarding the imported library")
+			withContext(Dispatchers.IO) {
+				stickersDir.deleteRecursively()
+				variantsDir.deleteRecursively()
+				manifestFile.delete()
+			}
+		}
+
+		if (source.size > MAX_FILES) {
 			XLog.w("Found more than $MAX_FILES stickers, notify user")
 			toaster.setMessage(context.getString(R.string.imported_031, MAX_FILES))
 		}
 
+		val manifest = if (fullRebuild) ImportManifest.empty() else ImportManifest.load(manifestFile)
+		val planned = plan(source.take(MAX_FILES))
+		val stickerCount = planned.count { !it.isVariant }
+
+		// On the first import after this manifest was introduced -- or after one was lost -- there is
+		// no record of anything, so every file would look changed and be re-copied, and every
+		// generated GIF would then be discarded as stale despite nothing having actually changed.
+		// A destination already holding exactly as many bytes as the source is the file the previous
+		// import wrote, so adopt it rather than doing that work again.
+		if (!fullRebuild) {
+			var adopted = 0
+			for (copy in planned) {
+				if (!manifest.matches(copy.source) &&
+					copy.source.size > 0L &&
+					copy.destination.isFile &&
+					copy.destination.length() == copy.source.size
+				) {
+					manifest.record(copy.source)
+					adopted++
+				}
+			}
+			if (adopted > 0) {
+				XLog.i("Adopted $adopted already-imported file(s) into the manifest")
+			}
+		}
+
+		// Anything already present and unchanged is left alone. This is the whole point of the
+		// manifest: on a re-import that added one pack, only that pack is copied.
+		val outstanding = planned.filter { !isUpToDate(it, manifest) }
+		XLog.i("Importing ${outstanding.size} of ${planned.size} file(s); the rest are unchanged")
+
 		withContext(Dispatchers.Main) {
 			progressBar.isIndeterminate = false
+			progressBar.progress = 0
 		}
 
-		// Perform concurrent file copy operations
-		XLog.i("Perform concurrent file copy operations...")
-		withContext(Dispatchers.IO) {
-			leafNodes.take(MAX_FILES).mapIndexed { index, file ->
-				async {
-					importSticker(file)
-					mainHandler.post {
-						updateProgressBar(index + 1, leafNodes.size)
-					}
-				}
-			}.awaitAll()
+		// Stickers whose content actually changed. Their variants are stale; everything else's are
+		// not, regardless of what the copy did to file timestamps.
+		val changed = outstanding.filter { !it.isVariant }.map { it.source.key }.toSet()
+
+		val copied = try {
+			copyAll(outstanding, manifest)
+		} finally {
+			// Losing the manifest because the user walked away mid-import would force a full re-copy
+			// next time, which is the cost this whole change exists to remove.
+			withContext(NonCancellable + Dispatchers.IO) { manifest.save(manifestFile) }
+		}
+		val removed = withContext(Dispatchers.IO) {
+			prune(planned, changed, fullRebuild, tree.complete)
+		}
+		// Forget files the source no longer offers -- a sticker deleted from the keyboard, say --
+		// otherwise the manifest only ever grows.
+		if (tree.complete) {
+			val present = planned.map { it.source.key }.toSet()
+			manifest.keys().filterNot { it in present }.forEach { manifest.forget(it) }
+		}
+		withContext(NonCancellable + Dispatchers.IO) { manifest.save(manifestFile) }
+
+		if (generateGifVariants) {
+			GifVariantGenerator(context, toaster, progressBar).generate(stickersDir, variantsDir)
+		}
+		// Counted from disk rather than from the plan: most variants are generated on the device and
+		// so never appear in the plan at all, which made a normal import report zero of them.
+		val variants = withContext(Dispatchers.IO) {
+			variantsDir.walkTopDown().count { it.isFile }
 		}
 
 		withContext(Dispatchers.Main) {
 			progressBar.visibility = View.GONE
 		}
 
-		XLog.i("Copied $totalStickers / $detectedStickers")
-
-		return totalStickers
+		// What is actually there, rather than what was planned: copies can fail, and prune can decline
+		// to run, either of which would make a planned count disagree with what the keyboard loads.
+		val onDisk = withContext(Dispatchers.IO) {
+			planned.count { !it.isVariant && it.destination.isFile }
+		}
+		XLog.i(
+			"Library holds $onDisk of $stickerCount planned sticker(s) and $variants variant(s); " +
+				"copied $copied, removed $removed",
+		)
+		return onDisk
 	}
 
 	/**
-	 * Copies stickers from source to internal storage
-	 *
-	 * @param sticker sticker to copy over
-	 *
-	 * @return 1 if sticker imported successfully else 0
+	 * Decide what belongs in the imported tree and where, rejecting unsupported files and enforcing
+	 * the per-pack cap. Done in one pass up front so that the copy stage has no shared state to
+	 * mutate, which is what made the previous concurrent version's counts unreliable.
 	 */
-	private suspend fun importSticker(sticker: DocumentFile) {
-		val parentDir = sticker.parentFile?.name ?: "__default__"
-		val packSize = packSizes[parentDir] ?: 0
-		if (packSize > MAX_PACK_SIZE) {
-			XLog.w("Found more than $MAX_PACK_SIZE stickers in '$parentDir', notify user")
-			toaster.setMessage(context.getString(R.string.imported_032, MAX_PACK_SIZE, parentDir))
-			return
-		}
-		if (sticker.type !in supportedMimes) {
-			XLog.w("'$parentDir/${sticker.name}' is not a supported mimetype (${sticker.type}), notify user")
-			toaster.setMessage(
-				context.getString(
-					R.string.imported_033,
-					sticker.type,
-					parentDir,
-					sticker.name
+	private fun plan(source: List<SourceFile>): List<PlannedCopy> {
+		// A file that differs from a webp only by extension is an alternate encoding of that sticker
+		// rather than a sticker of its own -- see tools/gif-variants.py.
+		val webpKeys = source
+			.filter { it.name.endsWith(".webp", ignoreCase = true) }
+			.map { "${it.pack}/${it.baseName}" }
+			.toSet()
+
+		val planned = mutableListOf<PlannedCopy>()
+		val packCounts = mutableMapOf<String, Int>()
+		val overfullPacks = mutableSetOf<String>()
+
+		for (file in source) {
+			if (file.mimeType !in supportedMimes) {
+				XLog.w("'${file.key}' is not a supported mimetype (${file.mimeType}), notify user")
+				toaster.setMessage(
+					context.getString(R.string.imported_033, file.mimeType, file.pack, file.name),
 				)
-			)
-			return
+				continue
+			}
+
+			// Only formats the sender actually looks for count as variants; diverting anything else
+			// would hide it from the keyboard while nothing ever used it.
+			val isVariant = file.name.endsWith(".gif", ignoreCase = true) &&
+				"${file.pack}/${file.baseName}" in webpKeys
+
+			if (!isVariant) {
+				val count = packCounts.getOrDefault(file.pack, 0)
+				if (count >= MAX_PACK_SIZE) {
+					if (overfullPacks.add(file.pack)) {
+						XLog.w("Found more than $MAX_PACK_SIZE stickers in '${file.pack}'")
+						toaster.setMessage(
+							context.getString(R.string.imported_032, MAX_PACK_SIZE, file.pack),
+						)
+					}
+					continue
+				}
+				packCounts[file.pack] = count + 1
+			}
+
+			val tree = if (isVariant) variantsDir else stickersDir
+			planned.add(PlannedCopy(file, File(tree, file.key), isVariant))
 		}
-		packSizes[parentDir] = packSize + 1
+		return planned
+	}
 
-		val contentResolver = context.contentResolver
-		try {
-			val inputStream = contentResolver.openInputStream(sticker.uri)
-			if (inputStream != null) {
-				val destSticker = File(context.filesDir, "stickers/$parentDir/${sticker.name}")
-				destSticker.parentFile?.mkdirs()
+	/** Already copied, unchanged at the source, and still present at the destination */
+	private fun isUpToDate(copy: PlannedCopy, manifest: ImportManifest): Boolean =
+		manifest.matches(copy.source) &&
+			copy.destination.isFile &&
+			copy.destination.length() == copy.source.size
 
-				withContext(Dispatchers.IO) {
-					inputStream.buffered(BUFFER_SIZE).use { input ->
-						destSticker.outputStream().buffered(BUFFER_SIZE).use { output ->
-							input.copyTo(output)
+	private suspend fun copyAll(
+		outstanding: List<PlannedCopy>,
+		manifest: ImportManifest,
+	): Int {
+		if (outstanding.isEmpty()) {
+			return 0
+		}
+		val done = AtomicInteger()
+		val copied = AtomicInteger()
+		val gate = Semaphore(COPY_PARALLELISM)
+		coroutineScope {
+			outstanding.map { copy ->
+				async(Dispatchers.IO) {
+					gate.withPermit {
+						if (copyOne(copy)) {
+							copied.incrementAndGet()
+							synchronized(manifest) { manifest.record(copy.source) }
 						}
 					}
+					val finished = done.incrementAndGet()
+					val percent = finished * 100 / outstanding.size
+					mainHandler.post {
+						// Posts from concurrent copies can arrive out of order, which made the bar
+						// visibly jump backwards.
+						progressBar.progress = maxOf(progressBar.progress, percent)
+					}
 				}
-				withContext(Dispatchers.IO) {
-					inputStream.close()
+			}.awaitAll()
+		}
+		return copied.get()
+	}
+
+	private fun copyOne(copy: PlannedCopy): Boolean {
+		copy.destination.parentFile?.mkdirs()
+		// Into a temporary file and then renamed: writing the destination directly means a copy that
+		// fails half way leaves a truncated file where a perfectly good sticker used to be.
+		val partial = try {
+			File.createTempFile("import-", ".part", copy.destination.parentFile)
+		} catch (e: IOException) {
+			XLog.e("Could not create a temporary file for '${copy.source.key}'")
+			XLog.e(e)
+			return false
+		}
+		return try {
+			context.contentResolver.openInputStream(copy.source.uri)?.use { input ->
+				input.buffered(BUFFER_SIZE).use { buffered ->
+					partial.outputStream().buffered(BUFFER_SIZE).use { output ->
+						buffered.copyTo(output)
+					}
 				}
-				totalStickers++
+			} ?: run {
+				XLog.e("Could not open '${copy.source.key}'")
+				return false
 			}
-		} catch (e: IOException) {
-			XLog.e("There was an IOException when copying '${parentDir}/${sticker.name}'!")
+			if (!partial.renameTo(copy.destination)) {
+				XLog.e("Could not move '${copy.source.key}' into place")
+				return false
+			}
+			true
+		} catch (e: Throwable) {
+			// A failure here used to cancel the enclosing scope, taking every other in-flight copy
+			// with it and skipping both the prune and the manifest save.
+			if (e is CancellationException) {
+				throw e
+			}
+			XLog.e("Failed to copy '${copy.source.key}'")
 			XLog.e(e)
+			false
+		} finally {
+			partial.delete()
 		}
 	}
 
 	/**
-	 * Get a MutableSet of DocumentFiles from a root node
+	 * Remove what the source no longer has.
+	 *
+	 * Stickers are matched against the plan. Variants are judged differently, because a GIF generated
+	 * on the device has no counterpart in the source and must not be read as an orphan: one is dropped
+	 * only when its sticker is gone, or when that sticker's content actually changed and a generation
+	 * pass will follow to replace it.
 	 *
-	 * @param rootNode parent dir to get all files from
-	 * @return MutableSet<DocumentFile> set of files
+	 * Note there is deliberately no timestamp comparison here. Copying rewrites a destination and
+	 * moves its mtime forward, so "sticker newer than variant" is true for everything this run
+	 * touched -- which on a first import, where nothing has a manifest entry yet, means every single
+	 * variant.
+	 *
+	 * @param planned List<PlannedCopy> everything the source says should exist
+	 * @param changedStickers Set<String> keys of stickers whose content this run replaced
+	 * @param fullRebuild Boolean the user asked for a clean rebuild
+	 * @param listingComplete Boolean whether the source walk read every directory
+	 * @return Int how many files were removed
 	 */
-	private fun fileWalk(rootNode: DocumentFile?): Set<DocumentFile> {
-		val leafNodes = mutableSetOf<DocumentFile>()
-		val stack = ArrayDeque<DocumentFile?>()
+	private fun prune(
+		planned: List<PlannedCopy>,
+		changedStickers: Set<String>,
+		fullRebuild: Boolean,
+		listingComplete: Boolean,
+	): Int {
+		val wanted = planned.map { it.destination.absolutePath }.toSet()
 
-		rootNode?.let { stack.addLast(it) }
+		// A listing that could not read every directory understates the source, and is indistinguishable
+		// from the user having deleted those packs.
+		if (!listingComplete && !fullRebuild) {
+			XLog.w("The source listing was incomplete, so nothing will be removed")
+			toaster.setMessage(context.getString(R.string.imported_036))
+			return 0
+		}
 
-		while (stack.isNotEmpty() && leafNodes.size < MAX_FILES) {
-			val currentFile = stack.removeLast()
+		// Even a complete-looking listing can be wrong -- a stale grant, a provider returning an empty
+		// cursor. Refuse to act on one that would throw away most of what is imported.
+		val existing = stickersDir.walkTopDown()
+			.filter { it.isFile && !it.absolutePath.contains("__compatSticker__") }
+			.count()
+		val survivors = planned.count { !it.isVariant }
+		if (!fullRebuild && existing > 0 && survivors < existing / 2) {
+			XLog.w(
+				"Listing produced $survivors sticker(s) against $existing already imported; " +
+					"refusing to prune in case the source could not be read properly",
+			)
+			toaster.setMessage(context.getString(R.string.imported_036))
+			return 0
+		}
 
-			currentFile?.listFiles()?.forEach { file ->
-				if (file.isFile) {
-					leafNodes.add(file)
-					detectedStickers++
+		var removed = 0
+		stickersDir.walkBottomUp().forEach { file ->
+			if (file.isFile &&
+				file.absolutePath !in wanted &&
+				!file.absolutePath.contains("__compatSticker__")
+			) {
+				if (file.delete()) removed++
+			} else if (file.isDirectory && file != stickersDir && file.listFiles()?.isEmpty() == true) {
+				file.delete()
+			}
+		}
 
-					if (leafNodes.size > MAX_FILES + 1) {
-						XLog.w("Found more than ${MAX_FILES + 1} stickers, so returning early")
-						return leafNodes
-					}
-				} else if (file.isDirectory) {
-					stack.addLast(file)
+		variantsDir.walkBottomUp().forEach { file ->
+			if (file.isFile) {
+				// A variant the source supplied was just copied, so it is current by definition.
+				if (file.absolutePath in wanted) {
+					return@forEach
+				}
+				val pack = file.parentFile?.name ?: return@forEach
+				val stickerKey = "$pack/${file.nameWithoutExtension}.webp"
+				val sticker = File(stickersDir, stickerKey)
+				if (!sticker.isFile) {
+					// Orphan: whatever it was generated from is gone.
+					if (file.delete()) removed++
+				} else if (stickerKey in changedStickers && generateGifVariants) {
+					// Stale, and only worth discarding because a generation pass will replace it.
+					// Without that gate this would delete a usable GIF and leave nothing behind.
+					if (file.delete()) removed++
 				}
+			} else if (file.isDirectory && file != variantsDir && file.listFiles()?.isEmpty() == true) {
+				file.delete()
 			}
 		}
-		return leafNodes
+		return removed
 	}
 }
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerKeySet.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerKeySet.kt
new file mode 100644
index 0000000..0248bd2
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerKeySet.kt
@@ -0,0 +1,111 @@
+package com.fredhappyface.ewesticker.utilities
+
+import android.content.SharedPreferences
+import com.elvishew.xlog.XLog
+import java.io.File
+
+/**
+ * A named set of stickers, remembered across imports.
+ *
+ * Entries are "pack/filename" rather than absolute paths, because every import rewrites the imported
+ * tree; recents stores absolute paths and loses its contents whenever a sticker is re-copied to a
+ * different location.
+ *
+ * Used for the starred stickers and, separately, for the ones the user has deleted -- those are
+ * remembered so the importer can keep skipping them instead of copying them back in from a source
+ * folder that still has them.
+ *
+ * @property preferences SharedPreferences the backup preferences, shared with the settings screen
+ * @property preferenceKey String which set this instance reads and writes
+ */
+class StickerKeySet(
+	private val preferences: SharedPreferences,
+	private val preferenceKey: String,
+) {
+	/**
+	 * A snapshot of the stored keys.
+	 *
+	 * getStringSet hands back an instance the framework may reuse, and mutating it corrupts the
+	 * in-memory preferences, so this always copies.
+	 */
+	private fun stored(): MutableSet<String> =
+		preferences.getStringSet(preferenceKey, emptySet())?.toMutableSet() ?: mutableSetOf()
+
+	/** "pack/filename" for a sticker in the imported tree */
+	fun keyOf(sticker: File): String? {
+		val pack = sticker.parentFile?.name ?: return null
+		return "$pack/${sticker.name}"
+	}
+
+	fun contains(sticker: File): Boolean {
+		val key = keyOf(sticker) ?: return false
+		return key in stored()
+	}
+
+	/**
+	 * Star or unstar a sticker.
+	 *
+	 * @param sticker File the sticker to toggle
+	 * @return Boolean true if it is now a favourite
+	 */
+	fun toggle(sticker: File): Boolean {
+		val key = keyOf(sticker) ?: return false
+		val current = stored()
+		val nowPresent = if (key in current) {
+			current.remove(key)
+			false
+		} else {
+			current.add(key)
+			true
+		}
+		preferences.edit().putStringSet(preferenceKey, current).apply()
+		XLog.i("${if (nowPresent) "Added" else "Removed"} '$key' ${if (nowPresent) "to" else "from"} $preferenceKey")
+		return nowPresent
+	}
+
+	/**
+	 * The starred stickers that still exist, in a stable order.
+	 *
+	 * Anything the source dropped is skipped rather than rendered as a blank cell that commits a uri
+	 * to a file which is not there -- which reports success and delivers nothing.
+	 *
+	 * @param stickersDir File the imported stickers tree
+	 * @return Array<File> existing favourites
+	 */
+	fun resolve(stickersDir: File): Array<File> {
+		val current = stored()
+		val alive = LinkedHashMap<String, File>()
+		for (key in current.sorted()) {
+			val file = File(stickersDir, key)
+			if (file.isFile) {
+				alive[key] = file
+			}
+		}
+		// Dead keys are dropped as they are found. Without this a tab whose visibility is decided by
+		// the raw set but whose contents are filtered by existence stays visible over an empty grid,
+		// and the only way to unstar something is to long-press a sticker that no longer exists.
+		if (alive.size != current.size) {
+			XLog.i("Dropping ${current.size - alive.size} missing entr(ies) from $preferenceKey")
+			preferences.edit().putStringSet(preferenceKey, alive.keys.toMutableSet()).apply()
+		}
+		return alive.values.toTypedArray()
+	}
+
+	/**
+	 * Does anything in this set still exist? Answered through resolve so that a tab's visibility and
+	 * its contents can never disagree.
+	 */
+	fun hasAny(stickersDir: File): Boolean = resolve(stickersDir).isNotEmpty()
+
+	/** Forget a sticker, used when deleting one that was also starred */
+	fun remove(sticker: File) {
+		val key = keyOf(sticker) ?: return
+		val current = stored()
+		if (current.remove(key)) {
+			preferences.edit().putStringSet(preferenceKey, current).apply()
+		}
+	}
+
+	/** Is the set empty? Used to decide whether a tab is worth showing. */
+	fun isEmpty(): Boolean = stored().isEmpty()
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerSender.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerSender.kt
index 37d4f57..11b54a0 100644
--- a/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerSender.kt
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/StickerSender.kt
@@ -12,14 +12,22 @@ import androidx.core.view.inputmethod.InputConnectionCompat
 import androidx.core.view.inputmethod.InputContentInfoCompat
 import coil.ImageLoader
 import coil.request.ImageRequest
+import coil.request.SuccessResult
+import coil.size.Size
 import com.elvishew.xlog.XLog
 import com.fredhappyface.ewesticker.R
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * The StickerSender Class used to contain all of the methods used for sending a sticker to an
@@ -37,6 +45,8 @@ import java.io.IOException
  * @property imageLoader: coil imageLoader object used to convert a sticker file to a drawable ready
  * for writing to a compat sticker
  * @property isPngFallback: is a png fallback enabled
+ * @property generateGifVariants: convert an animated sticker to a GIF at send time when the target
+ * takes image/gif and no variant exists yet
  */
 class StickerSender(
 	private val context: Context,
@@ -47,11 +57,25 @@ class StickerSender(
 	private val compatCache: Cache,
 	private val imageLoader: ImageLoader,
 	private val isPngFallback: Boolean,
+	private val generateGifVariants: Boolean = false,
 ) {
 
 	private val supportedMimes = this.currentInputEditorInfo?.contentMimeTypes ?: emptyArray()
 	private val packageName = this.currentInputEditorInfo?.packageName
 
+	/**
+	 * Set once this sender no longer owns the input field. An on-demand conversion can outlive the
+	 * field it started in, and committing or opening a share sheet after that puts a chooser on top
+	 * of whatever the user moved on to.
+	 */
+	@Volatile
+	private var abandoned = false
+
+	/** Stop acting on a field this sender no longer owns. */
+	fun abandon() {
+		abandoned = true
+	}
+
 	init {
 		XLog.i("Connecting to $packageName which supports [${supportedMimes.joinToString(", ")}]")
 	}
@@ -78,24 +102,47 @@ class StickerSender(
 		val compatStickerName = file.hashCode().toString()
 		val compatSticker = File(internalDir, "__compatSticker__/$compatStickerName.png")
 
-		if (!compatSticker.exists()) {
+		// A zero-length file satisfies exists() forever, so a write that failed once would never be
+		// retried. Length is the honest test of "do we already have this".
+		if (compatSticker.length() == 0L) {
 			XLog.i("Create a fallback png sticker '__compatSticker__/$compatStickerName.png'")
 
 			compatSticker.parentFile?.mkdirs()
-			try {
-				val request = ImageRequest.Builder(context)
-					.data(file)
-					.target { result ->
-						val bitmap = result.toBitmap()
-						bitmap.compress(
-							Bitmap.CompressFormat.PNG,
-							90,
-							FileOutputStream(compatSticker),
-						)
+			val request = ImageRequest.Builder(context)
+				.data(file)
+				// Without an explicit size, coil resolves one from the display rather than the
+				// source, so the fallback came out rescaled and soft. A stand-in for a sticker
+				// should be exactly the resolution of the sticker it replaces.
+				.size(Size.ORIGINAL)
+				.build()
+
+			// execute() reports a decode failure by returning an ErrorResult rather than throwing.
+			// Running the encode in a target callback hid that: no file was written, yet this
+			// returned a path anyway, and commitContent then reported success for a sticker that
+			// never arrived.
+			val drawable = (imageLoader.execute(request) as? SuccessResult)?.drawable
+			if (drawable == null) {
+				XLog.e("Could not decode '${file.name}' for a png fallback")
+				showToast(context.getString(R.string.fallback_041))
+				return null
+			}
+
+			// Encoding a full-resolution png and writing it are both slow enough to be felt when
+			// they happen on the thread that draws the keyboard, which is where the target callback
+			// used to put them.
+			val written = withContext(Dispatchers.IO) {
+				try {
+					FileOutputStream(compatSticker).use { stream ->
+						drawable.toBitmap().compress(Bitmap.CompressFormat.PNG, 100, stream)
 					}
-					.build()
-				imageLoader.execute(request)
-			} catch (ignore: IOException) {
+				} catch (e: IOException) {
+					XLog.e("Could not write the png fallback for '${file.name}'")
+					XLog.e(e)
+					false
+				}
+			}
+			if (!written || compatSticker.length() == 0L) {
+				compatSticker.delete()
 				showToast(context.getString(R.string.fallback_041))
 				return null
 			}
@@ -108,6 +155,64 @@ class StickerSender(
 		return compatSticker
 	}
 
+	/**
+	 * Pick the file and mimetype to actually commit for a sticker, given what the target app says
+	 * it accepts. An exact mimetype match always wins. Failing that, for webp:
+	 *
+	 * 1. Prefer any vendor-specific image/webp.* mimetype the target advertises. WhatsApp never
+	 *    advertises plain image/webp; it exposes image/webp.wasticker, and only content committed
+	 *    under that mimetype is treated as a sticker rather than flattened into a photo -- which is
+	 *    also what preserves animation.
+	 * 2. Otherwise, if the target takes image/gif, send a GIF variant of the sticker if one was
+	 *    generated (see tools/gif-variants.py). Apps like Instagram and Teams advertise no webp
+	 *    mimetype at all, so a GIF is the only way to keep an animated sticker moving there.
+	 *
+	 * @param file File the sticker to send
+	 * @param stickerType String the mimetype derived from the file extension
+	 * @return Pair<File, String> the file to commit and the mimetype to commit it under
+	 */
+	private fun resolveCommit(file: File, stickerType: String): Pair<File, String> {
+		// A wildcard counts as accepting the original. Without this an app advertising both image/*
+		// and image/gif would be handed the downscaled, 128-colour GIF variant even though it would
+		// have taken the full-quality webp.
+		if (stickerType in supportedMimes ||
+			("image/*" in supportedMimes && stickerType.startsWith("image/")) ||
+			("video/*" in supportedMimes && stickerType.startsWith("video/"))
+		) {
+			return file to stickerType
+		}
+		if (stickerType == "image/webp") {
+			supportedMimes.firstOrNull { it.startsWith("image/webp.") }?.let {
+				XLog.i("Committing ${file.name} as '$it' for $packageName")
+				return file to it
+			}
+			if ("image/gif" in supportedMimes) {
+				formatVariant(file, "gif")?.let {
+					XLog.i("Committing ${file.name} as its GIF variant for $packageName")
+					return it to "image/gif"
+				}
+			}
+		}
+		return file to stickerType
+	}
+
+	/**
+	 * Look for an alternate encoding of a sticker, imported alongside it into a parallel tree so
+	 * that it never shows up as a duplicate in the keyboard grid.
+	 *
+	 * @param file File the sticker to find a variant of
+	 * @param extension String the extension of the wanted variant
+	 * @return File? the variant, or null if it was never generated
+	 */
+	private fun formatVariant(file: File, extension: String): File? {
+		val pack = file.parentFile?.name ?: return null
+		// Note internalDir is the stickers tree itself, whereas the importer keeps variants in a
+		// sibling of it so that they are never enumerated as packs.
+		val variant =
+			File(context.filesDir, "variants/$pack/${file.nameWithoutExtension}.$extension")
+		return variant.takeIf { it.isFile }
+	}
+
 	/**
 	 * Main method to send a sticker to an InputConnectionCompat, this attempts to send via the happy path (assuming the
 	 * InputConnectionCompat supports the stickers mime type. Otherwise attempts falling back to png, and then finally if that fails,
@@ -115,15 +220,16 @@ class StickerSender(
 	 */
 	fun sendSticker(file: File) {
 		val stickerType = Utils.getMimeType(file) ?: "__unknown__"
+		val (commitFile, commitType) = resolveCommit(file, stickerType)
 
 		// Try and only send as is if the app explicitly supports it
 		// Note: Many apps do not support svg, so send as png regardless!
-		if ((stickerType in supportedMimes
+		if ((commitType in supportedMimes
 				|| "image/*" in supportedMimes && stickerType.startsWith("image/")
 				|| "video/*" in supportedMimes && stickerType.startsWith("video/"))
 			&& stickerType != "image/svg+xml"
 		) {
-			if (!doCommitContent(stickerType, file)) {
+			if (!doCommitContent(commitType, commitFile)) {
 				CoroutineScope(Dispatchers.Main).launch {
 					doFallbackCommitContent(stickerType, file)
 				}
@@ -145,12 +251,21 @@ class StickerSender(
 	 */
 	private fun doCommitContent(mimeType: String, file: File): Boolean {
 		XLog.i("Sending ${file.name} ($mimeType) to ${this.packageName}")
-		val inputContentInfoCompat = InputContentInfoCompat(
+		// getUriForFile throws if the file sits outside every root in file_paths.xml. Reporting
+		// failure lets the caller fall back, which beats taking the whole keyboard down mid-send.
+		val uri = try {
 			FileProvider.getUriForFile(
 				context,
 				"com.fredhappyface.ewesticker.inputcontent",
 				file,
-			),
+			)
+		} catch (e: IllegalArgumentException) {
+			XLog.e("Cannot serve '${file.path}' over the file provider")
+			XLog.e(e)
+			return false
+		}
+		val inputContentInfoCompat = InputContentInfoCompat(
+			uri,
 			ClipDescription(file.name, arrayOf(mimeType)),
 			null,
 		)
@@ -177,11 +292,37 @@ class StickerSender(
 	 */
 	private suspend fun doFallbackCommitContent(mimeType: String, file: File) {
 
+		// Before settling for a still image, try producing the GIF this sticker never got. Doing it
+		// here means only the animated stickers actually sent to a GIF-only app are ever converted,
+		// and the result lands in the variants tree, so the next send of it is immediate.
+		convertVariantOnDemand(file)?.let {
+			if (doCommitContent("image/gif", it)) {
+				return
+			}
+		}
+		if (abandoned) {
+			XLog.i("Input field went away while converting, abandoning the send")
+			return
+		}
+
 		if (isPngFallback && ("image/png" in supportedMimes || "image/*" in supportedMimes)) {
 			val compatSticker = createCompatSticker(file)
 			if (compatSticker != null) {
 				if (!doCommitContent("image/png", compatSticker)) {
 					openShareSheet(mimeType, file)
+				} else if (WebpAnimation.isAnimated(file)) {
+					// A png of an animated sticker drops the animation without saying so, which
+					// just looks broken. Distinguish an app that cannot take a GIF at all from one
+					// that could, had a variant been generated for this sticker.
+					showToast(
+						context.getString(
+							if ("image/gif" in supportedMimes) {
+								R.string.fallback_no_gif
+							} else {
+								R.string.fallback_animation
+							},
+						),
+					)
 				}
 				return
 			}
@@ -190,12 +331,79 @@ class StickerSender(
 
 	}
 
+	/**
+	 * Build the GIF variant of an animated sticker that does not have one yet, for a target that
+	 * takes image/gif but no webp. Returns null whenever that does not apply, or when conversion
+	 * fails, leaving the caller to fall back as before.
+	 *
+	 * @param file File the sticker being sent
+	 * @return File? the freshly written GIF, or null
+	 */
+	private suspend fun convertVariantOnDemand(file: File): File? {
+		if (abandoned || !generateGifVariants || "image/gif" !in supportedMimes) {
+			return null
+		}
+		if (!WebpAnimation.isAnimated(file) || formatVariant(file, "gif") != null) {
+			return null
+		}
+		val pack = file.parentFile?.name ?: return null
+		val destination =
+			File(context.filesDir, "variants/$pack/${file.nameWithoutExtension}.gif")
+
+		// Conversion takes seconds, which is long enough for an impatient second tap. Serialising on
+		// the destination means the second tap waits for the first result instead of starting a
+		// duplicate conversion, and the re-checks inside the lock let it use what just landed.
+		val lock = conversionLocks.computeIfAbsent(destination.path) { Mutex() }
+		lock.withLock {
+			if (destination.isFile) {
+				return destination
+			}
+			if (destination.path in failedConversions) {
+				return null
+			}
+			showToast(context.getString(R.string.fallback_converting))
+			val converted = withContext(Dispatchers.Default) {
+				// The decoder now runs inside the keyboard process, where anything escaping takes
+				// the keyboard down mid-typing. convert() only handles IOException and
+				// OutOfMemoryError, and a malformed sticker can produce neither of those.
+				runCatching {
+					GifVariantGenerator(context, toaster, null).convert(file, destination)
+				}.getOrElse {
+					if (it is CancellationException) {
+						throw it
+					}
+					XLog.e("On-demand GIF conversion threw for '${file.name}'")
+					XLog.e(it)
+					false
+				}
+			}
+			if (!converted) {
+				// Remember the failure: retrying costs seconds and will fail the same way.
+				failedConversions.add(destination.path)
+				XLog.e("On-demand GIF conversion failed for '${file.name}'")
+				return null
+			}
+		}
+		XLog.i("Converted '${file.name}' to a GIF variant on demand for $packageName")
+		return destination.takeIf { it.isFile }
+	}
+
 	/**
 	 * Called by doFallbackCommitContent. Opens a share sheet to send the sticker
 	 *
 	 * @param mimeType String
 	 * @param file File
 	 */
+	private companion object {
+		/**
+		 * Shared across senders, because a new one is built for every input field while a conversion
+		 * started in a previous field may still be running.
+		 */
+		val conversionLocks = ConcurrentHashMap<String, Mutex>()
+		val failedConversions: MutableSet<String> =
+			Collections.newSetFromMap(ConcurrentHashMap<String, Boolean>())
+	}
+
 	private fun openShareSheet(mimeType: String, file: File) {
 		XLog.i("$packageName reports that is doesn't support png over its InputConnectionCompat, so open a share sheet")
 		val uri = FileProvider.getUriForFile(
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/utilities/WebpAnimation.kt b/app/src/main/java/com/fredhappyface/ewesticker/utilities/WebpAnimation.kt
new file mode 100644
index 0000000..f61329e
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/utilities/WebpAnimation.kt
@@ -0,0 +1,365 @@
+package com.fredhappyface.ewesticker.utilities
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.PorterDuff
+import android.graphics.Rect
+import com.elvishew.xlog.XLog
+import java.io.File
+import java.io.IOException
+import java.io.RandomAccessFile
+
+/** Byte offset of the frame duration within an ANMF payload, after four 24-bit x/y/w/h fields */
+private const val ANMF_DURATION_OFFSET = 12
+
+/** Length of the fixed part of an ANMF payload, before its own sub-chunks begin */
+private const val ANMF_HEADER_SIZE = 16
+
+/** ANMF flag bit meaning "overwrite the canvas rectangle" rather than alpha-blend onto it */
+private const val FLAG_DO_NOT_BLEND = 0x02
+
+/** ANMF flag bit meaning "clear the canvas rectangle once this frame has been shown" */
+private const val FLAG_DISPOSE_TO_BACKGROUND = 0x01
+
+/** Payload length of a VP8X chunk: 4 flag bytes then two 24-bit canvas dimensions */
+private const val VP8X_PAYLOAD_SIZE = 10
+
+/** VP8X flag bit declaring that the image carries an alpha channel */
+private const val VP8X_FLAG_ALPHA = 0x10
+
+/**
+ * Reads the frames of an animated webp.
+ *
+ * The platform can play an animated webp back as an AnimatedImageDrawable but will not hand over
+ * individual frames, and re-encoding a sticker as a GIF needs every frame. Rather than bundling a
+ * second copy of libwebp to get at them, this walks the webp's RIFF container itself and re-wraps
+ * each ANMF frame as a standalone webp, which BitmapFactory decodes with the platform's own
+ * decoder. Frames are then composited onto a canvas following the blend and disposal rules from the
+ * container, so what a caller sees is what a viewer would see.
+ *
+ * @property width Int canvas width in pixels
+ * @property height Int canvas height in pixels
+ * @property durationsMs List<Int> display duration of each frame in milliseconds
+ */
+class WebpAnimation private constructor(
+	private val data: ByteArray,
+	val width: Int,
+	val height: Int,
+	private val frames: List<Frame>,
+) {
+	private class Frame(
+		val x: Int,
+		val y: Int,
+		val width: Int,
+		val height: Int,
+		val durationMs: Int,
+		val doNotBlend: Boolean,
+		val disposeToBackground: Boolean,
+		val payload: ByteArray,
+	)
+
+	val frameCount: Int
+		get() = frames.size
+
+	val durationsMs: List<Int>
+		get() = frames.map { it.durationMs }
+
+	/**
+	 * Composite and hand over each frame in turn. The same bitmap is reused across the whole
+	 * animation, so a consumer that needs to keep a frame must copy it.
+	 *
+	 * @param onFrame (Int, Bitmap) -> Unit called with the index and the composited canvas
+	 * @return Boolean false if any frame failed to decode
+	 */
+	fun forEachFrame(onFrame: (Int, Bitmap) -> Unit): Boolean {
+		val canvasBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+		val canvas = Canvas(canvasBitmap)
+		try {
+			frames.forEachIndexed { index, frame ->
+				val decoded = BitmapFactory.decodeByteArray(frame.payload, 0, frame.payload.size)
+				if (decoded == null) {
+					XLog.e("Could not decode frame $index of an animated webp")
+					return false
+				}
+				val target = Rect(frame.x, frame.y, frame.x + frame.width, frame.y + frame.height)
+				// "Do not blend" replaces the rectangle outright, so the area under it has to go
+				// first; otherwise the new frame is composited over what is already there.
+				if (frame.doNotBlend) {
+					canvas.save()
+					canvas.clipRect(target)
+					canvas.drawColor(0, PorterDuff.Mode.CLEAR)
+					canvas.restore()
+				}
+				canvas.drawBitmap(decoded, null, target, null)
+				decoded.recycle()
+
+				onFrame(index, canvasBitmap)
+
+				if (frame.disposeToBackground) {
+					canvas.save()
+					canvas.clipRect(target)
+					canvas.drawColor(0, PorterDuff.Mode.CLEAR)
+					canvas.restore()
+				}
+			}
+		} finally {
+			canvasBitmap.recycle()
+		}
+		return true
+	}
+
+	companion object {
+		/**
+		 * Is this file an animated webp? An animated webp declares an ANIM chunk immediately after
+		 * VP8X, so this only reads the start of the file rather than decoding it.
+		 *
+		 * @param file File the file to test
+		 * @return Boolean true if the file is an animated webp
+		 */
+		fun isAnimated(file: File): Boolean {
+			if (!file.name.endsWith(".webp", ignoreCase = true)) {
+				return false
+			}
+			// Walks the chunk headers, skipping over payloads rather than reading them. Searching a
+			// fixed-size prefix for "ANIM" was cheaper but wrong: anything sizeable sitting between
+			// VP8X and ANIM -- an ICC profile, say -- pushes the marker out of the window, and the
+			// sticker is then treated as still and never gets a GIF version.
+			return try {
+				RandomAccessFile(file, "r").use { raf ->
+					if (raf.length() < 12) {
+						return false
+					}
+					val header = ByteArray(12)
+					raf.readFully(header)
+					if (String(header, 0, 4, Charsets.ISO_8859_1) != "RIFF" ||
+						String(header, 8, 4, Charsets.ISO_8859_1) != "WEBP"
+					) {
+						return false
+					}
+					var position = 12L
+					val end = raf.length()
+					val chunk = ByteArray(8)
+					while (position + 8 <= end) {
+						raf.seek(position)
+						raf.readFully(chunk)
+						val fourcc = String(chunk, 0, 4, Charsets.ISO_8859_1)
+						if (fourcc == "ANIM" || fourcc == "ANMF") {
+							return true
+						}
+						val size = (chunk[4].toLong() and 0xFF) or
+							((chunk[5].toLong() and 0xFF) shl 8) or
+							((chunk[6].toLong() and 0xFF) shl 16) or
+							((chunk[7].toLong() and 0xFF) shl 24)
+						if (size < 0) {
+							return false
+						}
+						position += 8 + size + (size and 1)
+					}
+					false
+				}
+			} catch (e: IOException) {
+				XLog.e("Could not read the header of '${file.name}'")
+				XLog.e(e)
+				false
+			}
+		}
+
+		/**
+		 * Read an animated webp, or return null if the file is not one. A still webp has no ANMF
+		 * chunks and is not an error, just not animated.
+		 *
+		 * @param file File the webp to read
+		 * @return WebpAnimation? the animation, or null if the file holds no animation
+		 */
+		fun read(file: File): WebpAnimation? {
+			val data = try {
+				file.readBytes()
+			} catch (e: IOException) {
+				XLog.e("Could not read '${file.name}'")
+				XLog.e(e)
+				return null
+			}
+			if (data.size < 16 || !startsWith(data, 0, "RIFF") || !startsWith(data, 8, "WEBP")) {
+				return null
+			}
+
+			var canvasWidth = 0
+			var canvasHeight = 0
+			val frames = mutableListOf<Frame>()
+			forEachChunk(data, 12, riffEnd(data)) { fourcc, offset, size ->
+				when (fourcc) {
+					"VP8X" -> if (size >= VP8X_PAYLOAD_SIZE) {
+						canvasWidth = read24(data, offset + 4) + 1
+						canvasHeight = read24(data, offset + 7) + 1
+					}
+
+					"ANMF" -> if (size >= ANMF_HEADER_SIZE) {
+						readFrame(data, offset, size)?.let { frames.add(it) }
+					}
+				}
+			}
+
+			if (frames.isEmpty() || canvasWidth <= 0 || canvasHeight <= 0) {
+				return null
+			}
+			return WebpAnimation(data, canvasWidth, canvasHeight, frames)
+		}
+
+		private fun readFrame(data: ByteArray, offset: Int, size: Int): Frame? {
+			// Frame offsets are stored divided by two, so they are always even.
+			val x = read24(data, offset) * 2
+			val y = read24(data, offset + 3) * 2
+			val width = read24(data, offset + 6) + 1
+			val height = read24(data, offset + 9) + 1
+			val durationMs = read24(data, offset + ANMF_DURATION_OFFSET)
+			val flags = data[offset + 15].toInt()
+
+			var alpha: IntArray? = null
+			var image: IntArray? = null
+			var lossless: IntArray? = null
+			forEachChunk(data, offset + ANMF_HEADER_SIZE, offset + size) { fourcc, at, len ->
+				when (fourcc) {
+					"ALPH" -> alpha = intArrayOf(at, len)
+					"VP8 " -> image = intArrayOf(at, len)
+					"VP8L" -> lossless = intArrayOf(at, len)
+				}
+			}
+
+			val payload = buildFrameWebp(data, width, height, alpha, image, lossless) ?: return null
+			return Frame(
+				x,
+				y,
+				width,
+				height,
+				durationMs,
+				flags and FLAG_DO_NOT_BLEND != 0,
+				flags and FLAG_DISPOSE_TO_BACKGROUND != 0,
+				payload,
+			)
+		}
+
+		/**
+		 * Wrap a single frame's compressed data in a RIFF container so that it becomes an ordinary
+		 * one-image webp file. Lossless frames carry their own alpha; a lossy frame with alpha needs
+		 * a VP8X header declaring it, followed by the alpha and colour chunks in that order.
+		 */
+		private fun buildFrameWebp(
+			data: ByteArray,
+			width: Int,
+			height: Int,
+			alpha: IntArray?,
+			image: IntArray?,
+			lossless: IntArray?,
+		): ByteArray? {
+			val body = ByteArrayBuilder()
+			when {
+				lossless != null -> body.chunk("VP8L", data, lossless[0], lossless[1])
+
+				image == null -> return null
+
+				alpha != null -> {
+					val header = ByteArrayBuilder()
+					header.byte(VP8X_FLAG_ALPHA)
+					header.byte(0).byte(0).byte(0)
+					header.int24(width - 1)
+					header.int24(height - 1)
+					body.chunk("VP8X", header.toByteArray(), 0, VP8X_PAYLOAD_SIZE)
+					body.chunk("ALPH", data, alpha[0], alpha[1])
+					body.chunk("VP8 ", data, image[0], image[1])
+				}
+
+				else -> body.chunk("VP8 ", data, image[0], image[1])
+			}
+
+			val bodyBytes = body.toByteArray()
+			val file = ByteArrayBuilder()
+			file.ascii("RIFF")
+			file.int32(4 + bodyBytes.size)
+			file.ascii("WEBP")
+			file.bytes(bodyBytes, 0, bodyBytes.size)
+			return file.toByteArray()
+		}
+
+		/** Walk the RIFF chunks between two offsets, honouring the pad byte on odd lengths */
+		private inline fun forEachChunk(
+			data: ByteArray,
+			from: Int,
+			to: Int,
+			action: (String, Int, Int) -> Unit,
+		) {
+			var pos = from
+			while (pos + 8 <= to) {
+				val fourcc = String(data, pos, 4, Charsets.ISO_8859_1)
+				val size = readInt32(data, pos + 4)
+				if (size < 0 || pos + 8 + size > to) {
+					return
+				}
+				action(fourcc, pos + 8, size)
+				pos += 8 + size + (size and 1)
+			}
+		}
+
+		private fun riffEnd(data: ByteArray): Int =
+			minOf(data.size, 8 + readInt32(data, 4))
+
+		private fun startsWith(data: ByteArray, offset: Int, text: String): Boolean =
+			text.indices.all { data[offset + it].toInt() and 0xFF == text[it].code }
+
+		private fun read24(data: ByteArray, offset: Int): Int =
+			(data[offset].toInt() and 0xFF) or
+				((data[offset + 1].toInt() and 0xFF) shl 8) or
+				((data[offset + 2].toInt() and 0xFF) shl 16)
+
+		private fun readInt32(data: ByteArray, offset: Int): Int =
+			read24(data, offset) or ((data[offset + 3].toInt() and 0xFF) shl 24)
+	}
+}
+
+/** Minimal growable byte buffer, enough to assemble a RIFF container */
+private class ByteArrayBuilder {
+	private var buffer = ByteArray(64)
+	private var length = 0
+
+	private fun ensure(extra: Int) {
+		if (length + extra > buffer.size) {
+			buffer = buffer.copyOf(maxOf(buffer.size * 2, length + extra))
+		}
+	}
+
+	fun byte(value: Int): ByteArrayBuilder {
+		ensure(1)
+		buffer[length++] = value.toByte()
+		return this
+	}
+
+	fun bytes(source: ByteArray, offset: Int, count: Int): ByteArrayBuilder {
+		ensure(count)
+		source.copyInto(buffer, length, offset, offset + count)
+		length += count
+		return this
+	}
+
+	fun ascii(text: String): ByteArrayBuilder {
+		text.forEach { byte(it.code) }
+		return this
+	}
+
+	fun int24(value: Int): ByteArrayBuilder =
+		byte(value).byte(value shr 8).byte(value shr 16)
+
+	fun int32(value: Int): ByteArrayBuilder =
+		int24(value).byte(value shr 24)
+
+	fun chunk(fourcc: String, source: ByteArray, offset: Int, count: Int): ByteArrayBuilder {
+		ascii(fourcc)
+		int32(count)
+		bytes(source, offset, count)
+		if (count and 1 == 1) {
+			byte(0)
+		}
+		return this
+	}
+
+	fun toByteArray(): ByteArray = buffer.copyOf(length)
+}
diff --git a/app/src/main/java/com/fredhappyface/ewesticker/view/PackHeaderViewHolder.kt b/app/src/main/java/com/fredhappyface/ewesticker/view/PackHeaderViewHolder.kt
new file mode 100644
index 0000000..c28dee4
--- /dev/null
+++ b/app/src/main/java/com/fredhappyface/ewesticker/view/PackHeaderViewHolder.kt
@@ -0,0 +1,11 @@
+package com.fredhappyface.ewesticker.view
+
+import android.view.View
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import com.fredhappyface.ewesticker.R
+
+class PackHeaderViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+	val packName: TextView = itemView.findViewById(R.id.packHeaderName)
+	val divider: View = itemView.findViewById(R.id.packHeaderDivider)
+}
diff --git a/app/src/main/res/drawable/delete_circle.xml b/app/src/main/res/drawable/delete_circle.xml
new file mode 100644
index 0000000..d7cf668
--- /dev/null
+++ b/app/src/main/res/drawable/delete_circle.xml
@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="200dp" android:viewportHeight="512" android:viewportWidth="512" android:width="200dp">
+
+    <path android:fillColor="@color/fg" android:pathData="M256,48C141.13,48 48,141.13 48,256s93.13,208 208,208 208,-93.13 208,-208S370.87,48 256,48zM256,80c97.05,0 176,78.95 176,176s-78.95,176 -176,176S80,353.05 80,256 158.95,80 256,80z"/>
+    <path android:fillColor="@color/fg" android:pathData="M200,152h112v24h56v28H144v-28h56zM168,224h176l-14,152a24,24 0,0 1,-24 22h-100a24,24 0,0 1,-24 -22zM216,252v112h24V252zM272,252v112h24V252z"/>
+
+</vector>
diff --git a/app/src/main/res/drawable/delete_confirm_circle.xml b/app/src/main/res/drawable/delete_confirm_circle.xml
new file mode 100644
index 0000000..ba25361
--- /dev/null
+++ b/app/src/main/res/drawable/delete_confirm_circle.xml
@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="200dp" android:viewportHeight="512" android:viewportWidth="512" android:width="200dp">
+
+    <path android:fillColor="@color/accent_a" android:pathData="M256,48C141.13,48 48,141.13 48,256s93.13,208 208,208 208,-93.13 208,-208S370.87,48 256,48z"/>
+    <path android:fillColor="@color/bg" android:pathData="M200,152h112v24h56v28H144v-28h56zM168,224h176l-14,152a24,24 0,0 1,-24 22h-100a24,24 0,0 1,-24 -22zM216,252v112h24V252zM272,252v112h24V252z"/>
+
+</vector>
diff --git a/app/src/main/res/drawable/pack_selected.xml b/app/src/main/res/drawable/pack_selected.xml
new file mode 100644
index 0000000..6fd8b2f
--- /dev/null
+++ b/app/src/main/res/drawable/pack_selected.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- The selected pack reads as a filled container behind the icon. Tinting the sticker image itself
+     was the old behaviour, which recoloured the artwork rather than indicating selection. -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+	android:shape="rectangle">
+	<corners android:radius="@dimen/pack_corner" />
+	<solid android:color="@color/selection_container" />
+</shape>
diff --git a/app/src/main/res/drawable/preview_surface.xml b/app/src/main/res/drawable/preview_surface.xml
new file mode 100644
index 0000000..bd9220f
--- /dev/null
+++ b/app/src/main/res/drawable/preview_surface.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+	android:shape="rectangle">
+	<corners android:radius="@dimen/preview_corner" />
+	<solid android:color="@color/bg2" />
+</shape>
diff --git a/app/src/main/res/drawable/resize_grabber.xml b/app/src/main/res/drawable/resize_grabber.xml
new file mode 100644
index 0000000..acd96ec
--- /dev/null
+++ b/app/src/main/res/drawable/resize_grabber.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- The grab indicator inside the resize handle. Uses the outline role so it reads as chrome
+     rather than as something tappable like a pack icon. -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+	android:shape="rectangle">
+	<solid android:color="@color/outline" />
+	<corners android:radius="@dimen/resize_grabber_height" />
+</shape>
diff --git a/app/src/main/res/drawable/star_circle.xml b/app/src/main/res/drawable/star_circle.xml
new file mode 100644
index 0000000..fdd63ef
--- /dev/null
+++ b/app/src/main/res/drawable/star_circle.xml
@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="200dp" android:viewportHeight="512" android:viewportWidth="512" android:width="200dp">
+
+    <path android:fillColor="@color/fg" android:pathData="M256,48C141.13,48 48,141.13 48,256s93.13,208 208,208 208,-93.13 208,-208S370.87,48 256,48zM256,80c97.05,0 176,78.95 176,176s-78.95,176 -176,176S80,353.05 80,256 158.95,80 256,80z"/>
+    <path android:fillColor="@color/fg" android:pathData="M256,136l35.1,71.12 78.5,11.41 -56.8,55.36 13.41,78.18L256,315.15l-70.21,36.92 13.41,-78.18 -56.8,-55.36 78.5,-11.41zM256,180.2l-19.55,39.61 -43.72,6.35 31.63,30.84 -7.47,43.54L256,279.98l39.11,20.56 -7.47,-43.54 31.63,-30.84 -43.72,-6.35z"/>
+
+</vector>
diff --git a/app/src/main/res/drawable/star_filled_circle.xml b/app/src/main/res/drawable/star_filled_circle.xml
new file mode 100644
index 0000000..892b039
--- /dev/null
+++ b/app/src/main/res/drawable/star_filled_circle.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="200dp" android:viewportHeight="512" android:viewportWidth="512" android:width="200dp">
+
+    <path android:fillColor="@color/fg" android:pathData="M256,48C141.13,48 48,141.13 48,256s93.13,208 208,208 208,-93.13 208,-208S370.87,48 256,48zM326.21,351.07 L256,314.15l-70.21,36.92 13.41,-78.18 -56.8,-55.36 78.5,-11.41L256,135l35.1,71.12 78.5,11.41 -56.8,55.36z"/>
+
+</vector>
diff --git a/app/src/main/res/drawable/sticker_ripple.xml b/app/src/main/res/drawable/sticker_ripple.xml
new file mode 100644
index 0000000..9477f73
--- /dev/null
+++ b/app/src/main/res/drawable/sticker_ripple.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+	android:color="@color/ripple">
+	<item android:id="@android:id/mask">
+		<shape android:shape="rectangle">
+			<corners android:radius="@dimen/sticker_corner" />
+			<solid android:color="#ffffffff" />
+		</shape>
+	</item>
+</ripple>
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 1ce3029..889ceda 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -137,6 +137,13 @@
 						android:text="@string/reload_sticker_pack_button"
 						app:shapeAppearance="?attr/shapeAppearanceSmallComponent" />
 
+					<Button
+						android:id="@+id/fullReimportBtn"
+						style="@style/button"
+						android:onClick="fullReimport"
+						android:text="@string/full_reimport_button"
+						app:shapeAppearance="?attr/shapeAppearanceSmallComponent" />
+
 					<com.google.android.material.progressindicator.LinearProgressIndicator
 						android:id="@+id/linearProgressIndicator"
 						android:layout_width="match_parent"
@@ -145,6 +152,54 @@
 
 				</LinearLayout>
 			</com.google.android.material.card.MaterialCardView>
+			<!-- Library -->
+			<com.google.android.material.card.MaterialCardView style="@style/card">
+
+				<LinearLayout
+					style="@style/cardchild"
+					android:orientation="vertical">
+
+					<TextView
+						style="@style/heading"
+						android:text="@string/library_heading" />
+
+					<TextView
+						android:id="@+id/librarySummary"
+						style="@style/body_text"
+						android:text="@string/library_scanning" />
+
+					<TextView
+						android:id="@+id/libraryAnimated"
+						style="@style/body_text"
+						android:text="" />
+
+					<TextView
+						android:id="@+id/libraryCoverage"
+						style="@style/body_text"
+						android:paddingBottom="@dimen/content_margin"
+						android:text="" />
+
+					<Button
+						android:id="@+id/generateVariantsBtn"
+						style="@style/button"
+						android:onClick="generateVariants"
+						android:text="@string/library_generate_button"
+						app:shapeAppearance="?attr/shapeAppearanceSmallComponent" />
+
+					<Button
+						android:id="@+id/deleteVariantsBtn"
+						style="@style/button"
+						android:onClick="deleteVariants"
+						android:text="@string/library_delete_button"
+						app:shapeAppearance="?attr/shapeAppearanceSmallComponent" />
+
+					<com.google.android.material.progressindicator.LinearProgressIndicator
+						android:id="@+id/libraryProgressIndicator"
+						android:layout_width="match_parent"
+						android:layout_height="wrap_content"
+						android:visibility="gone" />
+				</LinearLayout>
+			</com.google.android.material.card.MaterialCardView>
 			<!-- Options -->
 			<com.google.android.material.card.MaterialCardView style="@style/card">
 
@@ -226,6 +281,20 @@
 							android:text="@string/options_restore_on_close" />
 					</LinearLayout>
 
+					<LinearLayout
+						style="@style/widthMatchHeightWrap"
+						android:orientation="horizontal">
+
+						<CheckBox
+							android:id="@+id/continuousScroll"
+							style="@style/checkbox" />
+
+						<TextView
+							style="@style/body_text"
+							android:paddingBottom="@dimen/content_margin"
+							android:text="@string/options_continuous_scroll" />
+					</LinearLayout>
+
 					<LinearLayout
 						style="@style/widthMatchHeightWrap"
 						android:orientation="horizontal">
@@ -268,6 +337,34 @@
 							android:text="@string/options_png_fallback" />
 					</LinearLayout>
 
+					<LinearLayout
+						style="@style/widthMatchHeightWrap"
+						android:orientation="horizontal">
+
+						<CheckBox
+							android:id="@+id/animateGrid"
+							style="@style/checkbox" />
+
+						<TextView
+							style="@style/body_text"
+							android:paddingBottom="@dimen/content_margin"
+							android:text="@string/options_animate_grid" />
+					</LinearLayout>
+
+					<LinearLayout
+						style="@style/widthMatchHeightWrap"
+						android:orientation="horizontal">
+
+						<CheckBox
+							android:id="@+id/generateGifs"
+							style="@style/checkbox" />
+
+						<TextView
+							style="@style/body_text"
+							android:paddingBottom="@dimen/content_margin"
+							android:text="@string/options_generate_gifs" />
+					</LinearLayout>
+
 					<LinearLayout
 						style="@style/widthMatchHeightWrap"
 						android:orientation="horizontal">
diff --git a/app/src/main/res/layout/keyboard_layout.xml b/app/src/main/res/layout/keyboard_layout.xml
index a6054f6..42aeca9 100644
--- a/app/src/main/res/layout/keyboard_layout.xml
+++ b/app/src/main/res/layout/keyboard_layout.xml
@@ -8,12 +8,36 @@
 	android:fitsSystemWindows="true"
 	tools:context="com.fredhappyface.ewesticker.ImageKeyboard">
 
+	<!-- Drag to resize. It is its own view rather than a gesture on the pack bar because that bar
+	     scrolls horizontally and already carries long-press, so a drag there would be ambiguous. -->
+	<FrameLayout
+		android:id="@+id/resizeHandle"
+		android:layout_width="match_parent"
+		android:layout_height="@dimen/resize_handle_height"
+		android:layout_alignParentTop="true"
+		android:background="@color/surface_bar"
+		android:contentDescription="@string/resize_handle"
+		android:focusable="true">
+
+		<View
+			android:layout_width="@dimen/resize_grabber_width"
+			android:layout_height="@dimen/resize_grabber_height"
+			android:layout_gravity="center"
+			android:background="@drawable/resize_grabber" />
+	</FrameLayout>
+
+	<!-- The pack bar sits on its own surface so it reads as a toolbar rather than as the first row
+	     of stickers. -->
 	<HorizontalScrollView
 		android:id="@+id/topHScrollView"
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
-		android:layout_alignParentTop="true"
-		android:padding="@dimen/sticker_padding"
+		android:layout_below="@id/resizeHandle"
+		android:background="@color/surface_bar"
+		android:paddingStart="@dimen/bar_padding"
+		android:paddingTop="@dimen/bar_padding"
+		android:paddingEnd="@dimen/bar_padding"
+		android:paddingBottom="@dimen/bar_padding"
 		android:scrollbars="none">
 
 		<LinearLayout
diff --git a/app/src/main/res/layout/pack_header.xml b/app/src/main/res/layout/pack_header.xml
new file mode 100644
index 0000000..8dcd055
--- /dev/null
+++ b/app/src/main/res/layout/pack_header.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="match_parent"
+	android:layout_height="wrap_content"
+	android:orientation="vertical"
+	android:paddingStart="@dimen/content_margin"
+	android:paddingEnd="@dimen/content_margin">
+
+	<View
+		android:id="@+id/packHeaderDivider"
+		android:layout_width="match_parent"
+		android:layout_height="1dp"
+		android:layout_marginTop="@dimen/content_margin"
+		android:alpha="0.3"
+		android:background="@color/outline" />
+
+	<TextView
+		android:id="@+id/packHeaderName"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:ellipsize="end"
+		android:letterSpacing="0.08"
+		android:maxLines="1"
+		android:paddingTop="@dimen/content_margin"
+		android:paddingBottom="@dimen/content_margin_bottom"
+		android:textAllCaps="true"
+		android:textColor="@color/accent"
+		android:textSize="@dimen/text_size_tiny"
+		android:textStyle="bold" />
+</LinearLayout>
diff --git a/app/src/main/res/layout/sticker_card.xml b/app/src/main/res/layout/sticker_card.xml
index d46ffab..af32e68 100644
--- a/app/src/main/res/layout/sticker_card.xml
+++ b/app/src/main/res/layout/sticker_card.xml
@@ -1,17 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-	xmlns:app="http://schemas.android.com/apk/res-auto"
 	android:layout_width="wrap_content"
 	android:layout_height="wrap_content"
-	android:padding="@dimen/sticker_padding"
-	app:cardCornerRadius="@dimen/zero">
+	android:padding="@dimen/sticker_padding">
 
 	<ImageButton
 		android:id="@+id/stickerButton"
 		android:layout_width="@dimen/pack_dimens"
 		android:layout_height="@dimen/pack_dimens"
-		android:background="@color/bg"
+		android:background="@drawable/sticker_ripple"
 		android:contentDescription="@string/pack_icon"
 		android:cropToPadding="true"
+		android:padding="@dimen/sticker_padding"
 		android:scaleType="fitCenter" />
 </FrameLayout>
diff --git a/app/src/main/res/layout/sticker_preview.xml b/app/src/main/res/layout/sticker_preview.xml
index aec0dd1..ec48e40 100644
--- a/app/src/main/res/layout/sticker_preview.xml
+++ b/app/src/main/res/layout/sticker_preview.xml
@@ -1,32 +1,80 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!-- A scrim over the keyboard with the sticker on a raised, rounded surface, rather than a flat
+     panel the same colour as everything behind it. -->
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-	android:id="@+id/packContent"
-	android:background="@color/bg"
 	android:layout_width="match_parent"
-	android:layout_height="wrap_content">
+	android:layout_height="wrap_content"
+	android:background="@color/scrim">
 
-	<TextView
-		android:id="@+id/stickerInfo"
-		style="@style/body_text"
-		android:layout_centerHorizontal="true"
-		android:text="" />
-
-	<ImageButton
-		android:id="@+id/stickerButton"
-		android:layout_width="wrap_content"
+	<LinearLayout
+		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
-		android:layout_below="@id/stickerInfo"
-		android:layout_centerHorizontal="true"
-		android:layout_gravity="center|center_horizontal|center_vertical"
-		android:background="@color/bg"
-		android:contentDescription="@string/sticker_icon"
-		android:cropToPadding="true"
-		android:scaleType="fitCenter" />
-
-	<TextView
-		style="@style/body_text"
-		android:layout_below="@id/stickerButton"
-		android:layout_centerHorizontal="true"
-		android:text="@string/close_sticker_preview" />
+		android:layout_centerInParent="true"
+		android:layout_margin="@dimen/content_margin"
+		android:background="@drawable/preview_surface"
+		android:elevation="8dp"
+		android:orientation="vertical"
+		android:padding="@dimen/content_margin">
+
+		<RelativeLayout
+			android:layout_width="match_parent"
+			android:layout_height="wrap_content">
+
+			<ImageButton
+				android:id="@+id/deleteButton"
+				android:layout_width="@dimen/pack_dimens"
+				android:layout_height="@dimen/pack_dimens"
+				android:layout_alignParentStart="true"
+				android:background="@drawable/sticker_ripple"
+				android:contentDescription="@string/delete_sticker"
+				android:padding="@dimen/sticker_padding"
+				android:scaleType="fitCenter" />
+
+			<TextView
+				android:id="@+id/stickerInfo"
+				style="@style/body_text"
+				android:layout_width="match_parent"
+				android:layout_centerVertical="true"
+				android:layout_marginStart="@dimen/sticker_padding"
+				android:layout_marginEnd="@dimen/sticker_padding"
+				android:layout_toStartOf="@id/favouriteButton"
+				android:layout_toEndOf="@id/deleteButton"
+				android:ellipsize="middle"
+				android:gravity="center"
+				android:maxLines="2"
+				android:textSize="@dimen/text_size_tiny"
+				android:text="" />
+
+			<ImageButton
+				android:id="@+id/favouriteButton"
+				android:layout_width="@dimen/pack_dimens"
+				android:layout_height="@dimen/pack_dimens"
+				android:layout_alignParentEnd="true"
+				android:background="@drawable/sticker_ripple"
+				android:contentDescription="@string/favourite_toggle"
+				android:padding="@dimen/sticker_padding"
+				android:scaleType="fitCenter" />
+		</RelativeLayout>
+
+		<ImageButton
+			android:id="@+id/stickerButton"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:layout_gravity="center_horizontal"
+			android:layout_marginTop="@dimen/content_margin"
+			android:background="@color/transparent"
+			android:contentDescription="@string/sticker_icon"
+			android:cropToPadding="true"
+			android:scaleType="fitCenter" />
+
+		<TextView
+			style="@style/body_text"
+			android:layout_width="match_parent"
+			android:layout_marginTop="@dimen/content_margin"
+			android:alpha="0.7"
+			android:gravity="center"
+			android:textSize="@dimen/text_size_tiny"
+			android:text="@string/close_sticker_preview" />
+	</LinearLayout>
 
 </RelativeLayout>
diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml
index 857ec0b..16f404c 100644
--- a/app/src/main/res/values-ar/strings.xml
+++ b/app/src/main/res/values-ar/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- الشيفرة المصدرية لEweSticker متاحة على https://github.com/FredHappyface/Android.EweSticker\n\n- تأخذ الدروس بيدك خلال سلسلة من الخطوات لبدء استخدام البرنامج. ابدأ من هنا إذا كنت جديدًا: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- دليل المساعدة يوفر نقطة انطلاق ويوضح المشكلات الشائعة التي قد تواجهها: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- رخصة MIT\n(انظر الرخصة لمزيد من المعلومات https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- الرسائل التفاعلية -->
     <string name="version_heading">معلومات موجزة</string>
-    <string name="pref_000">تم تغيير التفضيلات. أعد تحميل لوحة المفاتيح لتطبيق الإعدادات</string>
     <string name="imported_010">بدء عملية الاستيراد. قد يستغرق ذلك بعض الوقت!</string>
-    <string name="imported_020">تم استيراد %1$d ملصق. أعد تحميل لوحة المفاتيح لعرض الملصقات الجديدة</string>
     <string name="imported_034">E034: فشلت عملية إعادة تحميل الملصقات، حاول اختيار مجلد مصدر الملصقات</string>
     <string name="fallback_041">E041: حدث استثناء غير متوقع أثناء تحويل الملصق</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-bn/strings.xml b/app/src/main/res/values-bn/strings.xml
index 73728f3..90058f2 100644
--- a/app/src/main/res/values-bn/strings.xml
+++ b/app/src/main/res/values-bn/strings.xml
@@ -42,9 +42,7 @@
     <!-- লিঙ্ক -->
 	<string name="links_heading">লিঙ্কস</string>
     <string name="links_text">- EweStickerের উৎসকোড উপলব্ধ https://github.com/FredHappyface/Android.EweSticker\n\n- টিউটোরিয়ালগুলি আপনাকে সফলভাবে সফটওয়্যার ব্যবহার করার জন্য এক ধরনের ধরাধারিত ধাক্কা মেয়ে নিয়ে যায়। নতুন হলে এখানে শুরু করুন: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- সাহায্য গাইড একটি শুরুপ্রয়াস প্রদান করে এবং আপনি যে সাধারণ সমস্যা নিয়ে বাধা পান তা প্রতিপাদন করে: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- মিট লাইসেন্স\n(আরও তথ্যের জন্য লাইসেন্সটি দেখুন https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
-    <string name="pref_000">পছন্দস্থান পরিবর্তন হয়েছে। সেটিংস প্রয়োগ করার জন্য কীবোর্ড পুনরায় লোড করুন</string>
     <string name="imported_010">আমদানি শুরু হয়েছে। এটি কিছু সময় নিতে পারে!</string>
-    <string name="imported_020">%1$d টি স্টিকার আমদানি করা হয়েছে। নতুন স্টিকার দেখানোর জন্য কীবোর্ড পুনরায় লোড করুন</string>
     <string name="imported_034">E034: স্টিকার পুনরায় লোড করা যায়নি, স্টিকার শোর্স ডিরেক্টরি চয়ন করার চেষ্টা করুন</string>
     <string name="fallback_041">E041: অপ্রত্যাশিত IOException যখন স্টিকার রুপান্তর করা হয়</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml
index 02c7ca2..67b05ad 100644
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- Der Quellcode für EweSticker ist verfügbar unter https://github.com/FredHappyface/Android.EweSticker\n\n- Die Tutorials führen dich schrittweise durch eine Reihe von Schritten, um die Software zu verwenden. Starte hier, wenn du neu bist: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- Der Hilfsleitfaden bietet einen Ausgangspunkt und erläutert häufig auftretende Probleme, die auftreten können: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT Lizenz\n(Siehe die Lizenz für weitere Informationen https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Interaktive Nachrichten -->
     <string name="version_heading">Details zum Artikel</string>
-    <string name="pref_000">Einstellungen geändert. Lade die Tastatur neu, damit die Einstellungen wirksam werden</string>
     <string name="imported_010">Import wird gestartet. Dies könnte einige Zeit dauern!</string>
-    <string name="imported_020">%1$d Sticker importiert. Lade die Tastatur neu, um neue Sticker anzuzeigen</string>
     <string name="imported_034">E034: Neuladen der Sticker fehlgeschlagen, versuche ein Sticker-Quellverzeichnis auszuwählen</string>
     <string name="fallback_041">E041: Unerwarteter IOException beim Konvertieren des Stickers</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml
index 12dc257..27b390d 100644
--- a/app/src/main/res/values-es/strings.xml
+++ b/app/src/main/res/values-es/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- El código fuente de EweSticker está disponible en https://github.com/FredHappyface/Android.EweSticker\n\n- Los tutoriales te llevan de la mano a través de una serie de pasos para empezar a usar el software. Empiece aquí si es nuevo: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- La guía de ayuda proporciona un punto de partida y esboza los problemas comunes que usted puede tener: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- Licencia MIT\n(Vea la licencia para más información https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Interactive Messages -->
     <string name="version_heading">Versión</string>
-    <string name="pref_000">Preferencias modificadas. Vuelva a cargar el teclado para que se apliquen los ajustes</string>
     <string name="imported_010">Comenzando la importación. ¡Esto puede llevar algún tiempo!</string>
-    <string name="imported_020">Importado %1$d stickers. Recargar el teclado para que se muestren los nuevos stickers</string>
     <string name="imported_034">E034: Falló la recarga de stickers, intente elegir un directorio de origen de los stickers</string>
     <string name="fallback_041">E041: IOException inesperado al convertir el sticker</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml
index beaea53..b0fbf86 100644
--- a/app/src/main/res/values-fr/strings.xml
+++ b/app/src/main/res/values-fr/strings.xml
@@ -36,9 +36,7 @@
     <string name="links_heading">Liens</string>
     <string name="links_text">- Le code source pour EweSticker est disponible à l\'adresse https://github.com/FredHappyface/Android.\n\n- Les tutoriels vous emmènent à la main par une série de étapes pour commencer à utiliser le logiciel. Commencez ici si vous êtes nouveau: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- Le guide d\'aide fournit un point de départ et décrit les questions fréquentes que vous pouvez avoir: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- Licence MIT\n(Voir la licence pour plus d\'informations https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <string name="version_heading">Version Info</string>
-    <string name="pref_000">Les préférences ont changé. Recharger le clavier pour les appliquer</string>
     <string name="imported_010">Démarrage de l’importation. Ceci va prendre du temps!</string>
-    <string name="imported_020">Autocollants importés %1$d. Recharger le clavier pour afficher les nouveaux autocollants</string>
     <!-- Keyboard -->
 	<string name="sticker_pack_info">%1$s (Pack : %2$s)</string>
     <string name="options_insensitive_sort">Activer le tri des paquets sensibles</string>
diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml
index c09b24e..3745217 100644
--- a/app/src/main/res/values-hi/strings.xml
+++ b/app/src/main/res/values-hi/strings.xml
@@ -43,9 +43,7 @@
     <string name="links_text">- EweSticker का स्रोत कोड https://github.com/FredHappyface/Android.EweSticker पर उपलब्ध है\n\n- यदि आप नए हैं, तो यह सॉफ़्टवेयर उपयोग करना शुरू करने के लिए एक सीरीज के स्टेप्स के माध्यम से जाते हैं: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- सहायता गाइड एक शुरुआती पॉइंट प्रदान करता है और आपके पास सामान्य समस्याएँ को आउटलाइन करता है जो आपके पास हो सकती हैं: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT लाइसेंस\n(अधिक जानकारी के लिए लाइसेंस देखें https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Interactive Messages -->
     <string name="version_heading">संस्करण की जानकारी</string>
-    <string name="pref_000">प्राथमिकताएँ बदल गईं। सेटिंग्स को लागू करने के लिए कीबोर्ड को पुनः लोड करें</string>
     <string name="imported_010">आयात शुरू हुआ। इसमें कुछ समय लग सकता है!</string>
-    <string name="imported_020">%1$d स्टिकर्स का आयात हुआ। नए स्टिकर्स दिखाने के लिए कीबोर्ड को पुनः लोड करें</string>
     <string name="imported_034">E034: स्टिकर्स को पुनः लोड करने में विफलता हुई, कृपया स्टिकर स्रोत निर्दिष्ट करने का प्रयास करें</string>
     <string name="fallback_041">E041: स्टिकर कन्वर्ट करते समय अप्रत्याशित IOException</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml
index ee56b0a..7ec4daa 100644
--- a/app/src/main/res/values-in/strings.xml
+++ b/app/src/main/res/values-in/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- Kode sumber untuk EweSticker tersedia di https://github.com/FredHappyface/Android.EweSticker\n\n- Tutorial ini memandu Anda melalui serangkaian langkah untuk mulai menggunakan perangkat lunak ini. Mulailah dari sini jika Anda masih baru: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- Panduan bantuan menyediakan titik awal dan menguraikan masalah umum yang mungkin Anda alami: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- Lisensi MIT\n (Lihat lisensi untuk informasi lebih lanjut https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Pesan Interaktif -->
     <string name="version_heading">Info Versi</string>
-    <string name="pref_000">Preferensi berubah. Muat ulang keyboard agar pengaturan dapat diterapkan</string>
     <string name="imported_010">Mulai impor. Ini mungkin membutuhkan waktu!</string>
-    <string name="imported_020">Mengimpor stiker %1$d. Muat ulang keyboard agar stiker baru dapat ditampilkan</string>
     <string name="imported_034">E034: Gagal memuat ulang stiker, coba pilih direktori sumber stiker</string>
     <string name="fallback_041">E041: IOException yang tidak diharapkan saat mengonversi stiker</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
index 9576f66..88ad967 100644
--- a/app/src/main/res/values-ja/strings.xml
+++ b/app/src/main/res/values-ja/strings.xml
@@ -43,9 +43,7 @@
     <string name="links_text">- EweStickerのソースコードは https://github.com/FredHappyface/Android.EweSticker で利用可能です。\n\n- チュートリアルでは、ソフトウェアの使用を開始する一連の手順を紹介しています。新規の場合はこちらから始めてください: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- ヘルプガイドはスタート地点を提供し、一般的な問題について概説しています: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MITライセンス\n(詳細についてはライセンスを参照 https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- インタラクティブメッセージ -->
     <string name="version_heading">バージョン情報</string>
-    <string name="pref_000">設定が変更されました。設定が適用されるようにキーボードを再読み込みしてください</string>
     <string name="imported_010">インポートを開始しました。しばらく時間がかかることがあります！</string>
-    <string name="imported_020">%1$d ステッカーをインポートしました。新しいステッカーを表示するにはキーボードを再読み込みしてください</string>
     <string name="imported_034">E034: ステッカーの再読み込みに失敗しました。ステッカーソースディレクトリを選択してみてください</string>
     <string name="fallback_041">E041: ステッカーを変換する際に予期しないIOExceptionが発生しました</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml
index 5c31dd0..2bb35d7 100644
--- a/app/src/main/res/values-ko/strings.xml
+++ b/app/src/main/res/values-ko/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- EweSticker의 소스 코드는 https://github.com/FredHappyface/Android.EweSticker에서 제공됩니다.\n\n- 튜토리얼은 소프트웨어 사용을 시작하기 위한 일련의 단계를 안내합니다. 처음 사용자라면 여기에서 시작하십시오: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- 도움말 가이드는 시작점을 제공하고 일반적인 문제를 개요로 설명합니다: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT 라이선스\n(자세한 정보는 라이선스에서 확인하십시오 https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- 대화식 메시지 -->
     <string name="version_heading">버전 정보</string>
-    <string name="pref_000">설정이 변경되었습니다. 설정을 적용하려면 키보드를 다시 불러오세요</string>
     <string name="imported_010">가져오기 시작. 시간이 걸릴 수 있습니다!</string>
-    <string name="imported_020">%1$d개의 스티커를 가져왔습니다. 새 스티커를 표시하려면 키보드를 다시 불러오세요</string>
     <string name="imported_034">E034: 스티커 다시 불러오기 실패. 스티커 소스 디렉터리를 선택해보세요</string>
     <string name="fallback_041">E041: 스티커 변환 중 예기치 않은 IOException 발생</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-night-v31/colors.xml b/app/src/main/res/values-night-v31/colors.xml
new file mode 100644
index 0000000..98cbd6b
--- /dev/null
+++ b/app/src/main/res/values-night-v31/colors.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<color name="accent">@android:color/system_accent1_200</color>
+	<color name="onAccent">@android:color/system_accent1_900</color>
+	<color name="surface_bar">@android:color/system_neutral1_800</color>
+	<color name="selection_container">@android:color/system_accent2_700</color>
+	<color name="on_selection_container">@android:color/system_accent2_100</color>
+	<color name="outline">@android:color/system_neutral2_400</color>
+</resources>
diff --git a/app/src/main/res/values-night-v31/themes.xml b/app/src/main/res/values-night-v31/themes.xml
new file mode 100644
index 0000000..e9fe129
--- /dev/null
+++ b/app/src/main/res/values-night-v31/themes.xml
@@ -0,0 +1,5 @@
+<resources>
+	<color name="bg">@android:color/system_neutral1_900</color>
+	<color name="fg">@android:color/system_neutral1_100</color>
+	<color name="bg2">@android:color/system_neutral2_800</color>
+</resources>
diff --git a/app/src/main/res/values-night/colors.xml b/app/src/main/res/values-night/colors.xml
new file mode 100644
index 0000000..97aba6b
--- /dev/null
+++ b/app/src/main/res/values-night/colors.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<color name="surface_bar">#232827</color>
+	<color name="selection_container">#00504f</color>
+	<color name="on_selection_container">#9df0ee</color>
+	<color name="outline">#899391</color>
+	<color name="ripple">#440fa3a2</color>
+	<color name="scrim">#b3000000</color>
+</resources>
diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml
index f345c49..1c51226 100644
--- a/app/src/main/res/values-pt/strings.xml
+++ b/app/src/main/res/values-pt/strings.xml
@@ -43,9 +43,7 @@
     <string name="links_text">- O código-fonte do EweSticker está disponível em https://github.com/FredHappyface/Android.EweSticker\n\n- Os tutoriais o guiarão passo a passo para começar a usar o software. Comece aqui se você for iniciante: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- O guia de ajuda fornece um ponto de partida e destaca problemas comuns que você pode encontrar: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- Licença MIT\n(Consulte a licença para obter mais informações em https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Mensagens Interativas -->
     <string name="version_heading">Informação da Versão</string>
-    <string name="pref_000">Preferências alteradas. Recarregue o teclado para que as configurações se apliquem</string>
     <string name="imported_010">Iniciando a importação. Isso pode levar algum tempo!</string>
-    <string name="imported_020">Importados %1$d adesivos. Recarregue o teclado para mostrar os novos adesivos</string>
     <string name="imported_034">E034: Falha ao recarregar adesivos, tente escolher um diretório de origem dos adesivos</string>
     <string name="fallback_041">E041: IOException inesperada ao converter adesivo</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml
index e31ba92..9c7d3e3 100644
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -43,9 +43,7 @@
     <string name="links_text">- Исходный код EweSticker доступен по адресу https://github.com/FredHappyface/Android.EweSticker\n\n- Учебники предоставляют пошаговые инструкции по началу работы с программным обеспечением. Начните с этого, если вы новичок: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- Руководство помощи предоставляет отправную точку и описывает общие проблемы, с которыми вы можете столкнуться: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- Лицензия MIT\n(См. лицензию для получения дополнительной информации по адресу https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
     <!-- Интерактивные сообщения -->
     <string name="version_heading">Версия</string>
-    <string name="pref_000">Изменены настройки. Перезагрузите клавиатуру, чтобы настройки вступили в силу</string>
     <string name="imported_010">Начало импорта. Это может занять некоторое время!</string>
-    <string name="imported_020">Импортировано %1$d стикеров. Перезагрузите клавиатуру, чтобы отобразить новые стикеры</string>
     <string name="imported_034">E034: Перезагрузка стикеров не удалась, попробуйте выбрать каталог источника стикеров</string>
     <string name="fallback_041">E041: Неожиданная ошибка ввода-вывода при преобразовании стикера</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-ur/strings.xml b/app/src/main/res/values-ur/strings.xml
index 03bea7c..a0c5303 100644
--- a/app/src/main/res/values-ur/strings.xml
+++ b/app/src/main/res/values-ur/strings.xml
@@ -42,9 +42,7 @@
     <!-- لنکس -->
 	<string name="links_heading">لنکس</string>
     <string name="links_text">- EweSticker کا سورس کوڈ https://github.com/FredHappyface/Android.EweSticker پر دستیاب ہے۔\n\n- ٹیوٹوریلز آپ کو استعمال کرنے کے لئے ایک سلسلہ کاروائیوں کے ذریعے لے جاتے ہیں۔ اگر آپ نئے ہیں تو یہاں سے شروع کریں: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- مدد گائیڈ عمدہ آغاز فراہم کرتا ہے اور آپ کی سامنے آنے والی عام مسائل کی مختصر جائزہ دیتا ہے: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT لائسنس\n(مزید معلومات کے لئے لائسنس دیکھیں https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md )</string>
-    <string name="pref_000">ترتیبات تبدیل ہوگئی ہیں. ترتیبات کو اطلاق کرنے کے لئے کی بورڈ دوبارہ لوڈ کریں</string>
     <string name="imported_010">شروع کریں منتقلی. اس میں کچھ وقت لگ سکتا ہے!</string>
-    <string name="imported_020">%1$d اسٹکر منتقل کر لئے گئے ہیں. نئے اسٹکرز دکھانے کے لئے کی بورڈ دوبارہ لوڈ کریں</string>
     <string name="imported_034">E034: اسٹکرز دوبارہ لوڈ کرنے میں ناکامی. ایک اسٹکر سورس ڈائریکٹری منتخب کرنے کا کوشش کریں</string>
     <string name="fallback_041">E041: اسٹکر کو تبدیل کرنے کے دوران غیر متوقع IOException کا اعلان</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-v31/colors.xml b/app/src/main/res/values-v31/colors.xml
new file mode 100644
index 0000000..a65d5ef
--- /dev/null
+++ b/app/src/main/res/values-v31/colors.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<color name="accent">@android:color/system_accent1_600</color>
+	<color name="onAccent">@android:color/system_accent1_0</color>
+	<color name="surface_bar">@android:color/system_neutral2_100</color>
+	<color name="selection_container">@android:color/system_accent2_100</color>
+	<color name="on_selection_container">@android:color/system_accent1_900</color>
+	<color name="outline">@android:color/system_neutral2_500</color>
+</resources>
diff --git a/app/src/main/res/values-v31/themes.xml b/app/src/main/res/values-v31/themes.xml
new file mode 100644
index 0000000..76eb164
--- /dev/null
+++ b/app/src/main/res/values-v31/themes.xml
@@ -0,0 +1,6 @@
+<resources>
+	<!-- Material You: the keyboard follows the wallpaper-derived system palette. -->
+	<color name="bg">@android:color/system_neutral1_50</color>
+	<color name="fg">@android:color/system_neutral1_900</color>
+	<color name="bg2">@android:color/system_neutral2_100</color>
+</resources>
diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
index 70a6061..eeb8326 100644
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- EweSticker 的源代码可在 https://github.com/FredHappyface/Android.EweSticker 上获得\n\n- 教程将逐步引导您开始使用该软件。如果您是新手，请从这里开始: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- 帮助指南提供了一个起点，并概述了您可能遇到的常见问题: https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT 许可证\n（有关更多信息，请参阅许可证 https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md）</string>
     <!-- 交互消息 -->
     <string name="version_heading">信息</string>
-    <string name="pref_000">首选项已更改。重新加载键盘以应用设置</string>
     <string name="imported_010">开始导入。这可能需要一些时间！</string>
-    <string name="imported_020">已导入 %1$d 个贴纸。重新加载键盘以显示新贴纸</string>
     <string name="imported_034">E034: 重新加载贴纸失败，请尝试选择贴纸源目录</string>
     <string name="fallback_041">E041: 在转换贴纸时发生意外的 IOException</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml
index aaddaec..1e20440 100644
--- a/app/src/main/res/values-zh-rTW/strings.xml
+++ b/app/src/main/res/values-zh-rTW/strings.xml
@@ -44,9 +44,7 @@
     <string name="links_text">- EweSticker 的原始碼可以在 https://github.com/FredHappyface/Android.EweSticker 上獲得\n\n- 教程將逐步引導你完成一系列步驟以開始使用軟體。如果你是新手，請從這裏開始：https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/tutorials\n\n- 幫助指南提供了一個起點，並概述了您可能遇到的常見問題：https://github.com/FredHappyface/Android.EweSticker/blob/main/documentation/help\n\n- MIT 許可證\n（有關更多資訊，請參閱許可證 https://github.com/FredHappyface/Android.EweSticker/blob/main/LICENSE.md）</string>
     <!-- 交互消息 -->
     <string name="version_heading">信息</string>
-    <string name="pref_000">偏好設定已變更。重新載入鍵盤以套用設定</string>
     <string name="imported_010">正在開始匯入。這可能需要一些時間！</string>
-    <string name="imported_020">已匯入 %1$d 個貼圖。重新載入鍵盤以顯示新貼圖</string>
     <string name="imported_034">E034：重新載入貼圖失敗，請嘗試選擇貼圖來源目錄</string>
     <string name="fallback_041">E041：在轉換貼圖時發生意外的 IOException</string>
     <!-- Keyboard -->
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
index efc7f38..cec4839 100644
--- a/app/src/main/res/values/colors.xml
+++ b/app/src/main/res/values/colors.xml
@@ -4,4 +4,13 @@
 	<color name="accent_a">#880fa3a2</color>
 	<color name="transparent">#0000</color>
 	<color name="onAccent">#e6e6e6</color>
+
+	<!-- Keyboard surfaces. Overridden in values-v31 with the system palette, so on Android 12 and
+	     later the keyboard takes its colours from the user's wallpaper like the rest of the system. -->
+	<color name="surface_bar">#eef3f2</color>
+	<color name="selection_container">#b6e7e5</color>
+	<color name="on_selection_container">#00201f</color>
+	<color name="outline">#6f7978</color>
+	<color name="ripple">#330fa3a2</color>
+	<color name="scrim">#99000000</color>
 </resources>
diff --git a/app/src/main/res/values/dimen.xml b/app/src/main/res/values/dimen.xml
index cd7aaf4..b463c91 100644
--- a/app/src/main/res/values/dimen.xml
+++ b/app/src/main/res/values/dimen.xml
@@ -16,4 +16,14 @@
 	<dimen name="corner">16dp</dimen>
 	<dimen name="pack_dimens">40dp</dimen>
 	<dimen name="sticker_padding">4dp</dimen>
+	<dimen name="sticker_corner">14dp</dimen>
+	<dimen name="pack_corner">18dp</dimen>
+	<dimen name="preview_corner">28dp</dimen>
+	<dimen name="bar_padding">6dp</dimen>
+	<dimen name="header_spacing">0.08</dimen>
+	<!-- Drag-to-resize handle. The strip is deliberately taller than the grabber it draws so the
+	     touch target clears the ~48dp guidance once the pack bar below it is counted. -->
+	<dimen name="resize_handle_height">20dp</dimen>
+	<dimen name="resize_grabber_width">40dp</dimen>
+	<dimen name="resize_grabber_height">4dp</dimen>
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index bc8b7bb..feb4ebb 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -3,6 +3,13 @@
 	<string name="app_name" translatable="false">EweSticker</string>
 	<string name="pack_icon">Pack icon</string>
 	<string name="sticker_icon">Sticker icon</string>
+	<string name="delete_sticker">Delete this sticker</string>
+	<string name="delete_confirm">Tap again to delete this sticker</string>
+	<string name="delete_done">Deleted from your sticker folder</string>
+	<string name="delete_failed">Could not delete that sticker, see the logs</string>
+	<string name="favourite_toggle">Star or unstar this sticker</string>
+	<string name="favourite_added">Starred, find it in the star tab</string>
+	<string name="favourite_removed">Unstarred</string>
 	<string name="close_sticker_preview">[tap to close sticker preview]</string>
 	<!-- Enable Keyboard -->
 	<string name="enable_keyboard_heading">Enable Keyboard</string>
@@ -11,12 +18,35 @@
 	<string name="update_sticker_pack_heading">Update Sticker Pack</string>
 	<string name="update_sticker_pack_button">Choose sticker source directory</string>
 	<string name="reload_sticker_pack_button">Reload stickers</string>
+	<string name="full_reimport_button">Full re-import (rebuild everything)</string>
 	<string name="update_sticker_pack_info">Current loaded sticker packs information: </string>
 	<string name="update_sticker_pack_info_path_lbl">- Path: </string>
 	<string name="update_sticker_pack_info_path">Not Set</string>
 	<string name="update_sticker_pack_info_date_lbl">- Date: </string>
 	<string name="update_sticker_pack_info_date">Never</string>
 	<string name="update_sticker_pack_info_total_lbl">- Total: </string>
+	<!-- Library -->
+	<string name="library_heading">Library</string>
+	<string name="library_scanning">Reading library…</string>
+	<string name="library_empty">No stickers imported yet</string>
+	<string name="library_summary">%1$d stickers in %2$d packs (%3$s)</string>
+	<string name="library_animated">%1$d animated, %2$d with a GIF version (%3$s)</string>
+	<string name="library_all_covered">Every animated sticker has a GIF version</string>
+	<plurals name="library_missing">
+		<item quantity="one">%1$d animated sticker has no GIF version, so it arrives as a still image in apps that only accept GIF</item>
+		<item quantity="other">%1$d animated stickers have no GIF version, so they arrive as still images in apps that only accept GIF</item>
+	</plurals>
+	<string name="library_generate_button">Generate missing GIF versions</string>
+	<string name="library_delete_button">Delete GIF versions</string>
+	<string name="library_delete_title">Delete GIF versions?</string>
+	<string name="library_delete_message">This frees %1$s. Animated stickers will arrive as still images in apps that only accept GIF until you generate them again.</string>
+	<string name="library_delete_confirm">Delete</string>
+	<string name="library_deleted">Deleted GIF versions, freed %1$s</string>
+	<string name="library_generated">Generated %1$d GIF version(s)</string>
+	<string name="library_failed">Something went wrong reading or changing the library, see the logs</string>
+	<string name="library_generate_failed">Could not generate any GIF versions, see the logs</string>
+	<string name="library_generated_partial">Generated %1$d of %2$d GIF versions, the rest failed</string>
+	<string name="library_nothing_to_generate">Every animated sticker already has a GIF version</string>
 	<!-- Options -->
 	<string name="options_heading">Options</string>
 	<string name="options_show_back_button">Show back button in navbar</string>
@@ -27,6 +57,9 @@
 	<string name="options_scroll">Enable swipe between packs (perpendicular to scroll direction)</string>
 	<string name="options_insensitive_sort">Enable case-insensitive pack sorting</string>
 	<string name="options_png_fallback">Enable PNG sticker fallback if sticker format isn\'t supported</string>
+	<string name="options_continuous_scroll">Scroll through every pack in one list, with a heading per pack (vertical layout only)</string>
+	<string name="options_animate_grid">Play animated stickers in the grid. Turning this off shows a still frame instead, which scrolls faster and uses less battery</string>
+	<string name="options_generate_gifs">Make GIF versions of animated stickers, so they still animate in apps that only accept GIF (slows down importing)</string>
 	<string name="options_icons_per_x_lbl">"Number of Rows: "</string>
 	<string name="options_icon_size_status_lbl">"Icon size: "</string>
 	<!-- Info -->
@@ -75,14 +108,20 @@ Copyright © Randy Zhou</string>
 	<string name="logs_heading">Logs</string>
 	<string name="logs_button">Get log file</string>
 	<!-- Interactive Messages -->
-	<string name="pref_000">Preferences changed. Reload the keyboard for settings to apply</string>
+	<string name="pref_000">Preferences saved</string>
 	<string name="imported_010">Starting import. This might take some time!</string>
-	<string name="imported_020">Imported %1$d stickers. Reload the keyboard for new stickers to show</string>
+	<string name="imported_020">Imported %1$d stickers</string>
 	<string name="imported_031">E031: Found more than %1$d stickers in total</string>
 	<string name="imported_032">E032: Found more than %1$d stickers in pack (%2$s)</string>
 	<string name="imported_033">E033: Unsupported format found (%1$s, file: %2$s/%3$s)</string>
 	<string name="imported_034">E034: Reloading stickers failed, try choosing a sticker source directory</string>
+	<string name="imported_035">Making GIF versions of %1$d animated stickers, this takes a while</string>
+	<string name="imported_036">Could not read the sticker folder properly, so nothing was removed. Use Full re-import if the library looks wrong.</string>
 	<string name="fallback_041">E041: Unexpected IOException when converting sticker</string>
+	<string name="fallback_animation">Sent as an image, this app can\'t show animation</string>
+	<string name="fallback_converting">Making a GIF version of this sticker…</string>
+	<string name="fallback_no_gif">Sent as an image, no GIF version of this sticker yet</string>
 	<!-- Keyboard -->
 	<string name="sticker_pack_info">%1$s (Pack: %2$s)</string>
+	<string name="resize_handle">Drag to change the keyboard height</string>
 </resources>
diff --git a/app/src/main/res/xml/file_paths.xml b/app/src/main/res/xml/file_paths.xml
index 12a332e..7639be7 100644
--- a/app/src/main/res/xml/file_paths.xml
+++ b/app/src/main/res/xml/file_paths.xml
@@ -3,4 +3,8 @@
 	<files-path
 		name="added_stickers"
 		path="stickers/" />
+	<!-- Alternate encodings of the above, for apps that cannot render the original format -->
+	<files-path
+		name="sticker_variants"
+		path="variants/" />
 </paths>
diff --git a/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifEncoderTest.kt b/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifEncoderTest.kt
new file mode 100644
index 0000000..8dbb14d
--- /dev/null
+++ b/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifEncoderTest.kt
@@ -0,0 +1,147 @@
+package com.fredhappyface.ewesticker.utilities
+
+import java.io.ByteArrayOutputStream
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * GifEncoder writes a byte format by hand, so what is worth asserting is that decoding its output
+ * gives back what went in. These run on the JVM rather than a device because the encoder deliberately
+ * depends on nothing from Android.
+ */
+class GifEncoderTest {
+	private fun encode(
+		frames: List<IntArray>,
+		width: Int,
+		height: Int,
+		colors: Int = 128,
+		delayMs: Int = 100,
+	): ByteArray {
+		val out = ByteArrayOutputStream()
+		val encoder = GifEncoder(out, width, height, colors)
+		frames.forEach { encoder.addFrame(it, delayMs) }
+		encoder.finish()
+		return out.toByteArray()
+	}
+
+	@Test
+	fun `writes a well formed gif`() {
+		val width = 32
+		val height = 24
+		val frames = (0 until 5).map { frame ->
+			IntArray(width * height) { pixel ->
+				val x = pixel % width
+				0xFF000000.toInt() or (((x * 8 + frame * 20) and 0xFF) shl 16) or (frame * 40 and 0xFF)
+			}
+		}
+
+		val bytes = encode(frames, width, height)
+		assertEquals("GIF89a", String(bytes, 0, 6, Charsets.US_ASCII))
+		assertEquals(0x3B.toByte(), bytes.last())
+
+		val gif = GifReader.read(bytes)
+		assertEquals(width, gif.width)
+		assertEquals(height, gif.height)
+		assertEquals(frames.size, gif.frames.size)
+		gif.frames.forEach {
+			assertEquals(width, it.width)
+			assertEquals(height, it.height)
+			assertEquals(width * height, it.pixels.size)
+		}
+	}
+
+	@Test
+	fun `reproduces flat colour exactly`() {
+		// With far fewer distinct colours than palette slots, quantisation has no excuse to
+		// approximate anything, so this should survive the round trip untouched.
+		val width = 16
+		val height = 16
+		val red = 0xFFCC2211.toInt()
+		val blue = 0xFF1122CC.toInt()
+		val frame = IntArray(width * height) { if (it % width < width / 2) red else blue }
+
+		val decoded = GifReader.read(encode(listOf(frame), width, height)).frames.single()
+
+		assertEquals(red, decoded.pixels[0])
+		assertEquals(blue, decoded.pixels[width - 1])
+	}
+
+	@Test
+	fun `keeps transparent pixels transparent`() {
+		val width = 8
+		val height = 8
+		val opaque = 0xFF00FF00.toInt()
+		val frame = IntArray(width * height) { if (it % 2 == 0) opaque else 0 }
+
+		val decoded = GifReader.read(encode(listOf(frame), width, height)).frames.single()
+
+		assertEquals(0, decoded.pixels[1])
+		assertEquals(opaque, decoded.pixels[0])
+	}
+
+	@Test
+	fun `respects the palette budget`() {
+		// A gradient holds far more colours than the budget allows, so the encoder has to reduce it
+		// and must not emit a colour table bigger than it declared.
+		val width = 64
+		val height = 64
+		val frame = IntArray(width * height) { pixel ->
+			val x = pixel % width
+			val y = pixel / width
+			0xFF000000.toInt() or ((x * 4) shl 16) or ((y * 4) shl 8) or ((x + y) * 2 and 0xFF)
+		}
+
+		val decoded = GifReader.read(encode(listOf(frame), width, height, colors = 16))
+			.frames
+			.single()
+
+		assertTrue("colour table was ${decoded.paletteSize}", decoded.paletteSize <= 16)
+		assertTrue(
+			"expected at most 16 distinct colours, saw ${decoded.pixels.toSet().size}",
+			decoded.pixels.toSet().size <= 16,
+		)
+	}
+
+	@Test
+	fun `converts frame delays to centiseconds`() {
+		val frame = IntArray(4) { 0xFF808080.toInt() }
+		val gif = GifReader.read(encode(listOf(frame), 2, 2, delayMs = 83))
+		assertEquals(8, gif.frames.single().delayCentiseconds)
+	}
+
+	@Test
+	fun `never emits a zero delay`() {
+		// A zero delay leaves the frame rate up to the viewer, so a very short frame has to round up.
+		val frame = IntArray(4) { 0xFF808080.toInt() }
+		val gif = GifReader.read(encode(listOf(frame), 2, 2, delayMs = 1))
+		assertTrue(gif.frames.single().delayCentiseconds >= 1)
+	}
+
+	@Test
+	fun `survives a single pixel frame`() {
+		val gif = GifReader.read(encode(listOf(intArrayOf(0xFF123456.toInt())), 1, 1))
+		assertEquals(1, gif.frames.single().pixels.size)
+		assertEquals(0xFF123456.toInt(), gif.frames.single().pixels[0])
+	}
+
+	@Test
+	fun `handles a photographic frame without losing pixels`() {
+		// Enough pseudo-random colour to push the LZW dictionary past its first few widenings and
+		// force a code size increase, which is where a hand-written encoder tends to go wrong.
+		val width = 96
+		val height = 96
+		var seed = 12345
+		val frame = IntArray(width * height) {
+			seed = seed * 1103515245 + 12345
+			0xFF000000.toInt() or ((seed ushr 8) and 0xFFFFFF)
+		}
+
+		val decoded = GifReader.read(encode(listOf(frame), width, height, colors = 256))
+			.frames
+			.single()
+
+		assertEquals(width * height, decoded.pixels.size)
+		assertTrue("decode produced only blanks", decoded.pixels.toSet().size > 1)
+	}
+}
diff --git a/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifReader.kt b/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifReader.kt
new file mode 100644
index 0000000..eb8771f
--- /dev/null
+++ b/app/src/test/java/com/fredhappyface/ewesticker/utilities/GifReader.kt
@@ -0,0 +1,191 @@
+package com.fredhappyface.ewesticker.utilities
+
+/**
+ * A minimal GIF reader, for asserting in tests that what GifEncoder wrote is what a decoder sees.
+ *
+ * Android unit tests compile against android.jar, which has no javax.imageio, so there is no stock
+ * decoder available to check against. Reading the format back by hand is the alternative, and it has
+ * the advantage of failing loudly on exactly the structural mistakes a hand-written encoder makes.
+ *
+ * @property width Int canvas width from the logical screen descriptor
+ * @property height Int canvas height from the logical screen descriptor
+ * @property frames List<Frame> every image in the file, in order
+ */
+class GifReader private constructor(
+	val width: Int,
+	val height: Int,
+	val frames: List<Frame>,
+) {
+	/**
+	 * @property pixels IntArray ARGB pixels, transparent entries being fully zero
+	 * @property delayCentiseconds Int delay declared for this frame
+	 * @property paletteSize Int number of entries in the colour table this frame used
+	 */
+	class Frame(
+		val width: Int,
+		val height: Int,
+		val pixels: IntArray,
+		val delayCentiseconds: Int,
+		val paletteSize: Int,
+	)
+
+	companion object {
+		fun read(bytes: ByteArray): GifReader {
+			require(String(bytes, 0, 6, Charsets.US_ASCII) == "GIF89a") { "not a GIF89a file" }
+			var pos = 6
+			val width = readShort(bytes, pos)
+			val height = readShort(bytes, pos + 2)
+			val screenPacked = bytes[pos + 4].toInt() and 0xFF
+			pos += 7
+			require(screenPacked and 0x80 == 0) { "these tests expect no global colour table" }
+
+			val frames = mutableListOf<Frame>()
+			var delay = 0
+			var transparentIndex = -1
+
+			while (pos < bytes.size) {
+				when (bytes[pos].toInt() and 0xFF) {
+					0x3B -> return GifReader(width, height, frames)
+
+					0x21 -> {
+						val label = bytes[pos + 1].toInt() and 0xFF
+						pos += 2
+						if (label == 0xF9) {
+							val size = bytes[pos].toInt() and 0xFF
+							val packed = bytes[pos + 1].toInt() and 0xFF
+							delay = readShort(bytes, pos + 2)
+							transparentIndex =
+								if (packed and 0x01 != 0) bytes[pos + 4].toInt() and 0xFF else -1
+							pos += 1 + size
+						}
+						pos = skipBlocks(bytes, pos)
+					}
+
+					0x2C -> {
+						val frameWidth = readShort(bytes, pos + 5)
+						val frameHeight = readShort(bytes, pos + 7)
+						val packed = bytes[pos + 9].toInt() and 0xFF
+						pos += 10
+						require(packed and 0x80 != 0) { "expected a local colour table" }
+						val paletteSize = 1 shl ((packed and 0x07) + 1)
+						val palette = IntArray(paletteSize) {
+							val at = pos + it * 3
+							((bytes[at].toInt() and 0xFF) shl 16) or
+								((bytes[at + 1].toInt() and 0xFF) shl 8) or
+								(bytes[at + 2].toInt() and 0xFF)
+						}
+						pos += paletteSize * 3
+
+						val minCodeSize = bytes[pos].toInt() and 0xFF
+						pos++
+						val data = mutableListOf<Byte>()
+						while (true) {
+							val length = bytes[pos].toInt() and 0xFF
+							pos++
+							if (length == 0) {
+								break
+							}
+							for (i in 0 until length) {
+								data.add(bytes[pos + i])
+							}
+							pos += length
+						}
+
+						val indices = inflate(data.toByteArray(), minCodeSize, frameWidth * frameHeight)
+						val pixels = IntArray(indices.size) {
+							val index = indices[it]
+							if (index == transparentIndex) {
+								0
+							} else {
+								0xFF000000.toInt() or palette[index]
+							}
+						}
+						frames.add(Frame(frameWidth, frameHeight, pixels, delay, paletteSize))
+					}
+
+					else -> throw IllegalStateException(
+						"unexpected block 0x${(bytes[pos].toInt() and 0xFF).toString(16)} at $pos",
+					)
+				}
+			}
+			throw IllegalStateException("file ended without a trailer")
+		}
+
+		private fun skipBlocks(bytes: ByteArray, start: Int): Int {
+			var pos = start
+			while (true) {
+				val length = bytes[pos].toInt() and 0xFF
+				pos++
+				if (length == 0) {
+					return pos
+				}
+				pos += length
+			}
+		}
+
+		/** Standard GIF LZW decode, the inverse of what GifEncoder emits */
+		private fun inflate(data: ByteArray, minCodeSize: Int, expected: Int): IntArray {
+			val clearCode = 1 shl minCodeSize
+			val endCode = clearCode + 1
+			val table = arrayOfNulls<IntArray>(4096)
+			for (i in 0 until clearCode) {
+				table[i] = intArrayOf(i)
+			}
+
+			var codeSize = minCodeSize + 1
+			var next = endCode + 1
+			var previous: IntArray? = null
+			val out = IntArray(expected)
+			var written = 0
+			var bitPos = 0
+
+			while (written < expected) {
+				var code = 0
+				var readable = true
+				for (bit in 0 until codeSize) {
+					val index = bitPos + bit
+					if (index / 8 >= data.size) {
+						readable = false
+						break
+					}
+					code = code or (((data[index / 8].toInt() shr (index % 8)) and 1) shl bit)
+				}
+				if (!readable || code == endCode) {
+					break
+				}
+				bitPos += codeSize
+
+				if (code == clearCode) {
+					codeSize = minCodeSize + 1
+					next = endCode + 1
+					previous = null
+					continue
+				}
+
+				val known = table[code]
+				// A code can legally refer to the entry it is about to define, which always means
+				// "the previous sequence plus its own first symbol".
+				val entry = known ?: previous?.let { it + it[0] } ?: break
+				for (value in entry) {
+					if (written < expected) {
+						out[written++] = value
+					}
+				}
+				previous?.let {
+					if (next < 4096) {
+						table[next] = it + entry[0]
+						next++
+						if (next > (1 shl codeSize) - 1 && codeSize < 12) {
+							codeSize++
+						}
+					}
+				}
+				previous = entry
+			}
+			return out
+		}
+
+		private fun readShort(bytes: ByteArray, at: Int): Int =
+			(bytes[at].toInt() and 0xFF) or ((bytes[at + 1].toInt() and 0xFF) shl 8)
+	}
+}
diff --git a/app/src/test/java/com/fredhappyface/ewesticker/utilities/ImageResamplerTest.kt b/app/src/test/java/com/fredhappyface/ewesticker/utilities/ImageResamplerTest.kt
new file mode 100644
index 0000000..7e9d03a
--- /dev/null
+++ b/app/src/test/java/com/fredhappyface/ewesticker/utilities/ImageResamplerTest.kt
@@ -0,0 +1,80 @@
+package com.fredhappyface.ewesticker.utilities
+
+import kotlin.math.abs
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ImageResamplerTest {
+	private fun solid(width: Int, height: Int, argb: Int) = IntArray(width * height) { argb }
+
+	@Test
+	fun `returns the source untouched when nothing changes`() {
+		val source = solid(4, 4, 0xFF102030.toInt())
+		val result = ImageResampler.resize(source, 4, 4, 4, 4)
+		assertEquals(source.toList(), result.toList())
+	}
+
+	@Test
+	fun `produces the requested dimensions`() {
+		val result = ImageResampler.resize(solid(512, 512, 0xFF808080.toInt()), 512, 512, 320, 200)
+		assertEquals(320 * 200, result.size)
+	}
+
+	@Test
+	fun `preserves a flat colour through a downscale`() {
+		// Lanczos has negative lobes, so a uniform image is the case that catches a normalisation
+		// bug: the weights must sum to one or flat colour drifts or overshoots.
+		val colour = 0xFF3C7A28.toInt()
+		val result = ImageResampler.resize(solid(512, 512, colour), 512, 512, 320, 320)
+		result.forEach { assertEquals(colour, it) }
+	}
+
+	@Test
+	fun `keeps fully transparent input transparent`() {
+		val result = ImageResampler.resize(solid(64, 64, 0), 64, 64, 32, 32)
+		result.forEach { assertEquals(0, it) }
+	}
+
+	@Test
+	fun `does not bleed colour out of transparent pixels`() {
+		// Half opaque red, half fully transparent but carrying blue in its unused colour channels.
+		// Premultiplying means that hidden blue must not tint the opaque side.
+		val width = 32
+		val height = 8
+		val source = IntArray(width * height) { index ->
+			if (index % width < width / 2) 0xFFFF0000.toInt() else 0x000000FF
+		}
+		val result = ImageResampler.resize(source, width, height, width / 2, height / 2)
+
+		val leftEdge = result[0]
+		assertEquals(255, leftEdge ushr 24)
+		assertTrue("blue leaked in: ${leftEdge.toString(16)}", (leftEdge and 0xFF) < 8)
+	}
+
+	@Test
+	fun `keeps a gradient monotonic`() {
+		val size = 256
+		val source = IntArray(size * size) { index ->
+			val x = index % size
+			0xFF000000.toInt() or (x shl 16) or (x shl 8) or x
+		}
+		val result = ImageResampler.resize(source, size, size, 64, 64)
+
+		var previous = -1
+		for (x in 0 until 64) {
+			val value = result[x] and 0xFF
+			assertTrue("value went backwards at $x", value >= previous - 1)
+			previous = value
+		}
+		// Ends should still span most of the original range rather than being washed out.
+		assertTrue(abs((result[63] and 0xFF) - (result[0] and 0xFF)) > 200)
+	}
+
+	@Test
+	fun `handles upscaling`() {
+		val result = ImageResampler.resize(solid(8, 8, 0xFF204060.toInt()), 8, 8, 24, 24)
+		assertEquals(24 * 24, result.size)
+		result.forEach { assertEquals(0xFF204060.toInt(), it) }
+	}
+}
diff --git a/docs/code-map.md b/docs/code-map.md
new file mode 100644
index 0000000..5631743
--- /dev/null
+++ b/docs/code-map.md
@@ -0,0 +1,116 @@
+# Code map
+
+File → responsibility. Read this before grepping; scope edits to the files named here.
+
+Upstream is [FredHappyface/Android.EweSticker](https://github.com/FredHappyface/Android.EweSticker).
+This is a personal fork; everything marked **(fork)** does not exist upstream.
+
+## Entry points
+
+| File | Responsibility |
+|---|---|
+| `ImageKeyboard.kt` | The `InputMethodService`. Owns the keyboard view, pack bar, search, preview, gestures, drag-to-resize height, and the reload-on-change mechanism **(fork)**. The biggest file; most keyboard behaviour lives here. |
+| `MainActivity.kt` | Settings screen. Directory picking, import triggers, the Library card **(fork)**, option toggles, log export. |
+
+## Sending a sticker
+
+| File | Responsibility |
+|---|---|
+| `utilities/StickerSender.kt` | Decides *what file* to send and *under which mimetype*, then commits it. Holds the fallback ladder and the on-demand GIF conversion **(fork)**. See `docs/sending.md`. |
+| `utilities/Utils.kt` | Mimetype from file extension, and the list of formats the app accepts on import. |
+| `utilities/Cache.kt` | Fixed-capacity ordered set, persisted to prefs. Two instances: recents, and converted PNG fallbacks. |
+| `utilities/StickerKeySet.kt` | **(fork)** A named set of stickers held as relative `pack/filename` keys so it survives a re-import. Backs favourites; `resolve()` prunes keys whose files are gone. |
+| `res/xml/file_paths.xml` | `FileProvider` roots. Both `stickers/` and `variants/` **(fork)** must be listed or committing throws. |
+
+## Importing
+
+| File | Responsibility |
+|---|---|
+| `utilities/StickerImporter.kt` | Plans and performs the import. Incremental and non-destructive **(fork)**. See `docs/import.md`. |
+| `utilities/SourceListing.kt` | **(fork)** Walks the SAF tree with one cursor per directory, yielding name/mime/size/mtime, and reports whether the walk was complete. |
+| `utilities/ImportManifest.kt` | **(fork)** Persisted record of what was copied, so the next import can tell changed from unchanged. |
+| `utilities/LibraryScanner.kt` | **(fork)** Measures the imported library for the Library card, and deletes generated GIFs. |
+
+Deleting a single sticker lives in `ImageKeyboard.removeEverywhere`, with the source-side work in
+`SourceListing.removeDocument` and `SourceListing.deletePackIfEmpty`. See "Deleting" in
+`docs/import.md` — it is the only code that removes files from the user's own storage.
+
+## GIF generation
+
+See `docs/gif-pipeline.md` for how these fit together and the quality numbers.
+
+| File | Responsibility |
+|---|---|
+| `utilities/GifVariantGenerator.kt` | **(fork)** Orchestrates webp → GIF conversion across cores; one conversion per sticker, temp file then rename. |
+| `utilities/WebpAnimation.kt` | **(fork)** Demuxes an animated webp by hand and hands over composited frames. Also `isAnimated`, the cheap animation probe used all over. |
+| `utilities/GifEncoder.kt` | **(fork)** GIF89a writer: median cut, Floyd–Steinberg dithering, LZW. No Android dependencies, so it is unit-testable on the JVM. |
+| `utilities/ImageResampler.kt` | **(fork)** Lanczos-3 resize on ARGB. Exists because `Bitmap.createScaledBitmap` only does bilinear, which loses against the desktop reference. |
+| `tools/gif-variants.py` | **(fork)** Desktop reference implementation and the quality benchmark the on-device encoder is measured against. |
+
+## Keyboard view
+
+| File | Responsibility |
+|---|---|
+| `adapter/AllPacksAdapter.kt` | **(fork)** Every pack in one scrollable list with a heading per pack. |
+| `adapter/StickerPackAdapter.kt` | A single pack, or search results. |
+| `adapter/StickerBinding.kt` | **(fork)** Shared sticker cell binding, so the two adapters cannot drift apart. |
+| `view/StickerPackViewHolder.kt`, `view/PackHeaderViewHolder.kt` | Cell and heading holders. |
+| `model/StickerPack.kt` | A pack directory: its stickers and its thumbnail. |
+| `res/layout/keyboard_layout.xml` | Drag handle (`resizeHandle`), then the pack bar (`topHScrollView` + `packsList`), above a `packContent` container that everything else is swapped into. |
+| `res/drawable/resize_grabber.xml` | **(fork)** The grab indicator inside the resize handle. Uses the `outline` role so it reads as chrome, not as something tappable. |
+| `res/layout/pack_header.xml` | **(fork)** Divider and pack name inside the combined list. |
+| `res/layout/sticker_card.xml` | One cell. Shared by the grid, the search strip and the pack bar, so a change here shows up in all three. |
+| `res/layout/sticker_preview.xml` | **(fork)** The long-press surface: delete and star controls, the enlarged sticker, and a scrim behind it. |
+
+### Theming **(fork)**
+
+| File | Responsibility |
+|---|---|
+| `res/values-v31/`, `res/values-night-v31/` | Material You. Maps `bg`/`fg`/`accent` and the surface roles onto the `system_neutral*`/`system_accent*` palette, so the keyboard follows the wallpaper on Android 12+. The files in `values/` are the pre-31 fallback. |
+| `res/drawable/pack_selected.xml` | The filled container behind the selected pack icon. Selection used to be a colour filter over the sticker artwork, which recoloured the image. |
+| `res/drawable/sticker_ripple.xml` | Rounded ripple used by every tappable sticker and preview control. |
+| `res/drawable/preview_surface.xml` | Rounded surface behind the long-press preview. |
+
+Colour roles beyond `bg`/`fg`/`accent`: `surface_bar` (the pack bar), `selection_container`,
+`outline` (dividers), `ripple`, `scrim`. Add new roles in all four value directories or the v31
+variant silently falls back.
+
+## Support
+
+| File | Responsibility |
+|---|---|
+| `utilities/Toaster.kt` | Toast wrapper; also queues messages the importer emits. |
+| `utilities/StartLogger.kt` | xlog setup. Logs go to `filesDir/logs/<date>`; `adb logcat -s EweSticker` is the fastest way to watch. |
+| `utilities/StickerClickListener.kt` | Callback interface the keyboard implements. |
+
+## Tests
+
+JVM unit tests only — `./gradlew testDebugUnitTest`. They cover the pieces with no Android
+dependencies, which is deliberately where the fiddly byte-level code lives.
+
+| File | Responsibility |
+|---|---|
+| `test/utilities/GifEncoderTest.kt` | Encoder round trips, transparency, palette budget, delays. |
+| `test/utilities/GifReader.kt` | A minimal GIF decoder used only by the tests, because `javax.imageio` is not on the Android unit-test classpath. |
+| `test/utilities/ImageResamplerTest.kt` | Flat colour, alpha bleed, gradients, up/downscale. |
+
+**Do not run `connectedAndroidTest`.** It uninstalls the app when it finishes, taking the imported
+library, the generated GIFs and every preference with it. There is an upstream `ScreenshotTest` in
+`androidTest/` that will do this if invoked.
+
+## Storage layout
+
+```
+filesDir/
+  stickers/<pack>/<name>.webp     imported stickers, what the grid shows
+  stickers/__compatSticker__/     cached PNG fallbacks (never pruned as a pack)
+  variants/<pack>/<name>.gif      GIF versions, generated or imported
+  import-manifest.tsv             what the last import copied (fork)
+  logs/<date>                     xlog output
+```
+
+Preferences live in two files: `backup_prefs` (options, the `favourites` set, and the
+`libraryVersion` counter) and the default preferences (sticker directory, caches, `activePack`).
+
+Nothing in app storage is irreplaceable *except* `variants/`: a generated GIF has no counterpart in
+the sticker folder, so anything that deletes it must be able to regenerate it or must not run.
diff --git a/docs/gif-pipeline.md b/docs/gif-pipeline.md
new file mode 100644
index 0000000..5b983f9
--- /dev/null
+++ b/docs/gif-pipeline.md
@@ -0,0 +1,99 @@
+# The webp → GIF pipeline
+
+Apps that advertise `image/gif` but no webp mimetype — Instagram, Teams — can only show an animated
+sticker if it is handed to them as a GIF. Android provides neither half of that conversion: nothing
+in the public SDK yields individual frames of an animated webp (`ImageDecoder` gives you an
+`AnimatedImageDrawable` you can only play), and there is no GIF encoder at all.
+
+So both halves are implemented here. `tools/gif-variants.py` is the desktop reference and the
+quality bar; the on-device path is measured against it.
+
+## Decoding — `WebpAnimation.kt`
+
+Rather than bundling a second copy of libwebp (Fresco's `animated-webp` pulls its entire image
+pipeline in beside Coil, ~3MB), this walks the webp RIFF container directly and re-wraps each `ANMF`
+frame as a standalone one-image webp, which `BitmapFactory` decodes with the platform's own decoder.
+
+Frames are then composited onto a canvas honouring the container's blend and disposal flags.
+
+**Verified byte-exact**: re-muxed frame 0 of a real sticker decoded to a total absolute difference of
+**0** against the reference decoder.
+
+`isAnimated()` is the cheap probe used throughout. It walks chunk headers with `RandomAccessFile`,
+seeking past payloads. It previously searched a fixed 64-byte prefix for `ANIM`, which is wrong: an
+ICC profile between `VP8X` and `ANIM` pushes the marker out of the window, and the sticker is then
+silently treated as still.
+
+## Encoding — `GifEncoder.kt`
+
+GIF89a, no Android dependencies (hence unit-testable on the JVM):
+
+- **Median cut** per frame, then **Floyd–Steinberg** dithering — deliberately the same pairing Pillow
+  uses in the reference, so output stays comparable.
+- **Local colour table per frame**, since a palette chosen for the whole animation wastes entries.
+- **LZW** with the standard clear/EOI handling.
+
+### Two mistakes worth remembering
+
+**The LZW code-width off-by-one.** A decoder learns each dictionary entry one code *later* than the
+encoder creates it, so its table lags by one. Widening the code width when the encoder's own counter
+reaches the ceiling starts emitting wider codes one code before the decoder starts reading them, and
+the whole stream desynchronises. Every GIF the first version produced was undecodable. The condition
+is `nextCode > (1 shl codeSize)`, not `>= `.
+
+**The palette lookup cache.** Caching nearest-colour results on a 5-bits-per-channel key was ~4×
+faster but cost **1.3 dB**, because rounding the query throws away exactly the small differences
+dithering works in. Removed; the scan is exhaustive on purpose.
+
+### The sort that dominated everything
+
+`sortByChannel` was an insertion sort, justified by a comment claiming boxes are small. That is wrong
+for the first split, which covers *every distinct colour in the frame* — around 6,100 for a
+photographic sticker. Replaced with a counting sort over the 8-bit key.
+
+Both sorts are stable, so the box boundaries and resulting palette are identical. Measured on the
+same input:
+
+| | Time | Output |
+|---|---|---|
+| Insertion sort | 12,256 ms | 2,060,088 bytes |
+| Counting sort | 1,397 ms | 2,060,088 bytes |
+
+**Byte-identical**, ~10× faster. On device, regenerating all 53 animated stickers went from **247s to
+32s**.
+
+## Resampling — `ImageResampler.kt`
+
+Separable Lanczos-3 on ARGB, premultiplied so colour cannot bleed out of transparent pixels.
+`Bitmap.createScaledBitmap` only offers bilinear, which is too few taps to shrink cleanly and lands
+visibly short of the reference.
+
+## Quality against the reference
+
+Same sticker, 39 frames, 320px, PSNR measured against identical ground-truth frames:
+
+| | Size | PSNR |
+|---|---|---|
+| Desktop Pillow (the reference) | 1899 KB | 36.48 dB |
+| On-device, full pipeline | 2015 KB | 36.35 dB |
+| On-device, encoder only | 2011 KB | 36.37 dB |
+
+0.13 dB and 6% size apart — parity. That the full pipeline (36.35) matches encoder-only on
+Pillow-resized frames (36.37) shows the Lanczos resampler is effectively identical to Pillow's.
+
+## Settings
+
+`MAX_EDGE = 320`, `COLORS = 128`, matching the reference defaults. Full 512px is over 4MB per
+sticker, too heavy to send. These are compile-time constants; exposing them was considered and
+rejected as knob-adding whose only feedback loop is re-running a multi-minute conversion.
+
+## Conversion happens in two places
+
+- **At import**, for everything missing a variant, behind the "Make GIF versions" preference.
+- **At send time**, for one sticker, when a GIF-only app needs one that does not exist yet. Only
+  stickers actually sent get converted this way.
+
+Both go through `GifVariantGenerator.convert`, which writes a uniquely-named temp file and renames.
+A fixed `.part` name was unsafe once both paths existed: two conversions of the same sticker opened
+the same file, the second truncating what the first had written, and the first then renamed a
+NUL-holed GIF into place and sent it.
diff --git a/docs/import.md b/docs/import.md
new file mode 100644
index 0000000..a61d07c
--- /dev/null
+++ b/docs/import.md
@@ -0,0 +1,122 @@
+# Importing
+
+The importer copies a user-chosen SAF directory into app storage. Upstream it deleted both trees,
+re-copied everything, and regenerated every GIF; adding one pack cost a full rebuild and the keyboard
+was empty throughout. It is now incremental and non-destructive.
+
+Measured on a 358-sticker library with 53 animated stickers:
+
+| | Before | After |
+|---|---|---|
+| Reload, nothing changed | 32 s | ~0.3 s |
+| Add one 3-file pack | 358 files + 53 GIFs | 3 files |
+
+## The sequence
+
+1. **List** the tree with one `contentResolver.query` per directory, projecting document id, name,
+   mime, size and last-modified (`SourceListing`). `DocumentFile` caches nothing — every
+   `name`/`type`/`isFile` is its own Binder round trip, so the old walk cost thousands of them and
+   still did not yield the metadata an incremental import needs.
+2. **Full rebuild only**, delete the trees — *after* the listing has succeeded, never before.
+3. **Plan** sequentially: reject unsupported mimes, classify variants, enforce the per-pack cap. All
+   in one pass so the concurrent stage has no shared state to mutate.
+4. **Adopt** destinations already holding exactly the source's byte count into the manifest, so a
+   first run after upgrading costs nothing rather than a full re-copy.
+5. **Copy** what changed, eight at a time, into a temp file then rename.
+6. **Prune** what the source no longer has.
+7. **Save the manifest**, under `NonCancellable`, and forget entries the source no longer offers so
+   it cannot grow forever.
+8. **Generate** missing GIF versions, if enabled.
+
+## The manifest
+
+`filesDir/import-manifest.tsv`, one line per file: `pack/name<TAB>size<TAB>modified`. A file is
+up to date when its manifest entry matches the source *and* the destination is present at the same
+length.
+
+A provider reporting `0` for size or mtime is treated as **unknown**, never as a matching value —
+otherwise such files look unchanged forever.
+
+## Pruning is the dangerous part
+
+Deleting is the only thing here that can lose data that no source can restore: the generated GIFs
+have no counterpart in the sticker folder. Three guards:
+
+- **An incomplete listing never prunes.** `SourceListing` reports whether every directory could be
+  read. One unreadable directory is indistinguishable from the user having deleted that whole pack.
+- **A listing accounting for under half of what is imported never prunes.** Catches a stale grant or
+  an empty cursor, and points the user at Full re-import.
+- **Variants are judged differently from stickers.** A sticker is wanted if it is in the plan. A
+  variant is dropped only when its sticker is gone, or when that sticker's content actually changed
+  *and* a generation pass will follow to replace it.
+
+### Why staleness is not decided by timestamps
+
+The obvious rule — "variant older than its sticker means stale" — is wrong, because **copying
+rewrites the destination and moves its mtime forward**. Every sticker touched by a run then looks
+newer than its variant. On a first run, where nothing has a manifest entry and everything is
+re-copied, that means *every* variant.
+
+This shipped briefly and the log shows exactly it:
+
+```
+copied 358, removed 53
+Wrote 53 / 53 GIF variant(s)
+```
+
+All 53 GIFs deleted and rebuilt, for files whose content never changed. They came back only because
+GIF generation was enabled; with it off — the default — 66MB would have been lost with nothing to
+restore it. Staleness now comes from what the manifest says actually changed.
+
+## Deleting a sticker
+
+Long-pressing a sticker offers a bin, armed by the first tap and acted on by the second — it is
+armed for four seconds and then forgets. Two taps because this is the only place in the app that
+removes files from the user's own storage.
+
+Order matters, and the source goes first:
+
+1. **The source file**, via `SourceListing.removeDocument`. That returns `REMOVED`, `ABSENT` or
+   `FAILED`, and `FAILED` aborts the whole thing — treating "I could not find out" as "it is already
+   gone" would delete the imported copy of a sticker the next import brings straight back.
+2. **The sibling `.gif`** that `tools/gif-variants.py` writes next to a webp. Leaving it behind means
+   the next import no longer sees a webp of that name, so the orphan imports as a sticker in its own
+   right and the deleted sticker reappears as a GIF.
+3. The imported copy, the generated variant, the cached PNG fallback, and its entries in favourites
+   and recents.
+4. **The pack directory**, if it just emptied — from app storage, the variants tree, and the source.
+
+Then packs are reloaded and the content view is rebuilt. That last step matters: `jumpToPack` reuses
+an already-built all-packs list and only scrolls it, which is right when the selection changed and
+wrong after a deletion — the adapter keeps a cell for a file that has gone, and it draws as a blank
+gap instead of the grid closing up.
+
+### Removing a source directory is the riskiest thing here
+
+`DocumentsContract.deleteDocument` on a directory is **recursive**. `deletePackIfEmpty` therefore
+requires four independent things to agree before it runs:
+
+- a **complete** walk of the tree,
+- **no file anywhere in it** belonging to that pack,
+- **exactly one** directory of that name, matched on `MIME_TYPE_DIR` so a *file* named like a pack
+  cannot be deleted,
+- an emptiness check **asked twice** that rejects a cursor still reporting `EXTRA_LOADING`.
+
+A single zero-row cursor is not evidence. A provider that loads children asynchronously returns an
+empty, still-loading cursor right after a delete invalidates its cache — and taking that at face
+value would destroy a pack directory and every unimported file in it.
+
+## Full re-import
+
+A separate button, because the normal path no longer rebuilds anything. It lists first, then deletes
+both trees and the manifest, then proceeds as above. Ordering matters: deleting first and *then*
+discovering the source is unreadable — an unmounted card, a grant gone stale — destroys the library
+in precisely the situation the user reached for that button because something already looked wrong.
+
+## Concurrency
+
+`MainActivity` serialises every library-mutating operation behind one guard (`runLibraryOperation`):
+import, full re-import, generate and delete. All buttons in both cards are disabled for the duration
+and restored in a `finally`. Without it, a delete could wipe the variants tree underneath a running
+generation, and returning to the screen mid-generation re-enabled the buttons so a second generator
+would convert everything twice into the same files.
diff --git a/docs/sending.md b/docs/sending.md
new file mode 100644
index 0000000..8b10fdb
--- /dev/null
+++ b/docs/sending.md
@@ -0,0 +1,67 @@
+# Sending a sticker
+
+Everything here was established by reading what apps actually advertise on a real device, not from
+documentation. `adb logcat -s EweSticker` prints the advertised list on every field focus:
+
+```
+Connecting to com.whatsapp which supports
+[image/gif, video/x.looping_mp4, image/jpeg, image/jpg, image/png, image/webp.wasticker]
+```
+
+## The mechanism
+
+A keyboard sends media through `InputConnectionCompat.commitContent`, which hands the target app a
+content URI plus a mimetype. The target app decides what that is. It will only accept mimetypes it
+declared in `EditorInfo.contentMimeTypes`.
+
+An IME **cannot** produce a WhatsApp sticker-pack sticker; that is a separate API requiring a
+`StickerContentProvider` and an "Add to WhatsApp" flow. What it can do is described below.
+
+## What the four target apps advertise
+
+| App | Advertises | Result |
+|---|---|---|
+| `com.whatsapp`, `com.whatsapp.w4b` | `image/gif`, `video/x.looping_mp4`, `image/jpeg`, `image/jpg`, `image/png`, **`image/webp.wasticker`** | A real, animated sticker |
+| `com.instagram.android` | `image/png`, `image/jpeg`, `image/gif` | GIF animates; no sticker concept |
+| `com.microsoft.teams` | `image/png`, `image/gif`, `image/jpg`, `image/jpeg` | GIF animates |
+
+**Neither WhatsApp advertises plain `image/webp`.** It exposes the proprietary
+`image/webp.wasticker` instead, and only content committed under *that* mimetype is treated as a
+sticker. Commit a webp as `image/webp` and it fails the mimetype check entirely, falling through to
+a flattened PNG or a share sheet — which is what "my animated sticker arrives as a big photo" was.
+
+Instagram is a dead end for animation despite advertising `image/gif`: it accepts the commit and
+then declines to insert it, steering the user to its own GIPHY picker. Verified — the commit returns
+success and nothing arrives. Teams does render the GIF.
+
+## The ladder in `StickerSender.resolveCommit`
+
+In order:
+
+1. **Exact match**, including wildcards. `image/*` counts as accepting the original — without this,
+   an app advertising both `image/*` and `image/gif` would be handed a downscaled 128-colour GIF
+   when it would happily have taken the full-quality webp.
+2. **A vendor `image/webp.*` mimetype**, matched by prefix rather than hardcoding `wasticker`, so
+   another app's equivalent is picked up for free.
+3. **A GIF variant**, when the target takes `image/gif` and one exists in `variants/`.
+4. **On demand conversion** — if the sticker is animated, the target takes GIF, and no variant
+   exists, convert it now (`convertVariantOnDemand`). Serialised per destination so two taps do not
+   convert twice into the same file; failures are negatively cached.
+5. **PNG fallback**, at source resolution, cached in `stickers/__compatSticker__/`. Toasts when this
+   drops animation, distinguishing "this app cannot show animation" from "no GIF version yet".
+6. **Share sheet**, scoped to the target package, carrying the original file untouched.
+
+## Traps
+
+- **`FileProvider` roots.** `res/xml/file_paths.xml` must list every tree a committed file can come
+  from. Adding `variants/` was forgotten once and `getUriForFile` threw, killing the keyboard
+  mid-send. `doCommitContent` now catches that and degrades instead of crashing.
+- **A missing file still commits successfully.** `getUriForFile` does not check existence and
+  `commitContent` reports success, so a phantom path arrives as nothing at all. This is why
+  `createCompatSticker` verifies the file is non-empty before caching or returning it.
+- **The sender outlives its field.** An on-demand conversion takes seconds, during which the user
+  can leave. `ImageKeyboard` calls `abandon()` on the outgoing sender so a late completion cannot
+  commit into a dead connection or throw a share sheet over whatever the user moved on to.
+- **Nothing heavy on the main thread.** The PNG encode used to run inside a Coil `target` callback,
+  which Coil invokes on `Main.immediate` — a full-resolution encode on the thread drawing the
+  keyboard, on every cache miss.
diff --git a/tools/gif-variants.py b/tools/gif-variants.py
new file mode 100644
index 0000000..5659f42
--- /dev/null
+++ b/tools/gif-variants.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""Generate GIF variants of animated webp stickers.
+
+WhatsApp accepts animated webp as a true sticker via its image/webp.wasticker
+mimetype, but Instagram and Teams advertise neither webp nor any sticker
+mimetype -- only image/gif. So for those apps the only way to keep a sticker
+moving is to hand them a GIF of the same artwork.
+
+This walks a sticker tree, finds the webp files that actually carry animation
+(an ANMF frame chunk), and writes a sibling <name>.gif next to each one.
+EweSticker's importer treats a .gif sitting beside a same-named .webp as a
+format variant rather than as a separate sticker, so the keyboard picks
+whichever one the target app can render. Static stickers are left alone --
+there is nothing to animate.
+
+Run it again after downloading new packs; existing variants are skipped unless
+the source is newer, so it is cheap to re-run.
+
+Usage:
+    gif-variants.py <dir>                    convert a local directory in place
+    gif-variants.py --device [SERIAL]        pull from, convert, push back to a phone
+    gif-variants.py <dir> --max-size 320     downscale to cap GIF file size
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+try:
+    from PIL import Image
+except ImportError:
+    sys.exit("Pillow is required: pip install Pillow")
+
+DEVICE_STICKER_DIR = "/sdcard/Stickers"
+# GIF stores delays in centiseconds, so sub-10ms precision is unrepresentable.
+MIN_GIF_DELAY_MS = 20
+
+
+def iter_riff_chunks(data: bytes):
+    """Yield (fourcc, payload_offset, payload_len) for each chunk in a RIFF file."""
+    if data[:4] != b"RIFF" or data[8:12] != b"WEBP":
+        return
+    pos = 12
+    end = min(len(data), 8 + int.from_bytes(data[4:8], "little"))
+    while pos + 8 <= end:
+        fourcc = data[pos : pos + 4]
+        size = int.from_bytes(data[pos + 4 : pos + 8], "little")
+        yield fourcc, pos + 8, size
+        pos += 8 + size + (size & 1)  # chunks are padded to even length
+
+
+def frame_durations(path: Path) -> list[int]:
+    """Per-frame durations in ms, read straight from the webp ANMF chunks.
+
+    An ANMF payload starts with frame x/y/width/height as 24-bit values, then a
+    24-bit duration, so the duration sits at a fixed offset of 12 bytes.
+    """
+    data = path.read_bytes()
+    durations = []
+    for fourcc, offset, _size in iter_riff_chunks(data):
+        if fourcc == b"ANMF":
+            durations.append(int.from_bytes(data[offset + 12 : offset + 15], "little"))
+    return durations
+
+
+def is_animated(path: Path) -> bool:
+    return bool(frame_durations(path))
+
+
+def quantize(frame: Image.Image, colors: int, has_alpha: bool) -> Image.Image:
+    """Convert an RGBA frame to a palettised frame GIF can store.
+
+    GIF transparency is a single palette index, so when the artwork has an alpha
+    channel one slot is reserved for it and every pixel below the halfway point
+    is snapped to fully transparent. That hard cutoff is what produces fringing
+    on soft edges; it is a limit of the format, not of this conversion.
+    """
+    if not has_alpha:
+        return frame.convert("RGB").quantize(colors=colors)
+
+    palettised = frame.convert("RGB").quantize(colors=min(colors, 255))
+    transparent = frame.getchannel("A").point(lambda a: 255 if a < 128 else 0)
+    palettised.paste(255, transparent)
+    return palettised
+
+
+def convert(src: Path, dest: Path, max_size: int, colors: int, every: int) -> tuple[int, int]:
+    """Write an animated GIF of src to dest. Returns (frame count, byte size)."""
+    durations = frame_durations(src)
+    image = Image.open(src)
+
+    frames: list[Image.Image] = []
+    kept_durations: list[int] = []
+    has_alpha = False
+    for index in range(0, getattr(image, "n_frames", 1), every):
+        image.seek(index)
+        frame = image.convert("RGBA")
+        if frame.getchannel("A").getextrema()[0] < 255:
+            has_alpha = True
+        if max(frame.size) > max_size:
+            scale = max_size / max(frame.size)
+            new_size = (round(frame.width * scale), round(frame.height * scale))
+            frame = frame.resize(new_size, Image.LANCZOS)
+        frames.append(frame)
+        # Dropped frames' time has to be absorbed by the frame that replaces them,
+        # otherwise decimating the animation also speeds it up.
+        window = durations[index : index + every]
+        kept_durations.append(sum(window) if window else 0)
+
+    palettised = [quantize(frame, colors, has_alpha) for frame in frames]
+    delays = [max(d, MIN_GIF_DELAY_MS) for d in kept_durations if d] or [100] * len(palettised)
+
+    save_options = {
+        "save_all": True,
+        "append_images": palettised[1:],
+        "duration": delays,
+        "loop": 0,
+        "disposal": 2,  # restore to background between frames
+        "optimize": False,
+    }
+    if has_alpha:
+        save_options["transparency"] = 255
+
+    palettised[0].save(dest, **save_options)
+    return len(palettised), dest.stat().st_size
+
+
+def convert_tree(root: Path, max_size: int, colors: int, every: int, force: bool) -> int:
+    converted = 0
+    skipped_static = 0
+    for src in sorted(root.rglob("*.webp")):
+        dest = src.with_suffix(".gif")
+        if not is_animated(src):
+            skipped_static += 1
+            continue
+        if dest.exists() and not force and dest.stat().st_mtime >= src.stat().st_mtime:
+            print(f"  = {src.parent.name}/{src.name} (variant up to date)")
+            continue
+        try:
+            frames, size = convert(src, dest, max_size, colors, every)
+        except Exception as exc:  # a single bad sticker should not abort the run
+            print(f"  ! {src.parent.name}/{src.name}: {exc}", file=sys.stderr)
+            continue
+        print(f"  + {src.parent.name}/{src.name} -> {frames} frames, {size // 1024}KB")
+        converted += 1
+    print(f"\n{converted} GIF variant(s) written; {skipped_static} static sticker(s) left alone.")
+    return converted
+
+
+def adb(serial: str | None, *args: str) -> str:
+    command = ["adb"]
+    if serial:
+        command += ["-s", serial]
+    result = subprocess.run(command + list(args), capture_output=True, text=True)
+    if result.returncode != 0:
+        sys.exit(f"adb {' '.join(args)} failed: {result.stderr.strip()}")
+    return result.stdout
+
+
+def run_on_device(serial: str | None, remote: str, max_size: int, colors: int,
+                  every: int, force: bool) -> None:
+    workdir = Path(tempfile.mkdtemp(prefix="gif-variants-"))
+    try:
+        print(f"Pulling {remote} ...")
+        adb(serial, "pull", remote, str(workdir / "Stickers"))
+        local = workdir / "Stickers"
+        if not local.is_dir():
+            sys.exit(f"nothing pulled from {remote}")
+
+        if not convert_tree(local, max_size, colors, every, force):
+            print("Nothing to push.")
+            return
+
+        print("\nPushing GIF variants back ...")
+        for gif in sorted(local.rglob("*.gif")):
+            target = f"{remote}/{gif.parent.name}/{gif.name}"
+            adb(serial, "push", str(gif), target)
+            print(f"  -> {target}")
+        print("\nDone. Re-import your sticker folder in EweSticker to pick these up.")
+    finally:
+        shutil.rmtree(workdir, ignore_errors=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("directory", nargs="?", type=Path, help="local sticker tree to convert")
+    parser.add_argument("--device", nargs="?", const="", metavar="SERIAL",
+                        help="operate on a connected phone over adb")
+    parser.add_argument("--remote", default=DEVICE_STICKER_DIR,
+                        help=f"sticker directory on the phone (default: {DEVICE_STICKER_DIR})")
+    # GIF is far bulkier than webp for the same artwork, so the defaults trade a
+    # little fidelity for a file size that is sane to send in a chat: a 512px
+    # 39-frame sticker is 4.6MB at full size and 1.9MB at these settings.
+    parser.add_argument("--max-size", type=int, default=320,
+                        help="cap the longest edge, downscaling to shrink the GIF (default: 320)")
+    parser.add_argument("--colors", type=int, default=128,
+                        help="palette size per frame, 2-256 (default: 128)")
+    parser.add_argument("--every", type=int, default=1, metavar="N",
+                        help="keep only every Nth frame; 2 roughly halves the size (default: 1)")
+    parser.add_argument("--force", action="store_true", help="rewrite variants that already exist")
+    args = parser.parse_args()
+
+    if not 2 <= args.colors <= 256:
+        parser.error("--colors must be between 2 and 256")
+    if args.every < 1:
+        parser.error("--every must be 1 or greater")
+
+    if args.device is not None:
+        run_on_device(args.device or None, args.remote.rstrip("/"), args.max_size,
+                      args.colors, args.every, args.force)
+    elif args.directory:
+        if not args.directory.is_dir():
+            sys.exit(f"not a directory: {args.directory}")
+        convert_tree(args.directory, args.max_size, args.colors, args.every, args.force)
+    else:
+        parser.error("pass a directory or --device")
+
+
+if __name__ == "__main__":
+    main()