diff --git a/.github/workflows/semanticemojifilter-ci.yml b/.github/workflows/semanticemojifilter-ci.yml
index b5ab3f1..4250fa8 100644
--- a/.github/workflows/semanticemojifilter-ci.yml
+++ b/.github/workflows/semanticemojifilter-ci.yml
@@ -49,7 +49,8 @@ jobs:
           key: semanticemojifilter-leaf-4262131b
 
       # Unit tests on JVM + Android (no device), the Android debug APK, and a wasm compile check;
-      # then the opt-in Laya verifier module (desktop + Android source sets, its own tests).
+      # then the opt-in Laya verifier module (desktop + Android source sets, its own tests) and
+      # its web form, the :webVerifier worker plus the app built against it.
       - name: Build and test
         working-directory: SemanticEmojiFilter
         run: |
@@ -68,4 +69,7 @@ jobs:
             :verifier:jvmTest \
             :cli:compileKotlin \
             :composeApp:compileKotlinJvm \
+            :verifier:compileKotlinWasmJs \
+            :webVerifier:compileProductionExecutableKotlinWasmJs \
+            :composeApp:compileKotlinWasmJs \
             --console=plain
diff --git a/README.md b/README.md
index 52b6bfa..47bba09 100644
--- a/README.md
+++ b/README.md
@@ -98,9 +98,10 @@ falls back to without NEON hardware.
 Type what you mean, get the emoji. Every keystroke is embedded on-device with the MongoDB LEAF
 retrieval encoder (23M parameters, BERT in the SKaiNET NN DSL) and ranked against a bilingual
 catalog of about 200 emoji; items above a calibrated threshold move up with a confidence badge.
-Desktop and Android add a second stage: the **Laya decision model** answers a typed yes/no
-question per candidate through `sk.ainet.decisions`, so 🍕 drops for "healthy things to eat"
-while 🥗 stays, and an unsure model says `?` instead of guessing.
+A second stage, the **Laya decision model**, answers a typed yes/no question per candidate
+through `sk.ainet.decisions`, so 🍕 drops for "healthy things to eat" while 🥗 stays, and an
+unsure model says `?` instead of guessing. On desktop and Android it loads from files; in the
+browser it runs in a Web Worker on the packed Q8_0 lane after a one-time opt-in download.
 
 <img src="SemanticEmojiFilter/docs/screenshots/grid.png" alt="Semantic Emoji Filter — matches above the threshold with vector and Laya confidence" width="640" />
 
diff --git a/SemanticEmojiFilter/README.md b/SemanticEmojiFilter/README.md
index cbb2218..e2cef5b 100644
--- a/SemanticEmojiFilter/README.md
+++ b/SemanticEmojiFilter/README.md
@@ -21,8 +21,9 @@ been stable for half a second, the top candidates go to the **Laya** decision mo
 search?"). The badge then shows both numbers, the vector confidence and Laya's probability; a
 candidate the model is unsure about shows `?` instead of a guess (policy: reject below 0.2,
 accept from 0.6). This stage is opt-in
-(`-PlayaVerifier=true`), Desktop and Android only, and visibly asynchronous: Laya is a 322M-parameter
-encoder run on the eager FP32 CPU path, several seconds per question on a laptop.
+(`-PlayaVerifier=true`) and visibly asynchronous: Laya is a 322M-parameter encoder, several seconds
+per question on the eager FP32 CPU path of a laptop, about a second in the browser on the packed
+Q8_0 lane with the SIMD128 sidecar (see *The Laya verifier*).
 
 **Honest numbers.** The diagnostics row shows the kernel tier, model load time and the live query
 latency; the CLI below produced the numbers in this README on the machine named there.
@@ -87,6 +88,17 @@ directories. The checkpoint (644 MB, `convaiinnovations/laya` `multilingual/`) d
 first verification into `~/.skainet-examples/semantic-emoji-filter/laya-multilingual/`
 (`LAYA_MODEL_DIR` overrides).
 
+**In the browser** the same flag adds the `:webVerifier` module: Laya runs inside a Web Worker
+(`laya-worker/` next to the app), so the page stays responsive while it loads and decides. It
+starts only when the user taps the *System 2* chip, because the first run fetches the 644 MB
+checkpoint from Hugging Face; the browser keeps it in the Cache API, so later visits read it from
+disk. The weights are quantized to Q8_0 at load (about 340 MB in memory instead of 1.3 GB of
+FP32) and served by the SIMD128 sidecar — with pthreads when the page is cross-origin isolated,
+which the examples site is. The decision quality of the Q8_0 lane is gated upstream (every choice
+of the FP32 reference agrees, probabilities within 0.05). The web and the desktop verifier share
+`LayaVerifier`, `EmojiMatchSchema` and the verdict cache; only the checkpoint source differs
+(`LayaWebSource` against `LayaFileSource`).
+
 ## Measured
 
 Laptop, 12 cores, JDK 21 with the Vector API (`Panama Vector (SIMD)` tier), SKaiNET 0.58.0,
diff --git a/SemanticEmojiFilter/composeApp/build.gradle.kts b/SemanticEmojiFilter/composeApp/build.gradle.kts
index 1f3eacd..de6bb79 100644
--- a/SemanticEmojiFilter/composeApp/build.gradle.kts
+++ b/SemanticEmojiFilter/composeApp/build.gradle.kts
@@ -32,6 +32,21 @@ val generateBuildInfo by tasks.registering {
     }
 }
 
+// With -PlayaVerifier=true the web build ships the :webVerifier worker: the raw Kotlin/Wasm
+// compiler output (an ES module plus its .wasm), copied under laya-worker/ into the wasm
+// resources so the distribution and the dev server serve it next to the app.
+val copyLayaWorker = if (layaVerifier) {
+    tasks.register<Copy>("copyLayaWorker") {
+        val worker = project(":webVerifier")
+        dependsOn(worker.tasks.named("wasmJsProductionExecutableCompileSync"))
+        from(worker.layout.buildDirectory.dir("compileSync/wasmJs/main/productionExecutable/kotlin")) {
+            exclude("*.map")
+            into("laya-worker")
+        }
+        into(layout.buildDirectory.dir("generated/layaWorker"))
+    }
+} else null
+
 kotlin {
     jvmToolchain(21)
 
@@ -80,13 +95,18 @@ kotlin {
             implementation(compose.desktop.currentOs)
             implementation(libs.kotlinx.coroutinesSwing)
         }
-        wasmJsMain.dependencies {
-            implementation(libs.kotlinx.coroutines)
-        }
         // The Laya verifier is a build-time switch: with -PlayaVerifier=true the :verifier module
-        // is on the Desktop and Android classpath and the *Verifier source dirs provide
-        // createVerifier(); without it the *NoVerifier dirs return the no-op verifier.
+        // is on the Desktop and Android classpath (the web talks to the :webVerifier worker) and
+        // the *Verifier source dirs provide createVerifier(); without it the *NoVerifier dirs
+        // return the no-op verifier.
         val verifierDir = if (layaVerifier) "Verifier" else "NoVerifier"
+        wasmJsMain {
+            dependencies {
+                implementation(libs.kotlinx.coroutines)
+            }
+            kotlin.srcDir("src/wasmJs$verifierDir/kotlin")
+            if (copyLayaWorker != null) resources.srcDir(copyLayaWorker)
+        }
         jvmMain {
             kotlin.srcDir("src/jvm$verifierDir/kotlin")
             if (layaVerifier) dependencies { implementation(project(":verifier")) }
diff --git a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/DiagnosticsRow.kt b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/DiagnosticsRow.kt
index 0be6782..d108b79 100644
--- a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/DiagnosticsRow.kt
+++ b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/DiagnosticsRow.kt
@@ -17,29 +17,30 @@ import sk.ainet.samples.emoji.vm.SearchStats
 
 /** Timings and the verifier state, so the demo shows its numbers instead of claiming them. */
 @Composable
-fun DiagnosticsRow(stats: SearchStats, verifierState: VerifierState, kernel: String) {
+fun DiagnosticsRow(stats: SearchStats, verifierState: VerifierState, kernel: String, onEnableVerifier: () -> Unit = {}) {
     Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
         AssistChip(onClick = {}, label = { Text(kernel) })
         AssistChip(onClick = {}, label = { Text("load ${stats.modelLoadMs} ms · index ${stats.indexBuildMs} ms") })
         if (stats.queries > 0) {
             AssistChip(onClick = {}, label = { Text("query ${stats.lastQueryMs} ms · p50 ${stats.p50QueryMs} ms") })
         }
-        VerifierChip(verifierState)
+        VerifierChip(verifierState, onEnableVerifier)
     }
 }
 
 @Composable
-private fun VerifierChip(state: VerifierState) {
+private fun VerifierChip(state: VerifierState, onEnable: () -> Unit) {
     val label = when (state) {
         is VerifierState.Disabled -> "System 2: off (${state.reason})"
+        is VerifierState.OptIn -> "System 2: ${state.message}"
         VerifierState.Idle -> "System 2: Laya ready"
         is VerifierState.Loading -> "System 2: ${state.message}"
         is VerifierState.Busy -> "System 2: ${state.done}/${state.total}"
         is VerifierState.Error -> "System 2: error"
     }
     AssistChip(
-        onClick = {},
-        label = { Text(label, color = if (state is VerifierState.Error) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface) },
+        onClick = { if (state is VerifierState.OptIn) onEnable() },
+        label = { Text(label, color = when (state) { is VerifierState.Error -> MaterialTheme.colorScheme.error; is VerifierState.OptIn -> MaterialTheme.colorScheme.primary; else -> MaterialTheme.colorScheme.onSurface }) },
         leadingIcon = {
             if (state is VerifierState.Loading || state is VerifierState.Busy) {
                 CircularProgressIndicator(Modifier.width(14.dp).height(14.dp), strokeWidth = 2.dp)
diff --git a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/EmojiGrid.kt b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/EmojiGrid.kt
index e1dfa3c..48e4129 100644
--- a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/EmojiGrid.kt
+++ b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/EmojiGrid.kt
@@ -14,12 +14,14 @@ import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.GridItemSpan
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.lazy.grid.rememberLazyGridState
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -39,7 +41,12 @@ import sk.ainet.samples.emoji.verify.Verdict
 fun EmojiGrid(ranked: List<RankedItem>, verdicts: Map<String, Verdict>, german: Boolean, queryActive: Boolean, modifier: Modifier = Modifier) {
     val top = if (queryActive) ranked.filter { it.tier == Tier.TOP } else emptyList()
     val rest = if (queryActive) ranked.filter { it.tier == Tier.REST } else ranked
-    LazyVerticalGrid(columns = GridCells.Adaptive(minSize = 112.dp), modifier = modifier, verticalArrangement = Arrangement.spacedBy(8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+    // A new ranking starts at the top. The grid keys its cards by item id and would otherwise keep
+    // the first visible card anchored: 🥗 leads the unranked catalog, and for a query that sends it
+    // to rank 70 the grid followed it down and hid the matches.
+    val state = rememberLazyGridState()
+    LaunchedEffect(ranked) { state.scrollToItem(0) }
+    LazyVerticalGrid(columns = GridCells.Adaptive(minSize = 112.dp), state = state, modifier = modifier, verticalArrangement = Arrangement.spacedBy(8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
         if (queryActive) {
             item(span = { GridItemSpan(maxLineSpan) }) {
                 SectionLabel(if (german) "Treffer (${top.size})" else "Matches (${top.size})")
diff --git a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/SearchScreen.kt b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/SearchScreen.kt
index 38ff96e..3a4479b 100644
--- a/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/SearchScreen.kt
+++ b/SemanticEmojiFilter/composeApp/src/commonMain/kotlin/sk/ainet/samples/emoji/ui/SearchScreen.kt
@@ -69,7 +69,7 @@ fun SearchScreen(viewModel: EmojiSearchViewModel, skainetVersion: String) {
                 }
                 is LoadState.Failed -> Text("Model failed to load: ${s.message}", color = MaterialTheme.colorScheme.error)
                 LoadState.Ready -> {
-                    DiagnosticsRow(stats = stats, verifierState = verifierState, kernel = kernelTierLabel())
+                    DiagnosticsRow(stats = stats, verifierState = verifierState, kernel = kernelTierLabel(), onEnableVerifier = viewModel.verifier::enable)
                     Spacer(Modifier.height(8.dp))
                     EmojiGrid(ranked = ranked, verdicts = verdicts, german = german, queryActive = query.isNotBlank(), modifier = Modifier.fillMaxSize())
                 }
diff --git a/SemanticEmojiFilter/composeApp/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/main.kt b/SemanticEmojiFilter/composeApp/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/main.kt
index 196cc2f..027fcf7 100644
--- a/SemanticEmojiFilter/composeApp/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/main.kt
+++ b/SemanticEmojiFilter/composeApp/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/main.kt
@@ -55,7 +55,7 @@ fun main() {
                 },
                 loadIndex = { engine, onProgress -> CatalogResources.index(CatalogResources.catalog(), engine, onProgress = onProgress) },
                 calibration = loadedCalibration,
-                verifierTopK = 0,
+                verifier = createVerifier(),
             )
         }
         CompositionLocalProvider(LocalEmojiFontFamily provides emojiFont) {
diff --git a/SemanticEmojiFilter/composeApp/src/wasmJsMain/resources/index.html b/SemanticEmojiFilter/composeApp/src/wasmJsMain/resources/index.html
index 0a91300..7970fb1 100644
--- a/SemanticEmojiFilter/composeApp/src/wasmJsMain/resources/index.html
+++ b/SemanticEmojiFilter/composeApp/src/wasmJsMain/resources/index.html
@@ -204,7 +204,7 @@
 
   <footer class="footer">
     MIT License &middot; SKaiNET-developers &middot;
-    ~92 MB encoder download on first load (MongoDB LEAF, Apache-2.0) — the Laya decision model (second stage) runs on Desktop and Android only.
+    ~92 MB encoder download on first load (MongoDB LEAF, Apache-2.0) — the Laya decision model (second stage, Apache-2.0) is opt-in: tap "System 2" for a one-time 644 MB download, cached by the browser.
   </footer>
 
   <script>
diff --git a/SemanticEmojiFilter/composeApp/src/wasmJsNoVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt b/SemanticEmojiFilter/composeApp/src/wasmJsNoVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt
new file mode 100644
index 0000000..1c99b8a
--- /dev/null
+++ b/SemanticEmojiFilter/composeApp/src/wasmJsNoVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt
@@ -0,0 +1,7 @@
+package sk.ainet.samples.emoji
+
+import sk.ainet.samples.emoji.verify.NoopVerifier
+import sk.ainet.samples.emoji.verify.Verifier
+
+/** Built without `-PlayaVerifier=true`: the second stage is off. */
+fun createVerifier(): Verifier = NoopVerifier("build with -PlayaVerifier=true")
diff --git a/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt b/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt
new file mode 100644
index 0000000..c3200e3
--- /dev/null
+++ b/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/VerifierFactory.kt
@@ -0,0 +1,10 @@
+package sk.ainet.samples.emoji
+
+import sk.ainet.samples.emoji.verify.Verifier
+
+/**
+ * Built with `-PlayaVerifier=true`: Laya runs in a Web Worker (the :webVerifier module, shipped
+ * under laya-worker/ next to the app). It starts only when the user taps the System 2 chip,
+ * because the first run downloads the 644 MB checkpoint into the browser cache.
+ */
+fun createVerifier(): Verifier = WorkerLayaVerifier("./laya-worker/SemanticEmojiFilter-webVerifier.mjs")
diff --git a/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/WorkerLayaVerifier.kt b/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/WorkerLayaVerifier.kt
new file mode 100644
index 0000000..800ea54
--- /dev/null
+++ b/SemanticEmojiFilter/composeApp/src/wasmJsVerifier/kotlin/sk/ainet/samples/emoji/WorkerLayaVerifier.kt
@@ -0,0 +1,127 @@
+@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
+
+package sk.ainet.samples.emoji
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import sk.ainet.samples.emoji.domain.CatalogItem
+import sk.ainet.samples.emoji.platform.logEvent
+import sk.ainet.samples.emoji.verify.DecideRequest
+import sk.ainet.samples.emoji.verify.Verdict
+import sk.ainet.samples.emoji.verify.Verifier
+import sk.ainet.samples.emoji.verify.VerifierState
+import sk.ainet.samples.emoji.verify.WorkerProtocol
+
+@JsFun("(url) => new Worker(url, { type: 'module' })")
+private external fun createModuleWorker(url: String): JsAny
+
+@JsFun("(worker, msg) => worker.postMessage(msg)")
+private external fun workerPostMessage(worker: JsAny, msg: String)
+
+@JsFun("(worker, onMessage, onError) => { worker.onmessage = (e) => onMessage(e.data); worker.onerror = (e) => onError(String(e && e.message ? e.message : e)); }")
+private external fun installWorkerHandlers(worker: JsAny, onMessage: (String) -> Unit, onError: (String) -> Unit)
+
+/**
+ * The page's side of the Laya Web Worker: the [Verifier] the view model drives, with the model
+ * itself in the worker (see `webVerifier/.../Main.kt` and [WorkerProtocol]). Verdicts are cached by
+ * (query, item) like the in-process verifier's; one request is in flight at a time, and a verdict
+ * for a request the flow has abandoned (the query changed) is dropped by its id.
+ */
+class WorkerLayaVerifier(private val workerUrl: String, private val cacheSize: Int = 256) : Verifier {
+    private val _state = MutableStateFlow<VerifierState>(VerifierState.OptIn("tap to load Laya (644 MB, runs in a Web Worker)"))
+    override val state: StateFlow<VerifierState> = _state
+
+    private val enabled = CompletableDeferred<Unit>()
+    private var loaded: CompletableDeferred<Unit>? = null
+    private var worker: JsAny? = null
+    private var nextId = 0
+    private var pending: Pair<Int, CompletableDeferred<Verdict>>? = null
+    private val oneAtATime = Mutex()
+    private val cache = LinkedHashMap<String, Verdict>()
+
+    override fun enable() {
+        if (enabled.isCompleted) return
+        _state.value = VerifierState.Loading("starting the Laya worker…")
+        val ready = CompletableDeferred<Unit>()
+        loaded = ready
+        val w = createModuleWorker(workerUrl)
+        worker = w
+        installWorkerHandlers(w, ::onMessage) { message ->
+            logEvent("verifier_worker_error", "error" to message)
+            _state.value = VerifierState.Error(message)
+            ready.completeExceptionally(RuntimeException(message))
+            pending?.second?.completeExceptionally(RuntimeException(message))
+        }
+        workerPostMessage(w, WorkerProtocol.LOAD)
+        enabled.complete(Unit)
+    }
+
+    private fun onMessage(raw: String) {
+        when {
+            raw == WorkerProtocol.READY -> {
+                logEvent("verifier_ready", "worker" to workerUrl)
+                _state.value = VerifierState.Idle
+                loaded?.complete(Unit)
+            }
+            raw.startsWith("STATE:") -> WorkerProtocol.parseState(raw)?.let {
+                logEvent("verifier_state", "state" to it)
+                _state.value = it
+            }
+            raw.startsWith("VERDICT:") -> WorkerProtocol.parseVerdict(raw)?.let { (id, verdict) ->
+                val p = pending
+                logEvent("verifier_verdict", "item" to verdict.itemId, "pTrue" to verdict.probabilityTrue, "accepted" to verdict.accepted, "ms" to verdict.millis, "stale" to (p == null || p.first != id))
+                if (p != null && p.first == id) p.second.complete(verdict)
+            }
+            raw.startsWith("ERROR:") -> WorkerProtocol.parseError(raw)?.let { (id, message) ->
+                _state.value = VerifierState.Error(message)
+                if (id == null) loaded?.completeExceptionally(RuntimeException(message))
+                else pending?.takeIf { it.first == id }?.second?.completeExceptionally(RuntimeException(message))
+            }
+        }
+    }
+
+    override fun verify(query: String, items: List<CatalogItem>): Flow<Verdict> = flow {
+        if (items.isEmpty()) return@flow
+        enabled.await()
+        try {
+            loaded?.await()
+        } catch (t: Throwable) {
+            return@flow
+        }
+        val w = worker ?: return@flow
+        try {
+            items.forEachIndexed { index, item ->
+                _state.value = VerifierState.Busy(index, items.size)
+                val key = "$query\u0000${item.id}"
+                val verdict = cache[key] ?: oneAtATime.withLock {
+                    val id = nextId++
+                    val deferred = CompletableDeferred<Verdict>()
+                    pending = id to deferred
+                    workerPostMessage(w, WorkerProtocol.decide(id, DecideRequest(query, item)))
+                    try {
+                        deferred.await()
+                    } finally {
+                        if (pending?.first == id) pending = null
+                    }
+                }.also { remember(key, it) }
+                emit(verdict)
+            }
+        } catch (t: Throwable) {
+            if (t is kotlinx.coroutines.CancellationException) throw t
+            _state.value = VerifierState.Error(t.message ?: t::class.simpleName ?: "decision failed")
+            return@flow
+        } finally {
+            if (_state.value is VerifierState.Busy) _state.value = VerifierState.Idle
+        }
+    }
+
+    private fun remember(key: String, verdict: Verdict) {
+        cache[key] = verdict
+        if (cache.size > cacheSize) cache.remove(cache.keys.first())
+    }
+}
diff --git a/SemanticEmojiFilter/settings.gradle.kts b/SemanticEmojiFilter/settings.gradle.kts
index 2500646..e9a7a6d 100644
--- a/SemanticEmojiFilter/settings.gradle.kts
+++ b/SemanticEmojiFilter/settings.gradle.kts
@@ -40,4 +40,7 @@ include(":androidApp")
 include(":composeApp")
 include(":shared")
 include(":cli")
-if (layaVerifier) include(":verifier")
+if (layaVerifier) {
+    include(":verifier")
+    include(":webVerifier")
+}
diff --git a/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/Verifier.kt b/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/Verifier.kt
index 589d163..bbbb53b 100644
--- a/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/Verifier.kt
+++ b/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/Verifier.kt
@@ -1,5 +1,7 @@
 package sk.ainet.samples.emoji.verify
 
+import kotlinx.serialization.Serializable
+
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -7,6 +9,7 @@ import kotlinx.coroutines.flow.emptyFlow
 import sk.ainet.samples.emoji.domain.CatalogItem
 
 /** A decision model's verdict on one candidate item for the current query. */
+@Serializable
 data class Verdict(
     val itemId: String,
     /** `P(item matches query)` as the model sees it; null when the model failed on this item. */
@@ -19,6 +22,8 @@ data class Verdict(
 sealed interface VerifierState {
     /** No verifier built in, or the device cannot run it; the reason shows in the UI. */
     data class Disabled(val reason: String) : VerifierState
+    /** Built in, but waits for the user (a large download, as on the web); [Verifier.enable] starts it. */
+    data class OptIn(val message: String) : VerifierState
     data object Idle : VerifierState
     data class Loading(val message: String) : VerifierState
     data class Busy(val done: Int, val total: Int) : VerifierState
@@ -33,6 +38,8 @@ sealed interface VerifierState {
 interface Verifier {
     val state: StateFlow<VerifierState>
     fun verify(query: String, items: List<CatalogItem>): Flow<Verdict>
+    /** Starts a verifier in [VerifierState.OptIn]; a no-op for the others. */
+    fun enable() {}
 }
 
 /** The web build and any build without `-PlayaVerifier=true`. */
diff --git a/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/WorkerProtocol.kt b/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/WorkerProtocol.kt
new file mode 100644
index 0000000..1e0666a
--- /dev/null
+++ b/SemanticEmojiFilter/shared/src/commonMain/kotlin/sk/ainet/samples/emoji/verify/WorkerProtocol.kt
@@ -0,0 +1,62 @@
+package sk.ainet.samples.emoji.verify
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import sk.ainet.samples.emoji.domain.CatalogItem
+
+/** One verification request, as the web build sends it to its Laya worker. */
+@Serializable
+data class DecideRequest(val query: String, val item: CatalogItem)
+
+/**
+ * The string protocol between the web app and the Laya Web Worker (see `webVerifier/.../Main.kt`).
+ * Main thread to worker: `LOAD`, `DECIDE:<id>:<DecideRequest json>`. Worker to main thread:
+ * `STATE:<kind>:<text>` while loading (`loading`, `error`), `READY`, `VERDICT:<id>:<Verdict json>`,
+ * `ERROR:<id or ->:<message>`. The id lets the main thread drop a verdict for a request it has
+ * cancelled meanwhile.
+ */
+object WorkerProtocol {
+    const val LOAD = "LOAD"
+    const val READY = "READY"
+    private val json = Json { ignoreUnknownKeys = true }
+
+    fun decide(id: Int, request: DecideRequest): String = "DECIDE:$id:" + json.encodeToString(DecideRequest.serializer(), request)
+    fun verdict(id: Int, verdict: Verdict): String = "VERDICT:$id:" + json.encodeToString(Verdict.serializer(), verdict)
+    fun error(id: Int?, message: String): String = "ERROR:${id ?: "-"}:$message"
+    fun loading(message: String): String = "STATE:loading:$message"
+    fun failed(message: String): String = "STATE:error:$message"
+
+    /** `(id, request)` of a `DECIDE` message, or null for anything else. */
+    fun parseDecide(raw: String): Pair<Int, DecideRequest>? = parseTagged(raw, "DECIDE:")?.let { (id, body) -> id to json.decodeFromString(DecideRequest.serializer(), body) }
+    fun parseVerdict(raw: String): Pair<Int, Verdict>? = parseTagged(raw, "VERDICT:")?.let { (id, body) -> id to json.decodeFromString(Verdict.serializer(), body) }
+    /** `(id or null, message)` of an `ERROR` message, or null for anything else. */
+    fun parseError(raw: String): Pair<Int?, String>? {
+        if (!raw.startsWith("ERROR:")) return null
+        val rest = raw.removePrefix("ERROR:")
+        val colon = rest.indexOf(':')
+        if (colon < 0) return null to rest
+        return rest.substring(0, colon).toIntOrNull() to rest.substring(colon + 1)
+    }
+    /** The [VerifierState] a `STATE` message carries, or null for anything else. */
+    fun parseState(raw: String): VerifierState? {
+        if (!raw.startsWith("STATE:")) return null
+        val rest = raw.removePrefix("STATE:")
+        val colon = rest.indexOf(':')
+        val kind = if (colon < 0) rest else rest.substring(0, colon)
+        val text = if (colon < 0) "" else rest.substring(colon + 1)
+        return when (kind) {
+            "loading" -> VerifierState.Loading(text)
+            "error" -> VerifierState.Error(text)
+            else -> null
+        }
+    }
+
+    private fun parseTagged(raw: String, tag: String): Pair<Int, String>? {
+        if (!raw.startsWith(tag)) return null
+        val rest = raw.removePrefix(tag)
+        val colon = rest.indexOf(':')
+        if (colon < 0) return null
+        val id = rest.substring(0, colon).toIntOrNull() ?: return null
+        return id to rest.substring(colon + 1)
+    }
+}
diff --git a/SemanticEmojiFilter/verifier/build.gradle.kts b/SemanticEmojiFilter/verifier/build.gradle.kts
index f3e06e6..b4f9166 100644
--- a/SemanticEmojiFilter/verifier/build.gradle.kts
+++ b/SemanticEmojiFilter/verifier/build.gradle.kts
@@ -1,7 +1,9 @@
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
-// The Laya decision model as a second-stage verifier. Desktop and Android only: the checkpoint
-// is 644 MB of F16 weights (about 1.3 GB as FP32 in memory), far outside the web budget.
+// The Laya decision model as a second-stage verifier. Desktop and Android load the 644 MB F16
+// checkpoint from files; the web build (wasmJs, inside the :webVerifier worker) fetches it from
+// Hugging Face into the browser cache and quantizes it to Q8_0 at load (about 340 MB in memory).
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidMultiplatformLibrary)
@@ -21,10 +23,20 @@ kotlin {
 
     jvm()
 
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+    }
+
     sourceSets {
         commonMain.dependencies {
             api(projects.shared)
             implementation(libs.kotlinx.coroutines)
+            // The BOMs again (shared applies them too): the wasm npm-aggregation configuration
+            // resolves this module's own dependencies without the constraints a project
+            // dependency carries, and would see them versionless.
+            implementation(project.dependencies.platform(libs.skainet.bom))
+            implementation(project.dependencies.platform(libs.skainet.transformers.bom))
             api(libs.skainet.transformers.decisions.api)
             implementation(libs.skainet.transformers.decisions.runtime)
             implementation(libs.skainet.transformers.inference.laya)
@@ -39,6 +51,10 @@ kotlin {
         }
         jvmMain { dependsOn(jvmAndroidMain) }
         androidMain { dependsOn(jvmAndroidMain) }
+        wasmJsMain.dependencies {
+            // The SIMD128 sidecar, installed inside the worker before the first execution context.
+            implementation(libs.skainet.backend.wasm.simd)
+        }
         commonTest.dependencies {
             implementation(libs.kotlin.test)
             implementation(libs.kotlinx.coroutines.test)
diff --git a/SemanticEmojiFilter/verifier/src/commonMain/kotlin/sk/ainet/samples/emoji/verifier/LayaVerifier.kt b/SemanticEmojiFilter/verifier/src/commonMain/kotlin/sk/ainet/samples/emoji/verifier/LayaVerifier.kt
index 5e7ca00..da54bc3 100644
--- a/SemanticEmojiFilter/verifier/src/commonMain/kotlin/sk/ainet/samples/emoji/verifier/LayaVerifier.kt
+++ b/SemanticEmojiFilter/verifier/src/commonMain/kotlin/sk/ainet/samples/emoji/verifier/LayaVerifier.kt
@@ -70,6 +70,11 @@ class LayaVerifier(
         }
     }
 
+    /** Loads the model now instead of on the first verification (the web worker does this on `LOAD`). */
+    suspend fun preload() {
+        openSession()
+    }
+
     private suspend fun openSession(): DecisionSession = loadMutex.withLock {
         session?.let { return it }
         _state.value = VerifierState.Loading("loading ${source.modelId}…")
diff --git a/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaAgentLoader.wasmJs.kt b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaAgentLoader.wasmJs.kt
new file mode 100644
index 0000000..bc94b12
--- /dev/null
+++ b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaAgentLoader.wasmJs.kt
@@ -0,0 +1,9 @@
+package sk.ainet.samples.emoji.verifier
+
+import sk.ainet.context.ExecutionContext
+import sk.ainet.lang.types.FP32
+import sk.ainet.models.laya.LayaAgent
+
+/** The web has no checkpoint directory; [LayaWebSource] builds the agent from fetched bytes instead. */
+actual fun loadLayaAgent(directory: String, ctx: ExecutionContext): LayaAgent<FP32> =
+    error("the web build has no filesystem ($directory); use LayaWebSource")
diff --git a/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaWebSource.kt b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaWebSource.kt
new file mode 100644
index 0000000..db6f75c
--- /dev/null
+++ b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/LayaWebSource.kt
@@ -0,0 +1,87 @@
+package sk.ainet.samples.emoji.verifier
+
+import sk.ainet.context.DirectCpuExecutionContext
+import sk.ainet.decisions.DecisionAdapter
+import sk.ainet.exec.wasm.WasmKernels
+import sk.ainet.exec.wasm.WasmSimd
+import sk.ainet.models.laya.LayaCheckpointFiles
+import sk.ainet.models.laya.LayaDecisionAdapter
+import sk.ainet.models.laya.LayaModelLoader
+import sk.ainet.models.laya.LayaWeightForms
+import sk.ainet.samples.emoji.platform.logEvent
+import kotlin.time.TimeSource
+
+/**
+ * The checkpoint fetched from Hugging Face into the browser cache and built on the packed Q8_0
+ * lane (SKEEP-007): about 340 MB of weights in memory instead of 1.3 GB of FP32, served by the
+ * SIMD128 sidecar. Runs inside the Laya Web Worker, never on the page's thread.
+ */
+class LayaWebSource(
+    /**
+     * Gets every progress line as it happens, in addition to [open]'s callback. The worker posts
+     * them to the page straight away: a `StateFlow` collector on the worker's single thread
+     * cannot run while the synchronous read and quantize work is going on, so it would conflate
+     * eighty seconds of progress into the first and the last line.
+     */
+    private val report: (String) -> Unit = {},
+) : DecisionAdapterSource {
+    override val modelId: String = EmojiMatchSchema.MODEL_ID
+
+    override suspend fun open(onProgress: (String) -> Unit): DecisionAdapter = openReporting { line ->
+        report(line)
+        onProgress(line)
+    }
+
+    private suspend fun openReporting(onProgress: (String) -> Unit): DecisionAdapter {
+        onProgress("loading the SIMD128 kernel sidecar…")
+        try {
+            WasmSimd.install()
+        } catch (e: Throwable) {
+            logEvent("laya_sidecar_failed", "reason" to (e.message ?: e::class.simpleName))
+        }
+        logEvent("laya_kernels", "mode" to WasmKernels.mode)
+        onProgress("kernels: ${WasmKernels.mode}")
+
+        val texts = HashMap<String, String>()
+        for (file in LayaCheckpoint.FILES) {
+            if (file == WEIGHTS) continue
+            onProgress("fetching Laya ${file.substringAfterLast('/')}…")
+            texts[file] = WebFiles.text(WebFiles.fetchCached(LayaCheckpoint.url(file)) { _, _ -> })
+        }
+        val files = LayaCheckpointFiles(
+            agentConfigJson = texts.getValue("rl_agent_config.json"),
+            encoderConfigJson = texts.getValue("encoder/config.json"),
+            tokenizerJson = texts.getValue("tokenizer/tokenizer.json"),
+            tokenizerConfigJson = texts.getValue("tokenizer/tokenizer_config.json"),
+        )
+
+        val totalMb = (LayaCheckpoint.SIZES.getValue(WEIGHTS) / 1_000_000).toString()
+        var lastMb = -1L
+        val blob = WebFiles.fetchCached(LayaCheckpoint.url(WEIGHTS)) { received, _ ->
+            val mb = (received / 1_000_000).toLong()
+            if (mb != lastMb) {
+                lastMb = mb
+                onProgress("downloading Laya weights… $mb / $totalMb MB")
+            }
+        }
+        val readStart = TimeSource.Monotonic.markNow()
+        val chunks = WebFiles.chunks(blob) { done, total -> onProgress("reading Laya weights… ${done / 1_000_000} / ${total / 1_000_000} MB") }
+        logEvent("laya_weights_read", "bytes" to WebFiles.size(blob), "ms" to readStart.elapsedNow().inWholeMilliseconds)
+
+        onProgress("building $modelId (Q8_0, exact GELU)…")
+        val started = TimeSource.Monotonic.markNow()
+        val agent = LayaModelLoader.load(
+            files = files,
+            weights = { sk.ainet.io.ByteArrayRandomAccessSource(chunks) },
+            ctx = DirectCpuExecutionContext(),
+            exactGelu = true,
+            weightFormFor = LayaWeightForms.q8_0For,
+        )
+        logEvent("laya_loaded", "lane" to "q8_0", "loadMs" to started.elapsedNow().inWholeMilliseconds)
+        return LayaDecisionAdapter(agent, modelId)
+    }
+
+    private companion object {
+        const val WEIGHTS = "model.safetensors"
+    }
+}
diff --git a/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/WebFiles.kt b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/WebFiles.kt
new file mode 100644
index 0000000..c8502dd
--- /dev/null
+++ b/SemanticEmojiFilter/verifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/verifier/WebFiles.kt
@@ -0,0 +1,113 @@
+@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class, kotlin.wasm.unsafe.UnsafeWasmMemoryApi::class)
+
+package sk.ainet.samples.emoji.verifier
+
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.wasm.unsafe.Pointer
+import kotlin.wasm.unsafe.wasmMemory
+import kotlin.wasm.unsafe.withScopedMemoryAllocator
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+/**
+ * Fetching and reading checkpoint files inside a Web Worker. A file is fetched once and kept in
+ * the Cache API (`skainet-laya`), so the next visit reads it from disk instead of the network;
+ * the bytes reach Kotlin through wasm linear memory (one `Uint8Array.set` per chunk, then a wasm
+ * loop into the `ByteArray`), never one JS call per byte. `FileReaderSync` makes the chunk reads
+ * synchronous, which is why this only runs in a worker.
+ */
+internal object WebFiles {
+    const val CACHE_NAME = "skainet-laya"
+
+    /** Fetches [url] (or takes it from the cache) and returns the Blob; [onProgress] gets (received, total) bytes while downloading. */
+    suspend fun fetchCached(url: String, onProgress: (Double, Double) -> Unit): JsAny = suspendCancellableCoroutine { cont ->
+        jsFetchCached(url, CACHE_NAME, onProgress, { cont.resume(it) }, { cont.resumeWithException(RuntimeException(it)) })
+    }
+
+    /** The whole Blob as text (the JSON side files). */
+    suspend fun text(blob: JsAny): String = suspendCancellableCoroutine { cont ->
+        jsBlobText(blob, { cont.resume(it) }, { cont.resumeWithException(RuntimeException(it)) })
+    }
+
+    fun size(blob: JsAny): Long = jsBlobSize(blob).toLong()
+
+    /** The Blob as equal-sized chunks (the last one shorter), the layout `ByteArrayRandomAccessSource` wants. */
+    fun chunks(blob: JsAny, chunkBytes: Int = 64 * 1024 * 1024, onProgress: (Long, Long) -> Unit = { _, _ -> }): List<ByteArray> {
+        val total = size(blob)
+        val out = ArrayList<ByteArray>()
+        var position = 0L
+        while (position < total) {
+            val n = minOf(chunkBytes.toLong(), total - position).toInt()
+            out += readRange(blob, position, n)
+            position += n
+            onProgress(position, total)
+        }
+        return out
+    }
+
+    private fun readRange(blob: JsAny, start: Long, length: Int): ByteArray {
+        val bytes = ByteArray(length)
+        var done = 0
+        while (done < length) {
+            val n = minOf(length - done, STAGE_BYTES)
+            withScopedMemoryAllocator { allocator ->
+                val base = allocator.allocate(n)
+                jsReadBlobInto(blob, (start + done).toDouble(), n, wasmMemory, base.address.toInt())
+                var p: Pointer = base
+                for (i in 0 until n) {
+                    bytes[done + i] = p.loadByte()
+                    p += 1
+                }
+            }
+            done += n
+        }
+        return bytes
+    }
+
+    private const val STAGE_BYTES = 16 * 1024 * 1024
+}
+
+@JsFun(
+    """
+    (url, cacheName, onProgress, onDone, onError) => {
+        (async () => {
+            let cache = null;
+            try { cache = await caches.open(cacheName); } catch (e) { console.warn('[laya] Cache API unavailable: ' + e); }
+            let response = cache ? await cache.match(url) : undefined;
+            if (!response) {
+                const net = await fetch(url);
+                if (!net.ok) throw new Error('fetch failed: ' + net.status + ' ' + url);
+                const total = Number(net.headers.get('Content-Length') || net.headers.get('X-Linked-Size') || 0);
+                const reader = net.body.getReader();
+                const parts = [];
+                let received = 0;
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    parts.push(value);
+                    received += value.length;
+                    onProgress(received, total);
+                }
+                const blob = new Blob(parts);
+                if (cache) {
+                    try { await cache.put(url, new Response(blob, { headers: { 'Content-Type': 'application/octet-stream', 'Content-Length': String(blob.size) } })); }
+                    catch (e) { console.warn('[laya] cache put failed: ' + e); }
+                }
+                onDone(blob);
+                return;
+            }
+            onDone(await response.blob());
+        })().catch((e) => onError(String(e && e.message ? e.message : e)));
+    }
+    """,
+)
+private external fun jsFetchCached(url: String, cacheName: String, onProgress: (Double, Double) -> Unit, onDone: (JsAny) -> Unit, onError: (String) -> Unit)
+
+@JsFun("(blob, onDone, onError) => blob.text().then(onDone).catch((e) => onError(String(e && e.message ? e.message : e)))")
+private external fun jsBlobText(blob: JsAny, onDone: (String) -> Unit, onError: (String) -> Unit)
+
+@JsFun("(blob) => blob.size")
+private external fun jsBlobSize(blob: JsAny): Double
+
+@JsFun("(blob, start, length, kmem, ptr) => new Uint8Array(kmem.buffer).set(new Uint8Array(new FileReaderSync().readAsArrayBuffer(blob.slice(start, start + length))), ptr)")
+private external fun jsReadBlobInto(blob: JsAny, start: Double, length: Int, kmem: JsAny, ptr: Int)
diff --git a/SemanticEmojiFilter/webVerifier/build.gradle.kts b/SemanticEmojiFilter/webVerifier/build.gradle.kts
new file mode 100644
index 0000000..b9a8632
--- /dev/null
+++ b/SemanticEmojiFilter/webVerifier/build.gradle.kts
@@ -0,0 +1,24 @@
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+
+// The Laya verifier as a Web Worker: a Kotlin/Wasm executable whose raw compiler output the web
+// app ships under laya-worker/ and starts as a module worker (see composeApp/build.gradle.kts).
+// Everything the worker does (download, quantize-at-load, decisions) runs off the page's thread.
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+}
+
+kotlin {
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+        binaries.executable()
+    }
+
+    sourceSets {
+        wasmJsMain.dependencies {
+            implementation(projects.shared)
+            implementation(projects.verifier)
+            implementation(libs.kotlinx.coroutines)
+        }
+    }
+}
diff --git a/SemanticEmojiFilter/webVerifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/webverifier/Main.kt b/SemanticEmojiFilter/webVerifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/webverifier/Main.kt
new file mode 100644
index 0000000..a283059
--- /dev/null
+++ b/SemanticEmojiFilter/webVerifier/src/wasmJsMain/kotlin/sk/ainet/samples/emoji/webverifier/Main.kt
@@ -0,0 +1,61 @@
+@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
+
+package sk.ainet.samples.emoji.webverifier
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.launch
+import sk.ainet.samples.emoji.verifier.LayaVerifier
+import sk.ainet.samples.emoji.verifier.LayaWebSource
+import sk.ainet.samples.emoji.verify.VerifierState
+import sk.ainet.samples.emoji.verify.WorkerProtocol
+
+/**
+ * The Laya Web Worker. The page's Kotlin/Wasm runs on the single JS thread, and a Laya decision
+ * is a second or more of straight compute even on the SIMD128 lane, so the model lives here:
+ * its own JS/Wasm context, its own memory, and the page repaints between messages.
+ *
+ * Protocol: see [WorkerProtocol]. `LOAD` fetches (or takes from the browser cache) and builds
+ * the Q8_0 agent; every `DECIDE` answers with one `VERDICT`, in order. Loading progress is
+ * forwarded as `STATE` messages; the main thread keeps its own busy counter.
+ */
+@JsFun("(msg) => self.postMessage(msg)")
+external fun postToMain(msg: String)
+
+@JsFun("(handler) => { self.onmessage = (e) => handler(e.data); }")
+external fun installOnMessage(handler: (String) -> Unit)
+
+private val scope = CoroutineScope(Job())
+private val verifier = LayaVerifier(LayaWebSource(report = { postToMain(WorkerProtocol.loading(it)) }))
+
+fun main() {
+    scope.launch {
+        verifier.state.collect { state ->
+            // Progress lines go straight from LayaWebSource; this flow cannot keep up with them.
+            if (state is VerifierState.Error) postToMain(WorkerProtocol.failed(state.message))
+        }
+    }
+    installOnMessage { raw -> scope.launch { handle(raw) } }
+}
+
+private suspend fun handle(raw: String) {
+    when {
+        raw == WorkerProtocol.LOAD -> try {
+            verifier.preload()
+            postToMain(WorkerProtocol.READY)
+        } catch (t: Throwable) {
+            postToMain(WorkerProtocol.error(null, t.message ?: t::class.simpleName ?: "load failed"))
+        }
+        else -> {
+            val (id, request) = WorkerProtocol.parseDecide(raw) ?: return
+            try {
+                val verdict = verifier.verify(request.query, listOf(request.item)).firstOrNull()
+                if (verdict != null) postToMain(WorkerProtocol.verdict(id, verdict))
+                else postToMain(WorkerProtocol.error(id, (verifier.state.value as? VerifierState.Error)?.message ?: "no verdict"))
+            } catch (t: Throwable) {
+                postToMain(WorkerProtocol.error(id, t.message ?: t::class.simpleName ?: "decision failed"))
+            }
+        }
+    }
+}
diff --git a/SemanticEmojiFilter/webapp.json b/SemanticEmojiFilter/webapp.json
index f645bf1..903b2f5 100644
--- a/SemanticEmojiFilter/webapp.json
+++ b/SemanticEmojiFilter/webapp.json
@@ -1,14 +1,14 @@
 {
   "id": "semanticemojifilter",
   "name": "Semantic Emoji Filter",
-  "description": "Type what you mean, get the emoji: on-device sentence embeddings (MongoDB LEAF, 23M parameters) rank 200 emoji live in the browser; desktop and Android add the Laya decision model as a second stage that re-checks the top hits.",
+  "description": "Type what you mean, get the emoji: on-device sentence embeddings (MongoDB LEAF, 23M parameters) rank 200 emoji live in the browser; the Laya decision model re-checks the top hits as a second stage — in the browser too, on the packed Q8_0 lane in a Web Worker, after a one-time 644 MB download.",
   "platforms": ["android", "desktop", "wasm"],
   "distDirs": [
     "composeApp/build/dist/wasmJs/productionExecutable"
   ],
   "build": {
-    "command": "./gradlew :composeApp:wasmJsBrowserDistribution",
-    "description": "Builds the wasm browser distribution, including the bundled ~92 MB LEAF checkpoint"
+    "command": "./gradlew -PlayaVerifier=true :composeApp:wasmJsBrowserDistribution",
+    "description": "Builds the wasm browser distribution with the Laya worker, including the bundled ~92 MB LEAF checkpoint"
   },
   "screenshot": "docs/screenshots/grid.png"
 }