diff --git a/CHANGELOG.md b/CHANGELOG.md
index 77e38e8f..74aa7a70 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@
 - **Explicit SIMD128 bodies for every sidecar matmul kernel**: Q4_K, Q5_K, Q6_K, Q5_0 and Q5_1 join Q8_0 and Q4_0 with hand-written `__wasm_simd128__` paths (the K-quant int8 dots on `i32x4.dot_i16x8_s`, the Q5 fifth-bit plane via a byte swizzle); the dense FP32 GEMM gets a 4×8 register-blocked, k-blocked micro-kernel; BF16 and FP16 widen eight weights per step. BF16 and FP16 also gain NEON bodies (none existed on any tier). Results stay bit-identical in accumulation order to the portable bodies.
 - **Threaded dense kernels**: `skainet_fp32_matmul`, `skainet_bf16_matmul` and `skainet_fp16_matmul` now split the output over the shared row-thread pool like the packed kernels do (the GEMM over the longer side of `C`, the 16-bit kernels over columns) — the mt sidecar's pthreads in a browser, the native pool on the JVM.
 - **`WasmCpuOps.matmul`**: a dense 2-D `A · B` on heap FP32 operands runs the sidecar GEMM; the common `[k, n]` loop no longer serves that shape on wasm (it was the only dense path that never reached the sidecar).
+- **Ternary kernels on the wasm tier**: the sidecar now exports `skainet_ternary_f32_gemv`, `skainet_ternary_lmhead_stage1` and `skainet_bitnet_gemv_tq2_0`, and `WasmTernaryKernelPack` (installed by `WasmSimd.install()`) registers them under the same `KernelDispatch` keys the JVM FFM and Android JNI ternary packs serve — exact FP32 × `BitNet-b1.58`, the fused multi-plane `BitNet-planes` lm_head and int8 × `TQ2_0`. A BitNet weight in a browser previously went to the decoding reference kernel. The portable branch of `skainet_ternary_f32.c` (MSVC and Emscripten) now holds the vendored kernel's 256-entry decode table as a compile-time constant with a SIMD128 body and threads over output rows through the shared row pool; `bitnet_gemv` gains a SIMD128 block body and the same row threading on every tier.
+- **Direct `x · Wᵀ` on the JVM**: `Fp32MatmulWtKernel` / `KernelProvider.matmulFp32Wt()` (and the JVM-only `Fp32MemSegMatmulWtKernel` / `MemSegKernelProvider.matmulFp32WtMemSeg()`) expose `skainet_fp32_matmul_wt`, which the wasm sidecar has served since 0.61.0 and the JVM never bound. `NativeKernelProvider` carries it; `DefaultCpuOpsJvm.matmulWeightTransposed` multiplies a dense `[out, in]` FP32 weight in place through it — a segment-backed weight where it lies, a heap weight after one resident off-heap copy — instead of transposing the weight once into `[k, n]` and caching the copy. The wasm provider exposes the same accessor (`WasmFp32MatmulWtKernel`), and `KernelProvider.supports("matmul_wt", …)` reports it.
+- **Kernel support matrix, fourth table** *Kernel packs (view dispatch)*: the ternary formats and the direct `x · Wᵀ` per platform, which the `matmul` accessors the first table introspects do not cover.
+- **`engine-fp32-linear`** in `jvm-cpu-publish` and `wasm-bench`: a `Linear` layer's `x · Wᵀ` (16 tokens, 768 → 3072) through `ctx.ops.matmulWeightTransposed`; on the JVM `--provider panama` measures the cached-transpose path and `--provider ffm` the direct kernel.
 - **`wasm-bench` runs the `engine-*` scenarios** of the JVM publish harness (`engine-fp32-gemm`, `engine-kernel-matmul`, `engine-bf16-matmul`, `engine-q8-matmul`, `engine-q4-gemm`, `engine-ternary-f32-gemv`, `engine-elementwise-add`, `engine-reductions-sum/mean`) with identical shapes and metrics on every tier it measures, so the JVM and wasm numbers sit in one table.
 
 ## [0.61.0] - 2026-10-16
diff --git a/build-logic/convention/src/main/kotlin/GenerateKernelMatrixTask.kt b/build-logic/convention/src/main/kotlin/GenerateKernelMatrixTask.kt
index 6964d6e0..17d2ebe1 100644
--- a/build-logic/convention/src/main/kotlin/GenerateKernelMatrixTask.kt
+++ b/build-logic/convention/src/main/kotlin/GenerateKernelMatrixTask.kt
@@ -128,6 +128,33 @@ abstract class GenerateKernelMatrixTask : DefaultTask() {
                 appendLine("|===")
                 appendLine("")
             }
+            if (module.packs.isNotEmpty()) {
+                appendLine("== Kernel packs (view dispatch)")
+                appendLine("")
+                appendLine(
+                    "Kernels that are not reached through the `matmul` accessors above: the ternary formats " +
+                        "are served by `ViewKernelPack`s keyed in `KernelDispatch` (`BitNet-b1.58` with exact " +
+                        "FP32 activations, the fused multi-plane `BitNet-planes` lm_head, `TQ2_0` with int8 " +
+                        "activations), and the dense `x · Wᵀ` of a `Linear` layer by the `matmulFp32Wt` " +
+                        "accessor, which multiplies a row-major `[out, in]` weight in place instead of " +
+                        "transposing and caching a copy. The scalar reference kernels serve every cell that " +
+                        "is empty here (`—`), at reference speed; the common row-dot serves `x · Wᵀ` there.",
+                )
+                appendLine("")
+                appendLine("[cols=\"$colSpec\", options=\"header\"]")
+                appendLine("|===")
+                append("| Kernel ")
+                module.platforms.forEach { append("| $it ") }
+                appendLine("")
+                appendLine("")
+                module.packs.forEach { fmt ->
+                    append("| `${fmt.name}` ")
+                    module.platforms.forEach { p -> append("| ${fmt.byPlatform[p] ?: "—"} ") }
+                    appendLine("")
+                }
+                appendLine("|===")
+                appendLine("")
+            }
             appendLine(
                 "See also the eager backends & kernels mindmap " +
                     "(xref:explanation/eager-execution.adoc[]) for the narrative overview and gaps.",
diff --git a/build-logic/convention/src/main/kotlin/models/KernelSupportModels.kt b/build-logic/convention/src/main/kotlin/models/KernelSupportModels.kt
index 90da5388..fe8a43eb 100644
--- a/build-logic/convention/src/main/kotlin/models/KernelSupportModels.kt
+++ b/build-logic/convention/src/main/kotlin/models/KernelSupportModels.kt
@@ -23,6 +23,12 @@ data class KernelSupportModule(
      */
     val mapped: List<KernelFormatSupport> = emptyList(),
     val resident: List<KernelFormatSupport> = emptyList(),
+    /**
+     * Kernel packs (view dispatch): the ternary formats and the direct dense `x · Wᵀ`, served by
+     * `ViewKernelPack`s / the `matmulFp32Wt` accessor rather than the `matmul` accessors. Absent in
+     * older JSON.
+     */
+    val packs: List<KernelFormatSupport> = emptyList(),
 )
 
 @Serializable
diff --git a/docs/modules/ROOT/pages/contributing/benchmarks.adoc b/docs/modules/ROOT/pages/contributing/benchmarks.adoc
index 69a2ed12..737ee21e 100644
--- a/docs/modules/ROOT/pages/contributing/benchmarks.adoc
+++ b/docs/modules/ROOT/pages/contributing/benchmarks.adoc
@@ -33,6 +33,7 @@ microbench tests under `skainet-backends/skainet-backend-native-cpu`:
 |===
 | Scenario | What it exercises | Unit | Direction
 | engine-fp32-gemm        | `ctx.ops.matmul` end-to-end FP32 square matmul              | GFLOPS        | higher is better
+| engine-fp32-linear      | `ctx.ops.matmulWeightTransposed` — a `Linear` layer's `x · Wᵀ` with the weight stored `[out, in]` (panama: cached transpose + GEMM; ffm: native direct kernel, no transposed copy) | GFLOPS | higher is better
 | engine-q4-gemm          | `PanamaVectorQ4KMatmulKernel` F32 × Q4_K matmul at LLM shapes | GOP/s        | higher is better
 | engine-kernel-matmul    | Direct `Fp32MatmulKernel` (scalar vs panama-vector)         | GFLOPS        | higher is better
 | engine-bf16-matmul      | `Bf16MatmulKernel` F32 × BF16-packed matmul (scalar vs panama-vector) | GFLOPS | higher is better
diff --git a/docs/modules/ROOT/pages/explanation/eager-execution.adoc b/docs/modules/ROOT/pages/explanation/eager-execution.adoc
index f251bfbe..3f4e9b59 100644
--- a/docs/modules/ROOT/pages/explanation/eager-execution.adoc
+++ b/docs/modules/ROOT/pages/explanation/eager-execution.adoc
@@ -29,7 +29,8 @@ mindmap
       Native FFM
         JVM only — C kernels via CMake
         Q4_K MemSeg zero-copy
-        Q6_K missing
+        direct x·Wᵀ, no transposed copy
+        ternary LUT gemv and planes lm_head
       Native JNI
         Android only — same C kernels via JNI
         two .so tiers, cpuinfo-gated armv8-a vs armv8.2+dotprod
@@ -47,7 +48,7 @@ mindmap
       Android — scalar, Native-JNI
       Native linux — scalar, Native-cinterop
       Native apple — scalar, Accelerate, Native-cinterop
-      JS and WASM — scalar; packed weights relaid once into kernel feed order (SKEEP-007)
+      JS and WASM — scalar; wasmJs plus the SIMD128 sidecar pack: every matmul format, ternary, direct x·Wᵀ (SKEEP-007)
 ----
 
 == Kernel × provider (matmul, FP32 activations)
@@ -56,6 +57,7 @@ mindmap
 |===
 | Weight format | Scalar (all targets) | Panama (JVM) | Native FFM (JVM) | Native JNI (Android) | Native cinterop (K/N) | Wasm SIMD128 (wasmJs)
 | FP32 | ✅ | ✅ | ✅ | ❌ | ❌ | ✅
+| FP32 `x · Wᵀ` direct (weight `[out, in]`, no transposed copy) | row-dot | ❌ (cached transpose) | ✅ | ❌ | ❌ | ✅
 | BF16 | ✅ | ✅ | ✅ | ❌ | ❌ | ✅
 | FP16 | ✅ | ✅ | ✅ | ❌ | ❌ | ✅
 | Q8_0 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅
@@ -65,9 +67,9 @@ mindmap
 | Q5_K | ✅ | ✅ | ✅ | ✅ | ✅ | ✅
 | Q5_1 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅
 | Q5_0 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅
-| TQ2_0 / BitNet b1.58 (int8 activations) | ✅ | — | — | ✅ NEON | — | —
-| BitNet b1.58 (exact FP32 activations, vendored NeoGPU kernel) | ✅ | ✅ FFM | — | ✅ JNI + fused lm_head | ✅ K/N cinterop | ❌ (reference)
-| BITNET_PLANES (multi-plane ternary packing) | ✅ | via kernel pack | — | via kernel pack | via kernel pack | ❌ (reference)
+| TQ2_0 / BitNet b1.58 (int8 activations) | ✅ | — | — | ✅ NEON | — | ✅ SIMD128
+| BitNet b1.58 (exact FP32 activations, LUT gemv) | ✅ | — | ✅ FFM (vendored NeoGPU) | ✅ JNI | ✅ K/N cinterop | ✅ SIMD128 LUT
+| BITNET_PLANES (multi-plane ternary packing, fused lm_head) | ✅ | — | ✅ FFM (vendored NeoGPU) | ✅ JNI | ✅ K/N cinterop | ✅ SIMD128 LUT
 | Q2_K / Q3_K / Q8_K / IQ4 | ❌ (dequant to FP32 only) | ❌ | ❌ | ❌ | ❌ | ❌
 |===
 
@@ -78,7 +80,15 @@ columns are mutually exclusive per platform rather than stacked. The Wasm SIMD12
 sidecar pack (`skainet-backend-wasm-simd`), present only after `WasmSimd.install()`; every matmul
 kernel in it has an explicit SIMD128 body (the K-quant int8 dots on `i32x4.dot_i16x8_s`, a 4×8
 register-blocked dense GEMM, eight-wide BF16/FP16 widening), and the dense kernels thread over the
-sidecar's pthread pool like the packed ones when the page is cross-origin isolated.
+sidecar's pthread pool like the packed ones when the page is cross-origin isolated. The ternary
+kernels in the sidecar are the portable mirror of the vendored NeoGPU kernel — the same 256-entry
+decode table as a compile-time constant, read four codes at a time in SIMD128 — registered under the
+same dispatch keys as the FFM and JNI ternary packs (`WasmTernaryKernelPack`).
+
+The dense `x · Wᵀ` row is the product a `Linear` layer computes. The JVM and the wasm tier multiply
+the `[out, in]` weight in place through `skainet_fp32_matmul_wt` (`KernelProvider.matmulFp32Wt`;
+the JVM makes a heap weight resident off-heap once, the sidecar keeps it in its linear memory) and
+never materialise the transposed copy the Panama path caches per weight.
 
 Packed weights reach a kernel through the registry by declaring their
 xref:explanation/packed-weight-layout.adoc[block order]; a canonical weight is relayouted once,
@@ -101,8 +111,6 @@ Packed-quant matmul works on every target: those formats have a `commonMain` sca
 
 == Gaps
 
-* *Wasm ternary / BitNet* — the ternary gemv and planes lm-head kernels are not in the sidecar
-build yet, so BitNet models in a browser run the decoding reference kernel.
 * *Wasm beyond matmul* — elementwise, activations, reductions, normalisation and attention are the
 common scalar Kotlin paths on wasmJs; Kotlin/Wasm has no SIMD types and no shared-memory threads, so
 these follow the matmuls into the sidecar (SKEEP-007 rollout step 3).
diff --git a/docs/modules/ROOT/pages/explanation/kernel-selection.adoc b/docs/modules/ROOT/pages/explanation/kernel-selection.adoc
index b522b017..a7a58253 100644
--- a/docs/modules/ROOT/pages/explanation/kernel-selection.adoc
+++ b/docs/modules/ROOT/pages/explanation/kernel-selection.adoc
@@ -91,7 +91,7 @@ platform support is absent (a missing native library, no vector unit).
 
 | Kotlin/Native, wasm, JS
 | manual — e.g. `installNativeKernels()`; on wasmJs `WasmSimd.install()` (SKEEP-007)
-| manual — call the pack's `install()` yourself; `WasmSimd.install()` registers the browser pack and its provider
+| manual — call the pack's `install()` yourself; `WasmSimd.install()` registers the browser pack, its ternary pack and its provider
 |===
 
 Without a row-major pack, a canonical packed weight is relaid **once per weight** into kernel feed
diff --git a/docs/modules/ROOT/pages/reference/kernel-support-matrix.adoc b/docs/modules/ROOT/pages/reference/kernel-support-matrix.adoc
index a3317ed3..a7de8e00 100644
--- a/docs/modules/ROOT/pages/reference/kernel-support-matrix.adoc
+++ b/docs/modules/ROOT/pages/reference/kernel-support-matrix.adoc
@@ -58,4 +58,18 @@ The browser has no files to map, so the wasm tier keeps weights *resident* in th
 | `Q5_0` | — | — | — | — | wasm-resident 
 |===
 
+== Kernel packs (view dispatch)
+
+Kernels that are not reached through the `matmul` accessors above: the ternary formats are served by `ViewKernelPack`s keyed in `KernelDispatch` (`BitNet-b1.58` with exact FP32 activations, the fused multi-plane `BitNet-planes` lm_head, `TQ2_0` with int8 activations), and the dense `x · Wᵀ` of a `Linear` layer by the `matmulFp32Wt` accessor, which multiplies a row-major `[out, in]` weight in place instead of transposing and caching a copy. The scalar reference kernels serve every cell that is empty here (`—`), at reference speed; the common row-dot serves `x · Wᵀ` there.
+
+[cols="1,1,1,1,1,1", options="header"]
+|===
+| Kernel | JVM | Android | Native·linux | Native·apple | JS/WASM 
+
+| `BitNet-b1.58 (FP32 activations)` | ffm-ternary | native-jni | native-cinterop | native-cinterop | wasm-simd128 
+| `BitNet-planes` | ffm-ternary | native-jni | native-cinterop | native-cinterop | wasm-simd128 
+| `TQ2_0 (int8 activations)` | — | native-jni | — | — | wasm-simd128 
+| `Float32 x·Wᵀ direct` | native-ffm | — | — | — | wasm-simd128 
+|===
+
 See also the eager backends & kernels mindmap (xref:explanation/eager-execution.adoc[]) for the narrative overview and gaps.
diff --git a/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/Fp32LinearScenario.kt b/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/Fp32LinearScenario.kt
new file mode 100644
index 00000000..2600d365
--- /dev/null
+++ b/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/Fp32LinearScenario.kt
@@ -0,0 +1,79 @@
+package sk.ainet.bench.publish.scenarios
+
+import sk.ainet.backend.api.kernel.KernelRegistry
+import sk.ainet.bench.publish.runner.Scenario
+import sk.ainet.context.DirectCpuExecutionContext
+import sk.ainet.exec.kernel.NativeKernelProvider
+import sk.ainet.exec.kernel.PanamaVectorKernelProvider
+import sk.ainet.exec.kernel.ScalarKernelProvider
+import sk.ainet.lang.tensor.Shape
+import sk.ainet.lang.tensor.Tensor
+import sk.ainet.lang.types.FP32
+
+/**
+ * A `Linear` layer's product, `x · Wᵀ` with the weight stored `[out, in]`, through the public
+ * `ctx.ops.matmulWeightTransposed` path — what every projection of a transformer pays, as opposed to
+ * the `[k, n]` GEMM of `engine-fp32-gemm`. Shape: a 16-token prefill against a 768 → 3072 FFN
+ * projection. Primary metric: GFLOP/s over `2·m·n·k`.
+ *
+ * The provider selects the path: `panama` (the default) transposes the weight once into `[k, n]`
+ * and runs the Vector API GEMM; `ffm` runs the native direct kernel (`skainet_fp32_matmul_wt`) over a
+ * weight made resident off-heap, no transposed copy; `scalar` is the common row-dot. Only the chosen
+ * provider is registered, so the ops layer cannot fall through to another.
+ */
+internal class Fp32LinearScenario(
+    smoke: Boolean,
+    private val providerName: String,
+) : Scenario {
+    override val id: String = "engine-fp32-linear"
+    override val suite: String = "skainet-engine"
+    override val primaryMetric: String = "gflops"
+    override val unit: String = "gflops"
+    override val higherIsBetter: Boolean = true
+    override val kernelProvider: String = providerName
+
+    private val m: Int = 16
+    private val k: Int = 768
+    private val n: Int = if (smoke) 768 else 3072
+    override val parameters: Map<String, String> = mapOf(
+        "m" to m.toString(),
+        "k" to k.toString(),
+        "n" to n.toString(),
+        "kernel" to providerName,
+    )
+
+    private lateinit var ctx: DirectCpuExecutionContext
+    private lateinit var x: Tensor<FP32, Float>
+    private lateinit var w: Tensor<FP32, Float>
+
+    override fun setup() {
+        KernelRegistry.clearForTesting()
+        when (providerName.lowercase()) {
+            "panama", "panama-vector" -> KernelRegistry.register(PanamaVectorKernelProvider)
+            "ffm", "native", "native-ffm" -> {
+                check(NativeKernelProvider.isAvailable()) { "bundled libskainet_kernels missing — the ffm provider cannot run" }
+                KernelRegistry.register(NativeKernelProvider)
+            }
+            "scalar" -> KernelRegistry.register(ScalarKernelProvider)
+            else -> error("unknown kernel provider: $providerName (use 'panama', 'ffm' or 'scalar')")
+        }
+        ctx = DirectCpuExecutionContext()
+        x = ctx.fromFloatArray(Shape(m, k), FP32::class, FloatArray(m * k) { ((it % 251) - 125).toFloat() / 127f })
+        w = ctx.fromFloatArray(Shape(n, k), FP32::class, FloatArray(n * k) { ((it * 13 % 257) - 128).toFloat() / 127f })
+        // First call: the transpose cache or the resident copy is built here, not in a measured run.
+        ctx.ops.matmulWeightTransposed(x, w)
+    }
+
+    override fun runOnce(): Double {
+        val start = System.nanoTime()
+        val result = ctx.ops.matmulWeightTransposed(x, w)
+        val elapsedNs = System.nanoTime() - start
+        @Suppress("UNUSED_VARIABLE") val sink = result.hashCode()
+        val flops = 2.0 * m.toDouble() * n.toDouble() * k.toDouble()
+        return (flops / (elapsedNs / 1_000_000_000.0)) / 1e9
+    }
+
+    override fun teardown() {
+        KernelRegistry.clearForTesting()
+    }
+}
diff --git a/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/ScenarioRegistry.kt b/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/ScenarioRegistry.kt
index 74a595fe..a3f0550e 100644
--- a/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/ScenarioRegistry.kt
+++ b/skainet-backends/benchmarks/jvm-cpu-publish/src/main/kotlin/sk/ainet/bench/publish/scenarios/ScenarioRegistry.kt
@@ -6,6 +6,7 @@ public object ScenarioRegistry {
 
     public fun ids(): List<String> = listOf(
         "engine-fp32-gemm",
+        "engine-fp32-linear",
         "engine-q4-gemm",
         "engine-kernel-matmul",
         "engine-bf16-matmul",
@@ -18,6 +19,7 @@ public object ScenarioRegistry {
 
     public fun byId(id: String, provider: String, smoke: Boolean): Scenario? = when (id) {
         "engine-fp32-gemm" -> Fp32GemmScenario(smoke = smoke, providerName = provider)
+        "engine-fp32-linear" -> Fp32LinearScenario(smoke = smoke, providerName = provider)
         "engine-q4-gemm" -> Q4GemmScenario(smoke = smoke, providerName = provider)
         "engine-kernel-matmul" -> KernelMatmulScenario(smoke = smoke, providerName = provider)
         "engine-bf16-matmul" -> Bf16MatmulScenario(smoke = smoke, providerName = provider)
diff --git a/skainet-backends/benchmarks/wasm-bench/src/wasmJsMain/kotlin/sk/ainet/bench/wasm/Scenarios.kt b/skainet-backends/benchmarks/wasm-bench/src/wasmJsMain/kotlin/sk/ainet/bench/wasm/Scenarios.kt
index 271fc27b..45b404e0 100644
--- a/skainet-backends/benchmarks/wasm-bench/src/wasmJsMain/kotlin/sk/ainet/bench/wasm/Scenarios.kt
+++ b/skainet-backends/benchmarks/wasm-bench/src/wasmJsMain/kotlin/sk/ainet/bench/wasm/Scenarios.kt
@@ -48,6 +48,15 @@ internal fun engineScenarios(): List<WasmScenario> = listOf(
         val flops = 2.0 * n * n * n;
         { flops / seconds { ctx.ops.matmul(a, b) } / 1e9 }
     },
+    WasmScenario("engine-fp32-linear", "gflops", mapOf("m" to "16", "k" to "768", "n" to "3072"), reps = 10) {
+        val m = 16; val k = 768; val n = 3072
+        val ctx = DirectCpuExecutionContext()
+        val x = ctx.fromFloatArray<FP32, Float>(Shape(m, k), FP32::class, FloatArray(m * k) { ((it % 251) - 125).toFloat() / 127f })
+        val w = ctx.fromFloatArray<FP32, Float>(Shape(n, k), FP32::class, FloatArray(n * k) { ((it * 13 % 257) - 128).toFloat() / 127f })
+        ctx.ops.matmulWeightTransposed(x, w) // the resident upload happens here, not in a measured run
+        val flops = 2.0 * m * n * k;
+        { flops / seconds { ctx.ops.matmulWeightTransposed(x, w) } / 1e9 }
+    },
     WasmScenario("engine-kernel-matmul", "gflops", mapOf("size" to "1024"), reps = 3) {
         val n = 1024
         DirectCpuExecutionContext()
diff --git a/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/Fp32MatmulWtKernel.kt b/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/Fp32MatmulWtKernel.kt
new file mode 100644
index 00000000..d85d77a1
--- /dev/null
+++ b/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/Fp32MatmulWtKernel.kt
@@ -0,0 +1,28 @@
+package sk.ainet.backend.api.kernel
+
+/**
+ * Dense `x · Wᵀ` for a row-major `[out, in]` FP32 weight — the shape a `Linear` layer stores its
+ * weight in, multiplied in place:
+ *
+ *   `out[i, o] = Σ_p x[i, p] · w[o, p]`
+ *
+ * Every output is one contiguous dot product over the weight's own row, so no transposed copy of
+ * the weight is ever made. This is the SPI face of `skainet_fp32_matmul_wt` (SKEEP-007), which the
+ * wasm sidecar has served since 0.61.0 and the JVM FFM provider binds as well: a tier whose
+ * [Fp32MatmulKernel] wants the weight input-major (`[k, n]`) otherwise pays a scattered transpose
+ * copy per weight and caches it — about 0.5 GB for a 22-layer encoder.
+ *
+ * Operands are contiguous: `x` is `m` rows of `k`, `w` is `n` rows of `k`, `out` is `m` rows of
+ * `n`, each from its offset. Implementations must not mutate `x` or `w`, must fully overwrite the
+ * `m × n` block of `out`, and may assume the arrays do not alias. `k == 0` zeroes the block;
+ * `m == 0` or `n == 0` is a no-op. Each output accumulates its products in ascending `p`, so a
+ * conforming kernel is bit-identical to transpose-then-GEMM with the same accumulation order.
+ */
+public interface Fp32MatmulWtKernel {
+    public fun matmulWt(
+        x: FloatArray, xOffset: Int,
+        w: FloatArray, wOffset: Int,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    )
+}
diff --git a/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/KernelProvider.kt b/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/KernelProvider.kt
index d1126a82..734c97e4 100644
--- a/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/KernelProvider.kt
+++ b/skainet-backends/skainet-backend-api/src/commonMain/kotlin/sk/ainet/backend/api/kernel/KernelProvider.kt
@@ -103,6 +103,13 @@ public interface KernelProvider {
      */
     public fun matmulQ5_0(): Q5_0MatmulKernel? = null
 
+    /**
+     * Dense `x · Wᵀ` over a row-major `[out, in]` FP32 weight ([Fp32MatmulWtKernel]), or `null`
+     * when this provider has no direct kernel for it and the caller should transpose once and use
+     * [matmulFp32]. Same fall-through pattern as [matmulQ4K].
+     */
+    public fun matmulFp32Wt(): Fp32MatmulWtKernel? = null
+
     /**
      * Capability query: does this provider carry a kernel for
      * [opName] with the given [dtypeKeys]?
@@ -122,15 +129,18 @@ public interface KernelProvider {
      * - For ops that aren't matmul (future: SDPA, gather, RMSNorm…),
      *   providers can override this method to declare those kernels.
      *
-     * The default body covers the four matmul accessors that exist
-     * on this interface today. Providers that ship additional
+     * The default body covers the matmul accessors on this interface,
+     * plus `"matmul_wt"` with `["Float32", "Float32"]` for the direct
+     * `x · Wᵀ` kernel ([matmulFp32Wt]). Providers that ship additional
      * kernels override and chain through `super.supports(...)` for
      * the matmul base cases.
      */
     public fun supports(opName: String, dtypeKeys: List<String>): Boolean {
-        if (opName != "matmul" || dtypeKeys.size != 2) return false
+        if (dtypeKeys.size != 2) return false
         val (input, weight) = dtypeKeys
         if (input != "Float32") return false
+        if (opName == "matmul_wt") return weight == "Float32" && matmulFp32Wt() != null
+        if (opName != "matmul") return false
         return when (weight) {
             "Float32" -> matmulFp32() != null
             "BFloat16" -> matmulBf16() != null
diff --git a/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/Fp32MemSegMatmulWtKernel.kt b/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/Fp32MemSegMatmulWtKernel.kt
new file mode 100644
index 00000000..6b95f271
--- /dev/null
+++ b/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/Fp32MemSegMatmulWtKernel.kt
@@ -0,0 +1,24 @@
+package sk.ainet.backend.api.kernel
+
+import java.lang.foreign.MemorySegment
+
+/**
+ * [Fp32MatmulWtKernel] with the `[out, in]` FP32 weight supplied as an off-heap
+ * `java.lang.foreign.MemorySegment` instead of a heap `FloatArray`. JVM-only sibling, for the same
+ * reason [Q4KMemSegMatmulKernel] exists: a downcall cannot read heap memory on JDK 21, so the heap
+ * face copies the whole weight on every call — and the weight is the large operand. A weight that
+ * already lives in a segment (loaded off-heap, or made resident once by the ops layer) is passed
+ * through with no copy at all; only the `m × k` activation and the `m × n` output are staged.
+ *
+ * Same contract as [Fp32MatmulWtKernel]: contiguous operands, `out` fully overwritten, products
+ * accumulated in ascending `p`. The caller owns the segment's arena and keeps it alive for the
+ * duration of the call; the kernel retains nothing past return.
+ */
+public interface Fp32MemSegMatmulWtKernel {
+    public fun matmulWt(
+        x: FloatArray, xOffset: Int,
+        weight: MemorySegment, weightByteOffset: Long,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    )
+}
diff --git a/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/MemSegKernelProvider.kt b/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/MemSegKernelProvider.kt
index 527401a5..c567aa11 100644
--- a/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/MemSegKernelProvider.kt
+++ b/skainet-backends/skainet-backend-api/src/jvmMain/kotlin/sk/ainet/backend/api/kernel/MemSegKernelProvider.kt
@@ -34,4 +34,10 @@ public interface MemSegKernelProvider {
      * keep compiling.
      */
     public fun matmulQ4KMemSeg(): Q4KMemSegMatmulKernel? = null
+
+    /**
+     * Dense `x · Wᵀ` with the `[out, in]` FP32 weight supplied as a `MemorySegment`
+     * ([Fp32MemSegMatmulWtKernel]), or `null`. Same `null` default as [matmulQ4KMemSeg].
+     */
+    public fun matmulFp32WtMemSeg(): Fp32MemSegMatmulWtKernel? = null
 }
diff --git a/skainet-backends/skainet-backend-cpu/api/jvm/skainet-backend-cpu.api b/skainet-backends/skainet-backend-cpu/api/jvm/skainet-backend-cpu.api
index e0b80980..eddcc360 100644
--- a/skainet-backends/skainet-backend-cpu/api/jvm/skainet-backend-cpu.api
+++ b/skainet-backends/skainet-backend-cpu/api/jvm/skainet-backend-cpu.api
@@ -67,6 +67,7 @@ public final class sk/ainet/exec/kernel/PanamaVectorKernelProvider : sk/ainet/ba
 	public fun matmulBf16 ()Lsk/ainet/backend/api/kernel/Bf16MatmulKernel;
 	public fun matmulFp16 ()Lsk/ainet/backend/api/kernel/Fp16MatmulKernel;
 	public fun matmulFp32 ()Lsk/ainet/backend/api/kernel/Fp32MatmulKernel;
+	public fun matmulFp32Wt ()Lsk/ainet/backend/api/kernel/Fp32MatmulWtKernel;
 	public fun matmulQ4K ()Lsk/ainet/backend/api/kernel/Q4KMatmulKernel;
 	public fun matmulQ4_0 ()Lsk/ainet/backend/api/kernel/Q4_0MatmulKernel;
 	public fun matmulQ5K ()Lsk/ainet/backend/api/kernel/Q5KMatmulKernel;
@@ -85,6 +86,7 @@ public final class sk/ainet/exec/kernel/PanamaVectorKernelProviderFactory : sk/a
 	public fun matmulBf16 ()Lsk/ainet/backend/api/kernel/Bf16MatmulKernel;
 	public fun matmulFp16 ()Lsk/ainet/backend/api/kernel/Fp16MatmulKernel;
 	public fun matmulFp32 ()Lsk/ainet/backend/api/kernel/Fp32MatmulKernel;
+	public fun matmulFp32Wt ()Lsk/ainet/backend/api/kernel/Fp32MatmulWtKernel;
 	public fun matmulQ4K ()Lsk/ainet/backend/api/kernel/Q4KMatmulKernel;
 	public fun matmulQ4_0 ()Lsk/ainet/backend/api/kernel/Q4_0MatmulKernel;
 	public fun matmulQ5K ()Lsk/ainet/backend/api/kernel/Q5KMatmulKernel;
@@ -168,6 +170,7 @@ public final class sk/ainet/exec/kernel/ScalarKernelProvider : sk/ainet/backend/
 	public fun matmulBf16 ()Lsk/ainet/backend/api/kernel/Bf16MatmulKernel;
 	public fun matmulFp16 ()Lsk/ainet/backend/api/kernel/Fp16MatmulKernel;
 	public fun matmulFp32 ()Lsk/ainet/backend/api/kernel/Fp32MatmulKernel;
+	public fun matmulFp32Wt ()Lsk/ainet/backend/api/kernel/Fp32MatmulWtKernel;
 	public fun matmulQ4K ()Lsk/ainet/backend/api/kernel/Q4KMatmulKernel;
 	public fun matmulQ4_0 ()Lsk/ainet/backend/api/kernel/Q4_0MatmulKernel;
 	public fun matmulQ5K ()Lsk/ainet/backend/api/kernel/Q5KMatmulKernel;
@@ -186,6 +189,7 @@ public final class sk/ainet/exec/kernel/ScalarKernelProviderFactory : sk/ainet/b
 	public fun matmulBf16 ()Lsk/ainet/backend/api/kernel/Bf16MatmulKernel;
 	public fun matmulFp16 ()Lsk/ainet/backend/api/kernel/Fp16MatmulKernel;
 	public fun matmulFp32 ()Lsk/ainet/backend/api/kernel/Fp32MatmulKernel;
+	public fun matmulFp32Wt ()Lsk/ainet/backend/api/kernel/Fp32MatmulWtKernel;
 	public fun matmulQ4K ()Lsk/ainet/backend/api/kernel/Q4KMatmulKernel;
 	public fun matmulQ4_0 ()Lsk/ainet/backend/api/kernel/Q4_0MatmulKernel;
 	public fun matmulQ5K ()Lsk/ainet/backend/api/kernel/Q5KMatmulKernel;
diff --git a/skainet-backends/skainet-backend-cpu/src/jvmMain/kotlin/sk/ainet/exec/tensor/ops/DefaultCpuOpsJvm.kt b/skainet-backends/skainet-backend-cpu/src/jvmMain/kotlin/sk/ainet/exec/tensor/ops/DefaultCpuOpsJvm.kt
index 8fe1cf91..3b2157b2 100644
--- a/skainet-backends/skainet-backend-cpu/src/jvmMain/kotlin/sk/ainet/exec/tensor/ops/DefaultCpuOpsJvm.kt
+++ b/skainet-backends/skainet-backend-cpu/src/jvmMain/kotlin/sk/ainet/exec/tensor/ops/DefaultCpuOpsJvm.kt
@@ -6,7 +6,9 @@ import jdk.incubator.vector.VectorOperators
 import sk.ainet.backend.api.kernel.Bf16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp32MatmulKernel
+import sk.ainet.backend.api.kernel.Fp32MemSegMatmulWtKernel
 import sk.ainet.backend.api.kernel.KernelRegistry
+import sk.ainet.backend.api.kernel.MemSegKernelProvider
 import sk.ainet.backend.api.kernel.KernelServiceLoader
 import sk.ainet.backend.api.kernel.KernelStrictness
 import sk.ainet.backend.api.kernel.Q4KMatmulKernel
@@ -196,12 +198,19 @@ internal class DefaultCpuOpsJvm(
      * tensor nothing could decode correctly (#1124). Here the kernels do exist, so the relayout
      * pays: once per weight, cached by the identity of its bytes.
      */
-    /** The JVM keeps the cached transpose: its vectorised `[k, n]` kernels are the fast path (SKEEP-007 §T0.2). */
+    /**
+     * The common row-dot is not this tier's direct path: a dense weight goes to the native `x · Wᵀ`
+     * kernel ([matmulDenseWeightTransposedNative]) when the FFM provider is loaded, and to the cached
+     * transpose plus the vectorised `[k, n]` kernels otherwise (SKEEP-007 §T0.2).
+     */
     override fun preferDirectWeightTransposed(): Boolean = false
 
     @Suppress("UNCHECKED_CAST")
     override fun <T : DType, V> matmulWeightTransposed(x: Tensor<T, V>, weight: Tensor<T, V>): Tensor<T, V> {
         if (weight.shape.rank != 2 || !isHeapPackedWeightForJvm(weight.data)) {
+            // Dense FP32 `[out, in]` weight with a native direct kernel: multiplied in place, no
+            // transposed copy made or cached (the weight is made resident off-heap once instead).
+            matmulDenseWeightTransposedNative(x, weight)?.let { return it }
             // Packed weights OUTSIDE the JVM relayout list (the ternary formats, #1136) go to the
             // common views→KernelDispatch path — whose kernels and reference are commonMain and
             // cannot read a MemorySegment-backed activation (SKEEP-004 forbids element access over
@@ -265,6 +274,94 @@ internal class DefaultCpuOpsJvm(
     private val prepackedWeightsJvm: MutableList<Pair<ByteArray, Tensor<*, *>>> = mutableListOf()
     private val PREPACK_CACHE_LIMIT_JVM: Int = 64
 
+    /**
+     * The direct `x · Wᵀ` kernel over an off-heap weight (`skainet_fp32_matmul_wt` through FFM), from
+     * the highest-priority available provider that carries one; `null` on a JVM without the native
+     * library, where the cached-transpose path below still serves.
+     */
+    private val fp32WtKernel: Fp32MemSegMatmulWtKernel? by lazy {
+        ensureKernelProviders()
+        KernelRegistry.providers().asSequence()
+            .filter { it.isAvailable() }
+            .mapNotNull { (it as? MemSegKernelProvider)?.matmulFp32WtMemSeg() }
+            .firstOrNull()
+    }
+
+    /**
+     * Dense weights made resident off-heap for [fp32WtKernel], keyed by the identity of their
+     * `TensorData` — the counterpart of the transposed-weight cache this path replaces, holding the
+     * same bytes untransposed where a downcall can read them without a per-call copy. Bounded like
+     * that cache; an evicted weight is simply copied again on its next use. Segments come from
+     * `Arena.ofAuto()`, so a dropped entry is reclaimed with the tensor that owned it.
+     */
+    private val residentDenseWeights: MutableList<Pair<Any, java.lang.foreign.MemorySegment>> = mutableListOf()
+    private val RESIDENT_DENSE_CACHE_LIMIT: Int = 256
+
+    /**
+     * `x · Wᵀ` for a dense FP32 `[out, in]` weight through the native direct kernel — the JVM-side
+     * half of SKEEP-007 §T0.2: no transposed copy of the weight is made, the weight is read where it
+     * lies (a segment-backed weight as is, a heap one after a single off-heap copy), and the C kernel
+     * threads over output rows. `null` when the kernel is not available or the operands are not
+     * dense FP32 the kernel can take, in which case the caller continues to the cached transpose.
+     */
+    @Suppress("UNCHECKED_CAST")
+    private fun <T : DType, V> matmulDenseWeightTransposedNative(x: Tensor<T, V>, weight: Tensor<T, V>): Tensor<T, V>? {
+        if (weight.shape.rank != 2 || x.rank < 1 || x.dtype != FP32::class || weight.dtype != FP32::class) return null
+        val kernel = fp32WtKernel ?: return null
+        val n = weight.shape[0]
+        val k = weight.shape[1]
+        if (x.shape.dimensions.last() != k) return null
+        val resident = residentDenseWeight(weight, n.toLong() * k) ?: return null
+        val activation = heapActivation(x) ?: return null
+        val m = if (k == 0) 0 else x.shape.volume / k
+        val out = FloatArray(m * n)
+        if (m > 0 && n > 0) kernel.matmulWt(activation.first, activation.second, resident.first, resident.second, out, 0, m, n, k)
+        val outShape = if (x.rank == 1) Shape(n) else Shape(*(x.shape.dimensions.copyOf(x.rank - 1) + n))
+        val outData = dataFactory.adoptFloatArray<T, Float>(outShape, x.dtype, out) as TensorData<T, V>
+        return newTensor(outData, x.dtype, x, weight)
+    }
+
+    /**
+     * The activation's floats and their offset on the heap; a dense segment-backed activation is
+     * copied (it is `m × k`, small). `MemorySegmentTensorData` specifically, not the marker
+     * interface: the Q4/Q8 segment types implement that too and hold packed bytes, not floats.
+     */
+    private fun heapActivation(x: Tensor<*, *>): Pair<FloatArray, Int>? = when (val d = x.data) {
+        is FloatArrayTensorData<*> -> d.buffer to 0
+        is MemorySegmentTensorData<*> -> {
+            val count = x.shape.volume
+            val arr = FloatArray(count)
+            java.lang.foreign.MemorySegment.copy(d.segment, java.lang.foreign.ValueLayout.JAVA_FLOAT, d.segmentByteOffset, arr, 0, count)
+            arr to 0
+        }
+        else -> null
+    }
+
+    /** The weight's `floats` floats as an off-heap segment and byte offset: its own segment, or the resident copy of its heap array. */
+    private fun residentDenseWeight(weight: Tensor<*, *>, floats: Long): Pair<java.lang.foreign.MemorySegment, Long>? {
+        val bytes = floats * java.lang.Float.BYTES
+        when (val d = weight.data) {
+            is MemorySegmentTensorData<*> -> {
+                if (d.segmentByteOffset + bytes > d.segment.byteSize()) return null
+                return d.segment to d.segmentByteOffset
+            }
+            is FloatArrayTensorData<*> -> {
+                if (d.buffer.size.toLong() < floats) return null
+                synchronized(residentDenseWeights) {
+                    residentDenseWeights.firstOrNull { it.first === d }?.let { return it.second to 0L }
+                    val seg = Arena.ofAuto().allocate(maxOf(bytes, 4L), 64L)
+                    if (floats > 0) {
+                        java.lang.foreign.MemorySegment.copy(d.buffer, 0, seg, java.lang.foreign.ValueLayout.JAVA_FLOAT, 0L, floats.toInt())
+                    }
+                    if (residentDenseWeights.size >= RESIDENT_DENSE_CACHE_LIMIT) residentDenseWeights.removeAt(0)
+                    residentDenseWeights.add(Pair(d, seg))
+                    return seg to 0L
+                }
+            }
+            else -> return null
+        }
+    }
+
     /**
      * Below this many multiply-accumulates a dense FP32 matmul is faster done directly than handed
      * to the tile-blocked SPI kernel, whose per-call setup dominates at these sizes. Sized to cover
diff --git a/skainet-backends/skainet-backend-native-cpu/native/include/skainet_kernels.h b/skainet-backends/skainet-backend-native-cpu/native/include/skainet_kernels.h
index 60663bfc..89caa42f 100644
--- a/skainet-backends/skainet-backend-native-cpu/native/include/skainet_kernels.h
+++ b/skainet-backends/skainet-backend-native-cpu/native/include/skainet_kernels.h
@@ -426,6 +426,10 @@ SKAINET_API void skainet_q5_1_matmul(
  * unpacking, after which `sdot` accumulates sixteen products per instruction
  * where the core has ARMv8.2 dotprod.
  *
+ * The Emscripten sidecar runs the same block in SIMD128 (`i32x4.dot_i16x8_s` on
+ * widened halves). Output rows are split over the shared row pool once there
+ * are enough of them (#1195 pattern); bit-identical to a single thread.
+ *
  * @param activation        int8 codes of one token, `input_dim` of them
  * @param activation_scale  the token's absmax scale (`absmax / 127`)
  * @param weight            canonical TQ2_0 blocks, row-major per output row
@@ -454,9 +458,10 @@ SKAINET_API void skainet_bitnet_gemv_tq2_0(
  * input_dim must be a multiple of 4. Unlike the int8 `bitnet_gemv` path
  * there is no activation quantization: results are exact. Backed by the
  * vendored NeoGPU LUT kernel (baseline NEON, no dotprod — the fast path for
- * Cortex-A72/Pi-4 class cores); it threads internally with pthreads once
- * output_dim >= 512. A portable scalar build stands in where the vendored
- * file cannot compile (MSVC).
+ * Cortex-A72/Pi-4 class cores), driven from the shared row pool. Where the
+ * vendored file cannot compile (MSVC, the Emscripten sidecar) a portable
+ * mirror with the same compile-time LUT stands in — scalar on MSVC, SIMD128
+ * in the sidecar — threaded over output rows through the same pool.
  */
 SKAINET_API void skainet_ternary_f32_gemv(
     const float* input, int32_t input_offset,
@@ -477,7 +482,9 @@ SKAINET_API void skainet_ternary_f32_gemv(
  * plane_stride_bytes == output_dim * input_dim / 4. row_scale holds raw
  * little-endian IEEE binary16 bit patterns, one per output row (sign
  * ignored — encoders store max|row| >= 0). input_dim must be a multiple
- * of 4. Threads internally with pthreads at any output_dim.
+ * of 4. The vendored kernel threads internally with pthreads at any
+ * output_dim; the portable mirror (MSVC, Emscripten) threads over output
+ * rows through the shared row pool.
  */
 SKAINET_API void skainet_ternary_lmhead_stage1(
     const float* input, int32_t input_offset,
diff --git a/skainet-backends/skainet-backend-native-cpu/native/src/bitnet_gemv.c b/skainet-backends/skainet-backend-native-cpu/native/src/bitnet_gemv.c
index e9144287..2f187817 100644
--- a/skainet-backends/skainet-backend-native-cpu/native/src/bitnet_gemv.c
+++ b/skainet-backends/skainet-backend-native-cpu/native/src/bitnet_gemv.c
@@ -1,5 +1,6 @@
 #include "skainet_kernels.h"
 #include "skainet_simd.h"
+#include "skainet_row_threads.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -31,6 +32,17 @@
  * than it saves, and a checkpoint that is going to be run through this kernel
  * ships as TQ2_0. TQ1_0's base-3 packing is likewise scalar — it is a storage
  * format, not a runtime one.
+ *
+ * The Emscripten sidecar has the same block body in SIMD128: the unpacking is
+ * identical (shift, mask) and the sixteen int8 products go through
+ * `i32x4.dot_i16x8_s` on widened halves, the stand-in for `sdot` every other
+ * int8 kernel in the sidecar uses.
+ *
+ * Output rows are independent, so they are split over the shared row pool
+ * (skainet_row_threads.h) when there are enough of them — the mt sidecar's
+ * pthreads in a browser, the native pool elsewhere. Per-row arithmetic never
+ * changes with the partition, so the result is bit-identical to a single
+ * thread's.
  */
 
 #define SKAINET_TQ2_0_BLOCK_SIZE 256
@@ -160,7 +172,76 @@ static inline int32_t skainet_tq2_0_block_neon(
 
     return vaddvq_s32(acc);
 }
-#endif /* SKAINET_HAVE_NEON */
+#define skainet_tq2_0_block_simd skainet_tq2_0_block_neon
+#elif defined(SKAINET_HAVE_WASM_SIMD128)
+/*
+ * The NEON block in SIMD128: the same two chunks × four bit pairs, codes kept in
+ * {0,1,2} with the Σ a bias removed by the caller. `wasm_u8x16_shr` takes a
+ * runtime shift, so the strips can loop over the bit pair.
+ */
+static inline int32_t skainet_tq2_0_block_wasm(
+    const uint8_t* SKAINET_RESTRICT qs,
+    const int8_t* SKAINET_RESTRICT act) {
+    const v128_t mask = wasm_u8x16_splat(3);
+    v128_t acc = wasm_i32x4_splat(0);
+    for (int32_t c = 0; c < 2; ++c) {
+        const v128_t lo = wasm_v128_load(qs + c * 32);
+        const v128_t hi = wasm_v128_load(qs + c * 32 + 16);
+        for (int32_t l = 0; l < 4; ++l) {
+            const v128_t wlo = wasm_v128_and(wasm_u8x16_shr(lo, (uint32_t) (2 * l)), mask);
+            const v128_t whi = wasm_v128_and(wasm_u8x16_shr(hi, (uint32_t) (2 * l)), mask);
+            const int8_t* a = act + c * 128 + l * 32;
+            acc = wasm_i32x4_add(acc, skainet_wasm_dot_u8x16_i8x16(wlo, wasm_v128_load(a)));
+            acc = wasm_i32x4_add(acc, skainet_wasm_dot_u8x16_i8x16(whi, wasm_v128_load(a + 16)));
+        }
+    }
+    return skainet_wasm_hadd_i32(acc);
+}
+#define skainet_tq2_0_block_simd skainet_tq2_0_block_wasm
+#endif /* SKAINET_HAVE_NEON / SKAINET_HAVE_WASM_SIMD128 */
+
+typedef struct {
+    const int8_t* act;
+    const uint8_t* w;
+    const int32_t* activation_sums;
+    float* out;
+    float activation_scale;
+    int32_t input_dim;
+    int32_t blocks_per_row;
+} skainet_bitnet_gemv_job;
+
+/* Output rows [o_start, o_end): every block of the row, scaled and summed. */
+static void skainet_bitnet_gemv_rows(void* ctx, int32_t o_start, int32_t o_end) {
+    const skainet_bitnet_gemv_job* j = (const skainet_bitnet_gemv_job*) ctx;
+    const int8_t* act = j->act;
+    const int32_t input_dim = j->input_dim;
+    const int32_t blocks_per_row = j->blocks_per_row;
+    for (int32_t o = o_start; o < o_end; ++o) {
+        float sum = 0.0f;
+        for (int32_t b = 0; b < blocks_per_row; ++b) {
+            const uint8_t* block = j->w + (size_t)(o * blocks_per_row + b) * SKAINET_TQ2_0_BYTES_PER_BLOCK;
+            const int32_t first = b * SKAINET_TQ2_0_BLOCK_SIZE;
+            const int32_t count = (input_dim - first) < SKAINET_TQ2_0_BLOCK_SIZE
+                ? (input_dim - first)
+                : SKAINET_TQ2_0_BLOCK_SIZE;
+            uint16_t scale_bits;
+            memcpy(&scale_bits, block + 64, sizeof(scale_bits));
+            const float d = skainet_bitnet_fp16(scale_bits);
+            int32_t partial;
+#ifdef skainet_tq2_0_block_simd
+            if (count == SKAINET_TQ2_0_BLOCK_SIZE) {
+                partial = skainet_tq2_0_block_simd(block, act + first) - j->activation_sums[b];
+            } else {
+                partial = skainet_tq2_0_block_scalar(block, act + first, count);
+            }
+#else
+            partial = skainet_tq2_0_block_scalar(block, act + first, count);
+#endif
+            sum += (float)partial * d;
+        }
+        j->out[o] = sum * j->activation_scale;
+    }
+}
 
 SKAINET_API void skainet_bitnet_gemv_tq2_0(
     const int8_t* SKAINET_RESTRICT activation, int32_t activation_offset,
@@ -203,30 +284,14 @@ SKAINET_API void skainet_bitnet_gemv_tq2_0(
         activation_sums[b] = s;
     }
 
-    for (int32_t o = 0; o < output_dim; ++o) {
-        float sum = 0.0f;
-        for (int32_t b = 0; b < blocks_per_row; ++b) {
-            const uint8_t* block = w + (size_t)(o * blocks_per_row + b) * SKAINET_TQ2_0_BYTES_PER_BLOCK;
-            const int32_t first = b * SKAINET_TQ2_0_BLOCK_SIZE;
-            const int32_t count = (input_dim - first) < SKAINET_TQ2_0_BLOCK_SIZE
-                ? (input_dim - first)
-                : SKAINET_TQ2_0_BLOCK_SIZE;
-            uint16_t scale_bits;
-            memcpy(&scale_bits, block + 64, sizeof(scale_bits));
-            const float d = skainet_bitnet_fp16(scale_bits);
-            int32_t partial;
-#if defined(SKAINET_HAVE_NEON)
-            if (count == SKAINET_TQ2_0_BLOCK_SIZE) {
-                partial = skainet_tq2_0_block_neon(block, act + first) - activation_sums[b];
-            } else {
-                partial = skainet_tq2_0_block_scalar(block, act + first, count);
-            }
-#else
-            partial = skainet_tq2_0_block_scalar(block, act + first, count);
-#endif
-            sum += (float)partial * d;
-        }
-        output[output_offset + o] = sum * activation_scale;
-    }
+    skainet_bitnet_gemv_job job;
+    job.act = act;
+    job.w = w;
+    job.activation_sums = activation_sums;
+    job.out = output + output_offset;
+    job.activation_scale = activation_scale;
+    job.input_dim = input_dim;
+    job.blocks_per_row = blocks_per_row;
+    skainet_run_rows(skainet_bitnet_gemv_rows, &job, output_dim);
     free(heap_sums);
 }
diff --git a/skainet-backends/skainet-backend-native-cpu/native/src/skainet_ternary_f32.c b/skainet-backends/skainet-backend-native-cpu/native/src/skainet_ternary_f32.c
index b9cf2824..cdf4015a 100644
--- a/skainet-backends/skainet-backend-native-cpu/native/src/skainet_ternary_f32.c
+++ b/skainet-backends/skainet-backend-native-cpu/native/src/skainet_ternary_f32.c
@@ -6,10 +6,13 @@
  * pthread_once warm-up, so first use is race-free under any threading.
  *
  * The vendored file needs pthreads and GNU/Clang builtins, so it is only in
- * the build where SKAINET_HAVE_NEOGPU_TERNARY is defined (non-MSVC). The
- * fallback branch below is a portable scalar mirror with identical semantics,
- * including the byte-code-3 → +2.0 decode (loaders reject code 3 at import;
- * the kernel contract is "garbage in, garbage out", never a crash).
+ * the build where SKAINET_HAVE_NEOGPU_TERNARY is defined (non-MSVC native
+ * builds). The other branch below is a portable mirror with identical
+ * semantics, including the byte-code-3 → +2.0 decode (loaders reject code 3
+ * at import; the kernel contract is "garbage in, garbage out", never a
+ * crash). It is what MSVC and the Emscripten sidecar compile: the same
+ * 256-entry LUT as a compile-time constant (no init guard to race on), a
+ * SIMD128 body in the sidecar, and the shared row pool for threading.
  */
 
 #include "skainet_kernels.h"
@@ -108,12 +111,92 @@ void skainet_ternary_lmhead_stage1(
         (uint32_t)input_dim);
 }
 
-#else /* !SKAINET_HAVE_NEOGPU_TERNARY — portable scalar mirror (MSVC etc.) */
+#else /* !SKAINET_HAVE_NEOGPU_TERNARY — portable mirror (MSVC, Emscripten) */
 
-/* decode(byte, lane) = ((byte >> (lane*2)) & 3) - 1, exactly the vendored LUT
- * (so byte code 3 yields +2, matching TernaryCodec.decodeBitNet). */
-static float skainet_ternary_decode(uint8_t b, int lane) {
-    return (float)((int)((b >> (lane * 2)) & 3) - 1);
+#include "skainet_simd.h"
+#include "skainet_row_threads.h"
+
+/*
+ * decode(byte, lane) = ((byte >> (lane*2)) & 3) - 1 — exactly the vendored
+ * LUT (so byte code 3 yields +2, matching TernaryCodec.decodeBitNet), as a
+ * compile-time constant: one 16-byte row per weight byte, the four decoded
+ * codes of its four elements. The vendored file builds the same table on
+ * first use behind a non-atomic flag; a constant needs no guard, which is
+ * what makes the row pool below safe without pthread_once.
+ */
+#define SKAINET_TERNARY_D(b, lane) ((float) ((int) (((b) >> ((lane) * 2)) & 3) - 1))
+#define SKAINET_TERNARY_E(b) \
+    { SKAINET_TERNARY_D(b, 0), SKAINET_TERNARY_D(b, 1), SKAINET_TERNARY_D(b, 2), SKAINET_TERNARY_D(b, 3) }
+#define SKAINET_TERNARY_E16(b) \
+    SKAINET_TERNARY_E(b + 0),  SKAINET_TERNARY_E(b + 1),  SKAINET_TERNARY_E(b + 2),  SKAINET_TERNARY_E(b + 3), \
+    SKAINET_TERNARY_E(b + 4),  SKAINET_TERNARY_E(b + 5),  SKAINET_TERNARY_E(b + 6),  SKAINET_TERNARY_E(b + 7), \
+    SKAINET_TERNARY_E(b + 8),  SKAINET_TERNARY_E(b + 9),  SKAINET_TERNARY_E(b + 10), SKAINET_TERNARY_E(b + 11), \
+    SKAINET_TERNARY_E(b + 12), SKAINET_TERNARY_E(b + 13), SKAINET_TERNARY_E(b + 14), SKAINET_TERNARY_E(b + 15)
+
+static const float skainet_ternary_lut[256][4] = {
+    SKAINET_TERNARY_E16(0),   SKAINET_TERNARY_E16(16),  SKAINET_TERNARY_E16(32),  SKAINET_TERNARY_E16(48),
+    SKAINET_TERNARY_E16(64),  SKAINET_TERNARY_E16(80),  SKAINET_TERNARY_E16(96),  SKAINET_TERNARY_E16(112),
+    SKAINET_TERNARY_E16(128), SKAINET_TERNARY_E16(144), SKAINET_TERNARY_E16(160), SKAINET_TERNARY_E16(176),
+    SKAINET_TERNARY_E16(192), SKAINET_TERNARY_E16(208), SKAINET_TERNARY_E16(224), SKAINET_TERNARY_E16(240),
+};
+
+#undef SKAINET_TERNARY_E16
+#undef SKAINET_TERNARY_E
+#undef SKAINET_TERNARY_D
+
+/* FP16 row scale decode, same bit arithmetic as the vendored file (sign
+ * ignored — encoders store max|row| >= 0). */
+static inline float skainet_ternary_row_scale(uint16_t h16) {
+    const uint32_t eu = (h16 >> 10) & 0x1Fu;
+    const uint32_t mu = h16 & 0x03FFu;
+    const uint32_t fu = ((eu + 112u) << 23) | (mu << 13);
+    float rsc;
+    memcpy(&rsc, &fu, 4);
+    return rsc;
+}
+
+typedef struct {
+    float* out;
+    const float* in;
+    const uint8_t* w;
+    int32_t row_bytes;
+} skainet_ternary_gemv_job;
+
+/* out[o] = Σ_bi lut[w[o][bi]] · in[bi*4 .. bi*4+3] for rows [o_start, o_end). */
+static void skainet_ternary_gemv_rows(void* ctx, int32_t o_start, int32_t o_end) {
+    const skainet_ternary_gemv_job* j = (const skainet_ternary_gemv_job*) ctx;
+    const float* in = j->in;
+    const int32_t row_bytes = j->row_bytes;
+    for (int32_t o = o_start; o < o_end; ++o) {
+        const uint8_t* wrow = j->w + (size_t) o * row_bytes;
+#ifdef SKAINET_HAVE_WASM_SIMD128
+        /* One LUT row is one f32x4 of decoded codes against four activations:
+         * a load, a multiply and an add per weight byte. Four accumulators
+         * keep the adds independent; the vendored NEON body does the same. */
+        v128_t acc0 = wasm_f32x4_splat(0.0f), acc1 = acc0, acc2 = acc0, acc3 = acc0;
+        int32_t bi = 0;
+        for (; bi + 4 <= row_bytes; bi += 4) {
+            acc0 = wasm_f32x4_add(acc0, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[wrow[bi]]), wasm_v128_load(in + (size_t) bi * 4)));
+            acc1 = wasm_f32x4_add(acc1, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[wrow[bi + 1]]), wasm_v128_load(in + (size_t) bi * 4 + 4)));
+            acc2 = wasm_f32x4_add(acc2, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[wrow[bi + 2]]), wasm_v128_load(in + (size_t) bi * 4 + 8)));
+            acc3 = wasm_f32x4_add(acc3, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[wrow[bi + 3]]), wasm_v128_load(in + (size_t) bi * 4 + 12)));
+        }
+        for (; bi < row_bytes; ++bi) {
+            acc0 = wasm_f32x4_add(acc0, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[wrow[bi]]), wasm_v128_load(in + (size_t) bi * 4)));
+        }
+        j->out[o] = skainet_wasm_hadd_f32(wasm_f32x4_add(wasm_f32x4_add(acc0, acc1), wasm_f32x4_add(acc2, acc3)));
+#else
+        float acc = 0.0f;
+        for (int32_t bi = 0; bi < row_bytes; ++bi) {
+            const float* d = skainet_ternary_lut[wrow[bi]];
+            acc += d[0] * in[bi * 4    ];
+            acc += d[1] * in[bi * 4 + 1];
+            acc += d[2] * in[bi * 4 + 2];
+            acc += d[3] * in[bi * 4 + 3];
+        }
+        j->out[o] = acc;
+#endif
+    }
 }
 
 void skainet_ternary_f32_gemv(
@@ -123,20 +206,76 @@ void skainet_ternary_f32_gemv(
     float* output, int32_t output_offset)
 {
     if (output_dim <= 0) return;
-    const float* in = input + input_offset;
-    const uint8_t* w = weight + weight_byte_offset;
-    const int32_t row_bytes = input_dim / 4;
-    for (int32_t n = 0; n < output_dim; n++) {
-        const uint8_t* wrow = w + (size_t)n * row_bytes;
-        float acc = 0.0f;
-        for (int32_t bi = 0; bi < row_bytes; bi++) {
-            const uint8_t b = wrow[bi];
-            acc += skainet_ternary_decode(b, 0) * in[bi * 4    ];
-            acc += skainet_ternary_decode(b, 1) * in[bi * 4 + 1];
-            acc += skainet_ternary_decode(b, 2) * in[bi * 4 + 2];
-            acc += skainet_ternary_decode(b, 3) * in[bi * 4 + 3];
+    skainet_ternary_gemv_job job = {
+        output + output_offset,
+        input + input_offset,
+        weight + weight_byte_offset,
+        input_dim / 4,
+    };
+    /* input_dim == 0: row_bytes 0, every row is written as 0.0f. */
+    skainet_run_rows(skainet_ternary_gemv_rows, &job, output_dim);
+}
+
+typedef struct {
+    float* out;
+    const float* in;
+    const uint8_t* p0;
+    const uint8_t* p1;
+    const uint8_t* p2;
+    const uint8_t* p3;
+    const uint16_t* row_scale;
+    int32_t row_bytes;
+} skainet_ternary_lmhead_job;
+
+/* out[o] = rs[o] · Σ_bi (lut[p0] + lut[p1]/3 + lut[p2]/9 + lut[p3]/27) · in[bi*4 ..]. */
+static void skainet_ternary_lmhead_rows(void* ctx, int32_t o_start, int32_t o_end) {
+    const skainet_ternary_lmhead_job* j = (const skainet_ternary_lmhead_job*) ctx;
+    const float* in = j->in;
+    const int32_t row_bytes = j->row_bytes;
+    const float w1 = 1.0f / 3.0f, w2 = 1.0f / 9.0f, w3 = 1.0f / 27.0f;
+    for (int32_t o = o_start; o < o_end; ++o) {
+        const uint8_t* r0 = j->p0 + (size_t) o * row_bytes;
+        const uint8_t* r1 = j->p1 + (size_t) o * row_bytes;
+        const uint8_t* r2 = j->p2 + (size_t) o * row_bytes;
+        const uint8_t* r3 = j->p3 + (size_t) o * row_bytes;
+#ifdef SKAINET_HAVE_WASM_SIMD128
+        const v128_t vw1 = wasm_f32x4_splat(w1), vw2 = wasm_f32x4_splat(w2), vw3 = wasm_f32x4_splat(w3);
+        v128_t acc0 = wasm_f32x4_splat(0.0f), acc1 = acc0;
+        int32_t bi = 0;
+        for (; bi + 2 <= row_bytes; bi += 2) {
+            v128_t u0 = wasm_v128_load(skainet_ternary_lut[r0[bi]]);
+            u0 = wasm_f32x4_add(u0, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r1[bi]]), vw1));
+            u0 = wasm_f32x4_add(u0, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r2[bi]]), vw2));
+            u0 = wasm_f32x4_add(u0, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r3[bi]]), vw3));
+            acc0 = wasm_f32x4_add(acc0, wasm_f32x4_mul(u0, wasm_v128_load(in + (size_t) bi * 4)));
+            v128_t u1 = wasm_v128_load(skainet_ternary_lut[r0[bi + 1]]);
+            u1 = wasm_f32x4_add(u1, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r1[bi + 1]]), vw1));
+            u1 = wasm_f32x4_add(u1, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r2[bi + 1]]), vw2));
+            u1 = wasm_f32x4_add(u1, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r3[bi + 1]]), vw3));
+            acc1 = wasm_f32x4_add(acc1, wasm_f32x4_mul(u1, wasm_v128_load(in + (size_t) bi * 4 + 4)));
         }
-        output[output_offset + n] = acc;
+        for (; bi < row_bytes; ++bi) {
+            v128_t u = wasm_v128_load(skainet_ternary_lut[r0[bi]]);
+            u = wasm_f32x4_add(u, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r1[bi]]), vw1));
+            u = wasm_f32x4_add(u, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r2[bi]]), vw2));
+            u = wasm_f32x4_add(u, wasm_f32x4_mul(wasm_v128_load(skainet_ternary_lut[r3[bi]]), vw3));
+            acc0 = wasm_f32x4_add(acc0, wasm_f32x4_mul(u, wasm_v128_load(in + (size_t) bi * 4)));
+        }
+        const float s = skainet_wasm_hadd_f32(wasm_f32x4_add(acc0, acc1));
+#else
+        float s = 0.0f;
+        for (int32_t bi = 0; bi < row_bytes; ++bi) {
+            const float* d0 = skainet_ternary_lut[r0[bi]];
+            const float* d1 = skainet_ternary_lut[r1[bi]];
+            const float* d2 = skainet_ternary_lut[r2[bi]];
+            const float* d3 = skainet_ternary_lut[r3[bi]];
+            for (int lane = 0; lane < 4; ++lane) {
+                const float u = d0[lane] + d1[lane] * w1 + d2[lane] * w2 + d3[lane] * w3;
+                s += u * in[bi * 4 + lane];
+            }
+        }
+#endif
+        j->out[o] = s * skainet_ternary_row_scale(j->row_scale[o]);
     }
 }
 
@@ -148,34 +287,18 @@ void skainet_ternary_lmhead_stage1(
     float* output, int32_t output_offset)
 {
     if (output_dim <= 0) return;
-    const float* in = input + input_offset;
     const uint8_t* base = planes + planes_byte_offset;
-    const uint16_t* rs = row_scale + row_scale_offset;
-    const int32_t row_bytes = input_dim / 4;
-    const float pw[4] = { 1.0f, 1.0f / 3.0f, 1.0f / 9.0f, 1.0f / 27.0f };
-    for (int32_t n = 0; n < output_dim; n++) {
-        float acc = 0.0f;
-        for (int32_t bi = 0; bi < row_bytes; bi++) {
-            for (int lane = 0; lane < 4; lane++) {
-                float u = 0.0f;
-                for (int p = 0; p < 4; p++) {
-                    const uint8_t b =
-                        base[(size_t)plane_stride_bytes * p + (size_t)n * row_bytes + bi];
-                    u += skainet_ternary_decode(b, lane) * pw[p];
-                }
-                acc += u * in[bi * 4 + lane];
-            }
-        }
-        /* FP16 row scale decode, same bit arithmetic as the vendored file
-         * (sign ignored — encoders store max|row| >= 0). */
-        const uint32_t h16 = rs[n];
-        const uint32_t eu = (h16 >> 10) & 0x1Fu;
-        const uint32_t mu = h16 & 0x03FFu;
-        const uint32_t fu = ((eu + 112u) << 23) | (mu << 13);
-        float rsc;
-        memcpy(&rsc, &fu, 4);
-        output[output_offset + n] = acc * rsc;
-    }
+    skainet_ternary_lmhead_job job = {
+        output + output_offset,
+        input + input_offset,
+        base,
+        base + (size_t) plane_stride_bytes,
+        base + (size_t) plane_stride_bytes * 2,
+        base + (size_t) plane_stride_bytes * 3,
+        row_scale + row_scale_offset,
+        input_dim / 4,
+    };
+    skainet_run_rows(skainet_ternary_lmhead_rows, &job, output_dim);
 }
 
 #endif /* SKAINET_HAVE_NEOGPU_TERNARY */
diff --git a/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernel.kt b/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernel.kt
new file mode 100644
index 00000000..1ec68d77
--- /dev/null
+++ b/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernel.kt
@@ -0,0 +1,116 @@
+package sk.ainet.exec.kernel
+
+import java.lang.foreign.Arena
+import java.lang.foreign.FunctionDescriptor
+import java.lang.foreign.Linker
+import java.lang.foreign.MemorySegment
+import java.lang.foreign.ValueLayout
+import java.lang.invoke.MethodHandle
+import sk.ainet.backend.api.kernel.Fp32MatmulWtKernel
+import sk.ainet.backend.api.kernel.Fp32MemSegMatmulWtKernel
+
+/**
+ * Native (FFM) `x · Wᵀ` over a row-major `[out, in]` FP32 weight — the JVM binding of
+ *
+ *   void skainet_fp32_matmul_wt(
+ *       const float* in, int32_t in_offset,
+ *       const float* w,  int32_t w_offset,
+ *       float* out,      int32_t out_offset,
+ *       int32_t m, int32_t n, int32_t k);
+ *
+ * which the wasm sidecar has served since 0.61.0 and the JVM never bound: `DefaultCpuOpsJvm`
+ * transposed every dense weight once into `[k, n]` for the GEMM kernels and cached the copy. The C
+ * kernel computes every output as one contiguous dot product over the weight's own row (NEON or
+ * auto-vectorised portable body, four rows per tile), threads over output rows through the shared
+ * row pool, and accumulates in ascending `p` — bit-identical to transpose-then-GEMM.
+ *
+ * Two faces. The heap face ([Fp32MatmulWtKernel]) stages both operands off-heap per call, like
+ * [NativeFp32MatmulKernel]; for a decode step that copy is the weight, so it is the slow one. The
+ * segment face ([Fp32MemSegMatmulWtKernel]) takes the weight where it lies and copies only the
+ * `m × k` activation and the `m × n` output, which is what the ops layer uses once it has made a
+ * weight resident off-heap (the JVM counterpart of the sidecar's resident dense weights).
+ */
+internal object NativeFp32MatmulWtKernel : Fp32MatmulWtKernel, Fp32MemSegMatmulWtKernel {
+
+    fun isAvailable(): Boolean = handle != null
+
+    override fun matmulWt(
+        x: FloatArray, xOffset: Int,
+        w: FloatArray, wOffset: Int,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    ) {
+        require(m >= 0 && n >= 0 && k >= 0) { "NativeFp32MatmulWtKernel: m, n, k must be non-negative; got m=$m n=$n k=$k" }
+        if (m == 0 || n == 0) return
+        val mh = handle ?: error("NativeFp32MatmulWtKernel invoked while native library unavailable")
+        val wFloats = n.toLong() * k
+        require(wOffset >= 0 && wOffset + wFloats <= w.size) {
+            "NativeFp32MatmulWtKernel: weight needs $wFloats floats from $wOffset, array has ${w.size}"
+        }
+        Arena.ofConfined().use { arena ->
+            val align = ValueLayout.JAVA_FLOAT.byteAlignment()
+            val wSeg: MemorySegment = if (wFloats > 0) arena.allocate(wFloats * java.lang.Float.BYTES, align) else MemorySegment.NULL
+            if (wFloats > 0) MemorySegment.copy(w, wOffset, wSeg, ValueLayout.JAVA_FLOAT, 0L, wFloats.toInt())
+            invoke(mh, arena, x, xOffset, wSeg, out, outOffset, m, n, k)
+        }
+    }
+
+    override fun matmulWt(
+        x: FloatArray, xOffset: Int,
+        weight: MemorySegment, weightByteOffset: Long,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    ) {
+        require(m >= 0 && n >= 0 && k >= 0) { "NativeFp32MatmulWtKernel: m, n, k must be non-negative; got m=$m n=$n k=$k" }
+        if (m == 0 || n == 0) return
+        val mh = handle ?: error("NativeFp32MatmulWtKernel invoked while native library unavailable")
+        val wBytes = n.toLong() * k * java.lang.Float.BYTES
+        require(weightByteOffset >= 0 && weightByteOffset + wBytes <= weight.byteSize()) {
+            "NativeFp32MatmulWtKernel: weight segment too small — needs $wBytes bytes from offset " +
+                "$weightByteOffset, segment is ${weight.byteSize()} bytes"
+        }
+        Arena.ofConfined().use { arena ->
+            invoke(mh, arena, x, xOffset, if (wBytes > 0) weight.asSlice(weightByteOffset) else MemorySegment.NULL, out, outOffset, m, n, k)
+        }
+    }
+
+    /** Stage the activation and the output, run, copy the output back. The weight is already a segment. */
+    private fun invoke(
+        mh: MethodHandle, arena: Arena,
+        x: FloatArray, xOffset: Int, wSeg: MemorySegment,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    ) {
+        val xFloats = m.toLong() * k
+        val outFloats = m.toLong() * n
+        require(xOffset >= 0 && xOffset + xFloats <= x.size) {
+            "NativeFp32MatmulWtKernel: activation needs $xFloats floats from $xOffset, array has ${x.size}"
+        }
+        require(outOffset >= 0 && outOffset + outFloats <= out.size) {
+            "NativeFp32MatmulWtKernel: output needs $outFloats floats from $outOffset, array has ${out.size}"
+        }
+        val align = ValueLayout.JAVA_FLOAT.byteAlignment()
+        val xSeg: MemorySegment = if (xFloats > 0) arena.allocate(xFloats * java.lang.Float.BYTES, align) else MemorySegment.NULL
+        val outSeg: MemorySegment = arena.allocate(outFloats * java.lang.Float.BYTES, align)
+        if (xFloats > 0) MemorySegment.copy(x, xOffset, xSeg, ValueLayout.JAVA_FLOAT, 0L, xFloats.toInt())
+        mh.invoke(xSeg, 0, wSeg, 0, outSeg, 0, m, n, k)
+        MemorySegment.copy(outSeg, ValueLayout.JAVA_FLOAT, 0L, out, outOffset, outFloats.toInt())
+    }
+
+    private val handle: MethodHandle? by lazy {
+        val lookup = NativeLibraryLoader.lookup() ?: return@lazy null
+        val symbol = lookup.find("skainet_fp32_matmul_wt").orElse(null) ?: return@lazy null
+        val descriptor = FunctionDescriptor.ofVoid(
+            ValueLayout.ADDRESS,    // in
+            ValueLayout.JAVA_INT,   // in_offset
+            ValueLayout.ADDRESS,    // w
+            ValueLayout.JAVA_INT,   // w_offset
+            ValueLayout.ADDRESS,    // out
+            ValueLayout.JAVA_INT,   // out_offset
+            ValueLayout.JAVA_INT,   // m
+            ValueLayout.JAVA_INT,   // n
+            ValueLayout.JAVA_INT,   // k
+        )
+        runCatching { Linker.nativeLinker().downcallHandle(symbol, descriptor) }.getOrNull()
+    }
+}
diff --git a/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeKernelProvider.kt b/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeKernelProvider.kt
index cff68465..08011ba3 100644
--- a/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeKernelProvider.kt
+++ b/skainet-backends/skainet-backend-native-cpu/src/jvmMain/kotlin/sk/ainet/exec/kernel/NativeKernelProvider.kt
@@ -3,6 +3,8 @@ package sk.ainet.exec.kernel
 import sk.ainet.backend.api.kernel.Bf16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp32MatmulKernel
+import sk.ainet.backend.api.kernel.Fp32MatmulWtKernel
+import sk.ainet.backend.api.kernel.Fp32MemSegMatmulWtKernel
 import sk.ainet.backend.api.kernel.KernelProvider
 import sk.ainet.backend.api.kernel.MemSegKernelProvider
 import sk.ainet.backend.api.kernel.Q4KMatmulKernel
@@ -82,6 +84,9 @@ import sk.ainet.backend.api.kernel.Q8_0MatmulKernel
  *    Every narrow-float accessor the SPI declares is wired here; a format
  *    served natively on one side and by the JVM fallback on the other looks
  *    like a slow kernel rather than a missing one.
+ *  - Now: the direct `x · Wᵀ` kernel (`skainet_fp32_matmul_wt`) in
+ *    [matmulFp32Wt] and its segment face [matmulFp32WtMemSeg], so a dense
+ *    `[out, in]` weight is multiplied in place instead of transposed and cached.
  */
 public object NativeKernelProvider : KernelProvider, MemSegKernelProvider {
     override val name: String = "native-ffm"
@@ -92,6 +97,12 @@ public object NativeKernelProvider : KernelProvider, MemSegKernelProvider {
     override fun matmulFp32(): Fp32MatmulKernel? =
         if (NativeFp32MatmulKernel.isAvailable()) NativeFp32MatmulKernel else null
 
+    override fun matmulFp32Wt(): Fp32MatmulWtKernel? =
+        if (NativeFp32MatmulWtKernel.isAvailable()) NativeFp32MatmulWtKernel else null
+
+    override fun matmulFp32WtMemSeg(): Fp32MemSegMatmulWtKernel? =
+        if (NativeFp32MatmulWtKernel.isAvailable()) NativeFp32MatmulWtKernel else null
+
     override fun matmulQ4K(): Q4KMatmulKernel? =
         if (NativeQ4KMatmulKernel.isAvailable()) NativeQ4KMatmulKernel else null
 
diff --git a/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/JvmDirectWeightTransposedTest.kt b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/JvmDirectWeightTransposedTest.kt
new file mode 100644
index 00000000..80662290
--- /dev/null
+++ b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/JvmDirectWeightTransposedTest.kt
@@ -0,0 +1,79 @@
+package sk.ainet.exec.kernel
+
+import kotlin.math.abs
+import kotlin.random.Random
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import sk.ainet.backend.api.kernel.KernelRegistry
+import sk.ainet.backend.api.kernel.KernelServiceLoader
+import sk.ainet.context.DirectCpuExecutionContext
+import sk.ainet.lang.tensor.Shape
+import sk.ainet.lang.tensor.Tensor
+import sk.ainet.lang.tensor.data.MemorySegmentBackedData
+import sk.ainet.lang.tensor.data.MemorySegmentTensorDataFactory
+import sk.ainet.lang.types.FP32
+
+/**
+ * `x · Wᵀ` on the JVM ops layer with a dense `[out, in]` weight goes through the native direct
+ * kernel (`skainet_fp32_matmul_wt`) when the FFM provider is loaded — heap weights after one
+ * resident off-heap copy, segment-backed weights where they lie — and agrees with the
+ * transpose-then-matmul result it replaces, for every activation rank a `Linear` layer sees.
+ */
+class JvmDirectWeightTransposedTest {
+
+    @BeforeTest
+    fun setUp() {
+        KernelRegistry.clearForTesting()
+        KernelServiceLoader.installAll()
+        assertTrue(NativeFp32MatmulWtKernel.isAvailable(), "bundled libskainet_kernels must resolve")
+    }
+
+    @AfterTest
+    fun tearDown() = KernelRegistry.clearForTesting()
+
+    private fun assertClose(expected: FloatArray, actual: FloatArray, what: String) {
+        assertEquals(expected.size, actual.size, "$what size")
+        var maxAbs = 0f
+        for (v in expected) maxAbs = maxOf(maxAbs, abs(v))
+        val tol = maxAbs * 1e-5f + 1e-6f
+        for (i in expected.indices) {
+            assertTrue(abs(expected[i] - actual[i]) <= tol, "$what[$i]: ${actual[i]} vs ${expected[i]} (tol $tol)")
+        }
+    }
+
+    private fun check(ctx: DirectCpuExecutionContext, xShape: Shape, n: Int, seed: Int, what: String) {
+        val rng = Random(seed)
+        val k = xShape.dimensions.last()
+        val x: Tensor<FP32, Float> = ctx.fromFloatArray(xShape, FP32::class, FloatArray(xShape.volume) { rng.nextFloat() - 0.5f })
+        val w: Tensor<FP32, Float> = ctx.fromFloatArray(Shape(n, k), FP32::class, FloatArray(n * k) { rng.nextFloat() - 0.5f })
+        val got = ctx.ops.matmulWeightTransposed(x, w)
+        val expectedShape = if (xShape.rank == 1) Shape(n) else Shape(*(xShape.dimensions.copyOf(xShape.rank - 1) + n))
+        assertEquals(expectedShape, got.shape, "$what shape")
+        val expected = ctx.ops.matmul(x, ctx.ops.transpose(w)).data.copyToFloatArray()
+        assertClose(expected, got.data.copyToFloatArray(), what)
+        // A second call reuses the resident weight: same answer.
+        assertClose(expected, ctx.ops.matmulWeightTransposed(x, w).data.copyToFloatArray(), "$what again")
+    }
+
+    @Test
+    fun heap_weights_match_transpose_then_matmul_for_every_activation_rank() {
+        val ctx = DirectCpuExecutionContext()
+        assertEquals("native-ffm", KernelRegistry.bestAvailable()?.name, "the FFM provider must win on this runner")
+        check(ctx, Shape(40), 70, 1, "rank-1")
+        check(ctx, Shape(3, 40), 70, 2, "rank-2")
+        check(ctx, Shape(2, 3, 40), 600, 3, "rank-3, threaded rows")
+        check(ctx, Shape(1, 1), 1, 4, "1×1")
+    }
+
+    @Test
+    fun segment_backed_weights_are_read_where_they_lie() {
+        val ctx = DirectCpuExecutionContext(tensorDataFactory = MemorySegmentTensorDataFactory())
+        val w: Tensor<FP32, Float> = ctx.fromFloatArray(Shape(5, 8), FP32::class, FloatArray(40) { it.toFloat() })
+        assertTrue(w.data is MemorySegmentBackedData, "this factory stages tensors off-heap: ${w.data::class.simpleName}")
+        check(ctx, Shape(4, 32), 48, 5, "segment-backed")
+        check(ctx, Shape(32), 520, 6, "segment-backed rank-1, threaded rows")
+    }
+}
diff --git a/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/KernelSupportMatrixTest.kt b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/KernelSupportMatrixTest.kt
index 84bf97d5..ce2fc048 100644
--- a/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/KernelSupportMatrixTest.kt
+++ b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/KernelSupportMatrixTest.kt
@@ -4,6 +4,7 @@ import java.io.File
 import kotlin.test.AfterTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 import sk.ainet.backend.api.kernel.KernelDispatch
 import sk.ainet.backend.api.kernel.KernelProvider
 import sk.ainet.lang.memory.plan.StorageCapabilities
@@ -106,6 +107,34 @@ class KernelSupportMatrixTest {
         Tier("ffm-rowmajor", 100, setOf("JVM"), KernelDispatch.mappedServableEncodings().map { it.name }.toSet()),
     )
 
+    /**
+     * Kernel packs (view dispatch): the ternary formats and the direct dense `x · Wᵀ` are not served
+     * through the `matmul` accessors the tables above introspect — the ternary kernels are
+     * `ViewKernelPack`s keyed in `KernelDispatch` (`FfmTernaryKernelPackFactory`, the JNI ternary pack,
+     * `NativeKnTernaryF32Gemv` / `NativeKnTernaryLmhead`, `WasmTernaryKernelPack`), and `x · Wᵀ` is the
+     * `matmulFp32Wt` accessor the ops layer consults before transposing a weight. Hand-declared per
+     * platform like the Android rows; the JVM cells are gated below against what the FFM provider and
+     * pack actually expose on this runner. Row names are the encodings as `TensorEncoding.name` spells
+     * them, plus the dense direct product.
+     */
+    private val packRows = listOf(
+        TensorEncoding.BITNET_B1_58.name + " (FP32 activations)",
+        TensorEncoding.BITNET_PLANES.name,
+        TensorEncoding.TQ2_0.name + " (int8 activations)",
+        "Float32 x·Wᵀ direct",
+    )
+
+    private fun packTiers(): List<Tier> {
+        val b158 = packRows[0]; val planes = packRows[1]; val tq2 = packRows[2]; val wt = packRows[3]
+        return listOf(
+            Tier("ffm-ternary", 100, setOf("JVM"), setOf(b158, planes)),
+            Tier("native-ffm", 100, setOf("JVM"), setOf(wt)),
+            Tier("native-jni", 100, setOf("Android"), setOf(b158, planes, tq2)),
+            Tier("native-cinterop", 100, setOf("Native·linux", "Native·apple"), setOf(b158, planes)),
+            Tier("wasm-simd128", 50, setOf("JS/WASM"), setOf(b158, planes, tq2, wt)),
+        )
+    }
+
     private fun best(fmt: String, platform: String, tiers: List<Tier>): String? =
         tiers.filter { platform in it.platforms && fmt in it.formats }.maxByOrNull { it.priority }?.name
 
@@ -145,6 +174,15 @@ class KernelSupportMatrixTest {
                 .append(cells.joinToString(", ")).append("}}")
             sb.append(if (i == residentFormats.lastIndex) "\n" else ",\n")
         }
+        sb.append("  ],\n")
+        val packs = packTiers()
+        sb.append("  \"packs\": [\n")
+        packRows.forEachIndexed { i, fmt ->
+            val cells = platforms.mapNotNull { p -> best(fmt, p, packs)?.let { "\"$p\": \"$it\"" } }
+            sb.append("    {\"name\": \"").append(fmt).append("\", \"byPlatform\": {")
+                .append(cells.joinToString(", ")).append("}}")
+            sb.append(if (i == packRows.lastIndex) "\n" else ",\n")
+        }
         sb.append("  ]\n}\n")
         return sb.toString()
     }
@@ -189,6 +227,14 @@ class KernelSupportMatrixTest {
                 "native-jni-direct row",
         )
 
+        // Drift gate on the JVM pack rows, where the environment allows it: the FFM provider must
+        // carry the direct `x · Wᵀ` kernel and the ternary pack both of its kernels.
+        if (NativeKernelProvider.isAvailable()) {
+            assertTrue(NativeKernelProvider.matmulFp32Wt() != null, "native-ffm lost its direct x·Wᵀ kernel — update packTiers()")
+            assertTrue(NativeTernaryF32GemvKernel.isAvailable() && NativeTernaryLmheadKernel.isAvailable(),
+                "ffm-ternary lost a kernel — update packTiers()")
+        }
+
         val jsonText = renderJson(tiers)
         val outDir = File("build/generated/kernel-support").apply { mkdirs() }
         File(outDir, "kernel-support.json").writeText(jsonText)
diff --git a/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernelTest.kt b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernelTest.kt
new file mode 100644
index 00000000..78b56d8f
--- /dev/null
+++ b/skainet-backends/skainet-backend-native-cpu/src/jvmTest/kotlin/sk/ainet/exec/kernel/NativeFp32MatmulWtKernelTest.kt
@@ -0,0 +1,111 @@
+package sk.ainet.exec.kernel
+
+import java.lang.foreign.Arena
+import java.lang.foreign.MemorySegment
+import java.lang.foreign.ValueLayout
+import kotlin.math.abs
+import kotlin.random.Random
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * [NativeFp32MatmulWtKernel] — the JVM binding of `skainet_fp32_matmul_wt` — against a plain
+ * row-dot reference, on both of its faces. The row-pool threshold (512 output rows) is crossed by
+ * one shape so the threaded partition is covered; per-row arithmetic does not depend on it.
+ */
+class NativeFp32MatmulWtKernelTest {
+
+    @BeforeTest
+    fun checkAvailable() {
+        assertTrue(NativeFp32MatmulWtKernel.isAvailable(), "bundled libskainet_kernels must resolve skainet_fp32_matmul_wt")
+    }
+
+    private fun reference(x: FloatArray, xOff: Int, w: FloatArray, wOff: Int, m: Int, n: Int, k: Int): FloatArray {
+        val out = FloatArray(m * n)
+        for (i in 0 until m) for (o in 0 until n) {
+            var acc = 0.0
+            for (p in 0 until k) acc += x[xOff + i * k + p].toDouble() * w[wOff + o * k + p]
+            out[i * n + o] = acc.toFloat()
+        }
+        return out
+    }
+
+    private fun assertClose(expected: FloatArray, actual: FloatArray, what: String) {
+        assertEquals(expected.size, actual.size, "$what size")
+        var maxAbs = 0f
+        for (v in expected) maxAbs = maxOf(maxAbs, abs(v))
+        val tol = maxAbs * 1e-5f + 1e-6f
+        for (i in expected.indices) {
+            assertTrue(abs(expected[i] - actual[i]) <= tol, "$what[$i]: ${actual[i]} vs ${expected[i]} (tol $tol)")
+        }
+    }
+
+    @Test
+    fun heap_face_matches_the_row_dot_reference_on_every_shape() {
+        val rng = Random(3)
+        // (m, n, k): a single token; a prefill against a threaded row count with a 4-lane tail; one row of weight.
+        for ((m, n, k) in listOf(Triple(1, 7, 5), Triple(3, 600, 37), Triple(5, 1, 64))) {
+            val x = FloatArray(m * k) { rng.nextFloat() - 0.5f }
+            val w = FloatArray(n * k) { rng.nextFloat() - 0.5f }
+            val out = FloatArray(m * n)
+            NativeFp32MatmulWtKernel.matmulWt(x, 0, w, 0, out, 0, m, n, k)
+            assertClose(reference(x, 0, w, 0, m, n, k), out, "wt $m×$k · ($n×$k)ᵀ")
+        }
+    }
+
+    @Test
+    fun offsets_are_honoured_and_the_rest_of_the_arrays_is_left_alone() {
+        val rng = Random(5)
+        val m = 2; val n = 9; val k = 12
+        val x = FloatArray(3 + m * k) { rng.nextFloat() }
+        val w = FloatArray(2 + n * k) { rng.nextFloat() }
+        val out = FloatArray(1 + m * n + 4) { 7f }
+        NativeFp32MatmulWtKernel.matmulWt(x, 3, w, 2, out, 1, m, n, k)
+        assertClose(reference(x, 3, w, 2, m, n, k), out.copyOfRange(1, 1 + m * n), "offset wt")
+        assertEquals(7f, out[0])
+        for (i in 1 + m * n until out.size) assertEquals(7f, out[i], "tail[$i] untouched")
+    }
+
+    @Test
+    fun k_zero_zeroes_the_block_and_empty_shapes_are_no_ops() {
+        val out = FloatArray(6) { 1f }
+        NativeFp32MatmulWtKernel.matmulWt(FloatArray(0), 0, FloatArray(0), 0, out, 0, 2, 3, 0)
+        assertContentEquals(FloatArray(6), out)
+        val untouched = FloatArray(4) { 2f }
+        NativeFp32MatmulWtKernel.matmulWt(FloatArray(0), 0, FloatArray(8), 0, untouched, 0, 0, 4, 2)
+        NativeFp32MatmulWtKernel.matmulWt(FloatArray(4), 0, FloatArray(0), 0, untouched, 0, 2, 0, 2)
+        assertContentEquals(FloatArray(4) { 2f }, untouched)
+    }
+
+    @Test
+    fun segment_face_is_bit_identical_to_the_heap_face() {
+        val rng = Random(11)
+        val m = 4; val n = 530; val k = 96
+        val x = FloatArray(m * k) { rng.nextFloat() - 0.5f }
+        val w = FloatArray(n * k) { rng.nextFloat() - 0.5f }
+        val viaHeap = FloatArray(m * n)
+        NativeFp32MatmulWtKernel.matmulWt(x, 0, w, 0, viaHeap, 0, m, n, k)
+        Arena.ofConfined().use { arena ->
+            // The weight sits 16 bytes into a larger segment: the offset is honoured and no copy is made.
+            val seg = arena.allocate(16L + n.toLong() * k * java.lang.Float.BYTES, 64L)
+            MemorySegment.copy(w, 0, seg, ValueLayout.JAVA_FLOAT, 16L, n * k)
+            val viaSegment = FloatArray(m * n)
+            NativeFp32MatmulWtKernel.matmulWt(x, 0, seg, 16L, viaSegment, 0, m, n, k)
+            assertContentEquals(viaHeap, viaSegment)
+        }
+        assertClose(reference(x, 0, w, 0, m, n, k), viaHeap, "threaded wt")
+    }
+
+    @Test
+    fun the_provider_exposes_both_faces() {
+        assertTrue(NativeKernelProvider.isAvailable())
+        assertNotNull(NativeKernelProvider.matmulFp32Wt())
+        assertNotNull(NativeKernelProvider.matmulFp32WtMemSeg())
+        assertTrue(NativeKernelProvider.supports("matmul_wt", listOf("Float32", "Float32")))
+        assertTrue(!ScalarKernelProvider.supports("matmul_wt", listOf("Float32", "Float32")), "the scalar floor has no direct kernel")
+    }
+}
diff --git a/skainet-backends/skainet-backend-wasm-simd/native/build-wasm.sh b/skainet-backends/skainet-backend-wasm-simd/native/build-wasm.sh
index 0c9009de..93eb3ef8 100644
--- a/skainet-backends/skainet-backend-wasm-simd/native/build-wasm.sh
+++ b/skainet-backends/skainet-backend-wasm-simd/native/build-wasm.sh
@@ -11,8 +11,9 @@
 #
 # The sources are skainet-backend-native-cpu/native/src — the same files the JVM FFM and Android JNI
 # packs are built from — compiled with Emscripten. Only the portable (#else) kernel bodies and the
-# explicit __wasm_simd128__ bodies are used; NEON, Apple dispatch and the vendored ternary kernels
-# are not part of this build.
+# explicit __wasm_simd128__ bodies are used; NEON and Apple dispatch are not part of this build.
+# The ternary kernels come from the portable branch of skainet_ternary_f32.c (the compile-time LUT
+# with its SIMD128 body), not from the vendored NeoGPU file, which needs native pthreads and NEON.
 #
 # Toolchain: emsdk, pinned below. `EMSDK_PYTHON` must point at a Python >= 3.10 when the default
 # python3 is older (pyenv). Usage:
@@ -44,11 +45,14 @@ SOURCES=(
   "$NATIVE/src/q4k_matmul.c"
   "$NATIVE/src/q5k_matmul.c"
   "$NATIVE/src/q6k_matmul.c"
+  "$NATIVE/src/skainet_ternary_f32.c"
+  "$NATIVE/src/bitnet_gemv.c"
   "$NATIVE/src/skainet_row_threads.c"
   "$NATIVE/src/skainet_cpu_features.c"
 )
 
 EXPORTS='_malloc,_free,_skainet_fp32_matmul,_skainet_fp32_matmul_wt,_skainet_bf16_matmul,_skainet_fp16_matmul'
+EXPORTS="$EXPORTS,_skainet_ternary_f32_gemv,_skainet_ternary_lmhead_stage1,_skainet_bitnet_gemv_tq2_0"
 for f in q4_0 q5_0 q5_1 q8_0 q4k q5k q6k; do
   EXPORTS="$EXPORTS,_skainet_${f}_matmul,_skainet_${f}_matmul_rm"
 done
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/SidecarArtifacts.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/SidecarArtifacts.kt
index b33356e5..225191a8 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/SidecarArtifacts.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/SidecarArtifacts.kt
@@ -1,13 +1,13 @@
 // GENERATED by native/build-wasm.sh (emsdk 4.0.14) -- do not edit.
 // SKEEP-007 Tier 1: the SIMD128 kernel sidecar, embedded so every consumer of this module carries it.
-// sha256 st: c1a6213df16738714532551430ae508eb29154459336c5069bf27be3205ba3f3
-// sha256 mt: 590e0bfe8a35c5fa259305688d3c964c5bf3013fab611b5557dcce65d3b8b097
+// sha256 st: 6d34f90f7c07e268d95f73c92767c46ed95d018d0baee613b5ed9392ae9712a5
+// sha256 mt: c088de54bbee432406499f313f05a901a6aecf64ccd9d4efd722cd1eac79f98c
 package sk.ainet.exec.wasm
 
 internal object SidecarArtifacts {
     const val EMSDK: String = "4.0.14"
-    const val ST_MJS: String = "async function createSkainetKernels(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?.node&&process.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url.startsWith("file:")?import.meta.url:process.cwd()+"/")}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["c"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("skainet_kernels_st.wasm")}try{return new URL("skainet_kernels_st.wasm",import.meta.url).href}catch(e){return "skainet_kernels_st.wasm"}}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=applySignatureConversions(wasmExports);wasmMemory=wasmExports["b"];Module["wasmMemory"]=wasmMemory;updateMemoryViews();assignWasmExports(wasmExports);return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var getHeapMax=()=>4294901760;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize>>>=0;var oldSize=HEAPU8.length;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["wasmMemory"]=wasmMemory;var _skainet_fp32_matmul,_skainet_fp32_matmul_wt,_skainet_bf16_matmul,_skainet_fp16_matmul,_skainet_q4_0_matmul,_skainet_q4_0_matmul_rm,_skainet_q5_0_matmul,_malloc,_free,_skainet_q5_0_matmul_rm,_skainet_q5_1_matmul,_skainet_q5_1_matmul_rm,_skainet_q8_0_matmul,_skainet_q8_0_matmul_rm,_skainet_q4k_matmul,_skainet_q4k_matmul_rm,_skainet_q5k_matmul,_skainet_q5k_matmul_rm,_skainet_q6k_matmul,_skainet_q6k_matmul_rm;function assignWasmExports(wasmExports){Module["_skainet_fp32_matmul"]=_skainet_fp32_matmul=wasmExports["d"];Module["_skainet_fp32_matmul_wt"]=_skainet_fp32_matmul_wt=wasmExports["e"];Module["_skainet_bf16_matmul"]=_skainet_bf16_matmul=wasmExports["f"];Module["_skainet_fp16_matmul"]=_skainet_fp16_matmul=wasmExports["g"];Module["_skainet_q4_0_matmul"]=_skainet_q4_0_matmul=wasmExports["h"];Module["_skainet_q4_0_matmul_rm"]=_skainet_q4_0_matmul_rm=wasmExports["i"];Module["_skainet_q5_0_matmul"]=_skainet_q5_0_matmul=wasmExports["j"];Module["_malloc"]=_malloc=wasmExports["k"];Module["_free"]=_free=wasmExports["l"];Module["_skainet_q5_0_matmul_rm"]=_skainet_q5_0_matmul_rm=wasmExports["m"];Module["_skainet_q5_1_matmul"]=_skainet_q5_1_matmul=wasmExports["n"];Module["_skainet_q5_1_matmul_rm"]=_skainet_q5_1_matmul_rm=wasmExports["o"];Module["_skainet_q8_0_matmul"]=_skainet_q8_0_matmul=wasmExports["p"];Module["_skainet_q8_0_matmul_rm"]=_skainet_q8_0_matmul_rm=wasmExports["q"];Module["_skainet_q4k_matmul"]=_skainet_q4k_matmul=wasmExports["r"];Module["_skainet_q4k_matmul_rm"]=_skainet_q4k_matmul_rm=wasmExports["s"];Module["_skainet_q5k_matmul"]=_skainet_q5k_matmul=wasmExports["t"];Module["_skainet_q5k_matmul_rm"]=_skainet_q5k_matmul_rm=wasmExports["u"];Module["_skainet_q6k_matmul"]=_skainet_q6k_matmul=wasmExports["v"];Module["_skainet_q6k_matmul_rm"]=_skainet_q6k_matmul_rm=wasmExports["w"]}var wasmImports={a:_emscripten_resize_heap};function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper_pp=f=>a0=>f(a0)>>>0;var makeWrapper_p=f=>()=>f()>>>0;wasmExports["k"]=makeWrapper_pp(wasmExports["k"]);wasmExports["_emscripten_stack_alloc"]=makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);wasmExports["emscripten_stack_get_current"]=makeWrapper_p(wasmExports["emscripten_stack_get_current"]);return wasmExports}function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
;return moduleRtn}export default createSkainetKernels;
"
-    const val ST_WASM: String = "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"
-    const val MT_MJS: String = "async function createSkainetKernels(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?.node&&process.type!="renderer";var ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&self.name?.startsWith("em-pthread");if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url.startsWith("file:")?import.meta.url:process.cwd()+"/");var worker_threads=require("worker_threads");global.Worker=worker_threads.Worker;ENVIRONMENT_IS_WORKER=!worker_threads.isMainThread;ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&worker_threads["workerData"]=="em-pthread"}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}if(!ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var defaultPrint=console.log.bind(console);var defaultPrintErr=console.error.bind(console);if(ENVIRONMENT_IS_NODE){var utils=require("util");var stringify=a=>typeof a=="object"?utils.inspect(a):a;defaultPrint=(...args)=>fs.writeSync(1,args.map(stringify).join(" ")+"\n");defaultPrintErr=(...args)=>fs.writeSync(2,args.map(stringify).join(" ")+"\n")}var out=defaultPrint;var err=defaultPrintErr;var wasmBinary;var wasmModule;var ABORT=false;var EXITSTATUS;var isFileURI=filename=>filename.startsWith("file://");function growMemViews(){if(wasmMemory.buffer!=HEAP8.buffer){updateMemoryViews()}}var readyPromiseResolve,readyPromiseReject;if(ENVIRONMENT_IS_NODE&&ENVIRONMENT_IS_PTHREAD){var parentPort=worker_threads["parentPort"];parentPort.on("message",msg=>global.onmessage?.({data:msg}));Object.assign(globalThis,{self:global,postMessage:msg=>parentPort["postMessage"](msg)});process.on("uncaughtException",err=>{postMessage({cmd:"uncaughtException",error:err});process.exit(1)})}var startWorker;if(ENVIRONMENT_IS_PTHREAD){var initializedJS=false;self.onunhandledrejection=e=>{throw e.reason||e};function handleMessage(e){try{var msgData=e["data"];var cmd=msgData.cmd;if(cmd==="load"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);startWorker=()=>{postMessage({cmd:"loaded"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};for(const handler of msgData.handlers){if(!Module[handler]||Module[handler].proxy){Module[handler]=(...args)=>{postMessage({cmd:"callHandler",handler,args})};if(handler=="print")out=Module[handler];if(handler=="printErr")err=Module[handler]}}wasmMemory=msgData.wasmMemory;updateMemoryViews();wasmModule=msgData.wasmModule;createWasm();run()}else if(cmd==="run"){establishStackSpace(msgData.pthread_ptr);__emscripten_thread_init(msgData.pthread_ptr,0,0,1,0,0);PThread.threadInitTLS();__emscripten_thread_mailbox_await(msgData.pthread_ptr);if(!initializedJS){initializedJS=true}try{invokeEntryPoint(msgData.start_routine,msgData.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(msgData.target==="setimmediate"){}else if(cmd==="checkMailbox"){if(initializedJS){checkMailbox()}}else if(cmd){err(`worker: received unknown command ${cmd}`);err(msgData)}}catch(ex){__emscripten_thread_crashed();throw ex}}self.onmessage=handleMessage}var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function initMemory(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["wasmMemory"]){wasmMemory=Module["wasmMemory"]}else{var INITIAL_MEMORY=Module["INITIAL_MEMORY"]||67108864;wasmMemory=new WebAssembly.Memory({initial:INITIAL_MEMORY/65536,maximum:65536,shared:true})}updateMemoryViews()}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(ENVIRONMENT_IS_PTHREAD)return startWorker();wasmExports["o"]()}function postRun(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("skainet_kernels_mt.wasm")}try{return new URL("skainet_kernels_mt.wasm",import.meta.url).href}catch(e){return "skainet_kernels_mt.wasm"}}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){assignWasmImports();return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=applySignatureConversions(wasmExports);registerTLSInit(wasmExports["K"]);wasmTable=wasmExports["q"];wasmModule=module;assignWasmExports(wasmExports);return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"],result["module"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}if(ENVIRONMENT_IS_PTHREAD){var instance=new WebAssembly.Instance(wasmModule,getWasmImports());return receiveInstance(instance,wasmModule)}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var terminateWorker=worker=>{worker.terminate();worker.onmessage=e=>{}};var cleanupThread=pthread_ptr=>{var worker=PThread.pthreads[pthread_ptr];PThread.returnWorkerToPool(worker)};var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var runDependencies=0;var dependenciesFulfilled=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var spawnThread=threadParams=>{var worker=PThread.getNewWorker();if(!worker){return 6}PThread.runningWorkers.push(worker);PThread.pthreads[threadParams.pthread_ptr]=worker;worker.pthread_ptr=threadParams.pthread_ptr;var msg={cmd:"run",start_routine:threadParams.startRoutine,arg:threadParams.arg,pthread_ptr:threadParams.pthread_ptr};if(ENVIRONMENT_IS_NODE){worker.unref()}worker.postMessage(msg,threadParams.transferList);return 0};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var proxyToMainThread=(funcIndex,emAsmAddr,sync,...callArgs)=>{var serializedNumCallArgs=callArgs.length*2;var sp=stackSave();var args=stackAlloc(serializedNumCallArgs*8);var b=args>>>3;for(var i=0;i<callArgs.length;i++){var arg=callArgs[i];if(typeof arg=="bigint"){(growMemViews(),HEAP64)[b+2*i>>>0]=1n;(growMemViews(),HEAP64)[b+2*i+1>>>0]=arg}else{(growMemViews(),HEAP64)[b+2*i>>>0]=0n;(growMemViews(),HEAPF64)[b+2*i+1>>>0]=arg}}var rtn=__emscripten_run_js_on_main_thread(funcIndex,emAsmAddr,serializedNumCallArgs,args,sync);stackRestore(sp);return rtn};function _proc_exit(code){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(0,0,1,code);EXITSTATUS=code;if(!keepRuntimeAlive()){PThread.terminateAllThreads();Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))}function exitOnMainThread(returnCode){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(1,0,0,returnCode);_exit(returnCode)}var exitJS=(status,implicit)=>{EXITSTATUS=status;if(ENVIRONMENT_IS_PTHREAD){exitOnMainThread(status);throw"unwind"}_proc_exit(status)};var _exit=exitJS;var PThread={unusedWorkers:[],runningWorkers:[],tlsInitFunctions:[],pthreads:{},init(){if(!ENVIRONMENT_IS_PTHREAD){PThread.initMainThread()}},initMainThread(){var pthreadPoolSize=4;while(pthreadPoolSize--){PThread.allocateUnusedWorker()}addOnPreRun(async()=>{var pthreadPoolReady=PThread.loadWasmModuleToAllWorkers();addRunDependency("loading-workers");await pthreadPoolReady;removeRunDependency("loading-workers")})},terminateAllThreads:()=>{for(var worker of PThread.runningWorkers){terminateWorker(worker)}for(var worker of PThread.unusedWorkers){terminateWorker(worker)}PThread.unusedWorkers=[];PThread.runningWorkers=[];PThread.pthreads={}},returnWorkerToPool:worker=>{var pthread_ptr=worker.pthread_ptr;delete PThread.pthreads[pthread_ptr];PThread.unusedWorkers.push(worker);PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker),1);worker.pthread_ptr=0;__emscripten_thread_free_data(pthread_ptr)},threadInitTLS(){PThread.tlsInitFunctions.forEach(f=>f())},loadWasmModuleToWorker:worker=>new Promise(onFinishedLoading=>{worker.onmessage=e=>{var d=e["data"];var cmd=d.cmd;if(d.targetThread&&d.targetThread!=_pthread_self()){var targetWorker=PThread.pthreads[d.targetThread];if(targetWorker){targetWorker.postMessage(d,d.transferList)}else{err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`)}return}if(cmd==="checkMailbox"){checkMailbox()}else if(cmd==="spawnThread"){spawnThread(d)}else if(cmd==="cleanupThread"){callUserCallback(()=>cleanupThread(d.thread))}else if(cmd==="loaded"){worker.loaded=true;if(ENVIRONMENT_IS_NODE&&!worker.pthread_ptr){worker.unref()}onFinishedLoading(worker)}else if(d.target==="setimmediate"){worker.postMessage(d)}else if(cmd==="uncaughtException"){worker.onerror(d.error)}else if(cmd==="callHandler"){Module[d.handler](...d.args)}else if(cmd){err(`worker sent an unknown command ${cmd}`)}};worker.onerror=e=>{var message="worker sent an error!";err(`${message} ${e.filename}:${e.lineno}: ${e.message}`);throw e};if(ENVIRONMENT_IS_NODE){worker.on("message",data=>worker.onmessage({data}));worker.on("error",e=>worker.onerror(e))}var handlers=[];var knownHandlers=["onExit","onAbort","print","printErr"];for(var handler of knownHandlers){if(Module.propertyIsEnumerable(handler)){handlers.push(handler)}}worker.postMessage({cmd:"load",handlers,wasmMemory,wasmModule})}),async loadWasmModuleToAllWorkers(){if(ENVIRONMENT_IS_PTHREAD){return}let pthreadPoolReady=Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker));return pthreadPoolReady},allocateUnusedWorker(){var worker;if(Module["mainScriptUrlOrBlob"]){var pthreadMainJs=Module["mainScriptUrlOrBlob"];if(typeof pthreadMainJs!="string"){pthreadMainJs=URL.createObjectURL(pthreadMainJs)}worker=new Worker(ENVIRONMENT_IS_NODE&&typeof pthreadMainJs=="string"&&pthreadMainJs.startsWith("data:")?new URL(pthreadMainJs):pthreadMainJs,{type:"module",workerData:"em-pthread",name:"em-pthread"})}else worker=new Worker(new URL("skainet_kernels_mt.mjs",import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});PThread.unusedWorkers.push(worker)},getNewWorker(){if(PThread.unusedWorkers.length==0){PThread.allocateUnusedWorker();PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0])}return PThread.unusedWorkers.pop()}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);function establishStackSpace(pthread_ptr){var stackHigh=(growMemViews(),HEAPU32)[pthread_ptr+52>>>2>>>0];var stackSize=(growMemViews(),HEAPU32)[pthread_ptr+56>>>2>>>0];var stackLow=stackHigh-stackSize;_emscripten_stack_set_limits(stackHigh,stackLow);stackRestore(stackHigh)}var wasmTableMirror=[];var wasmTable;var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var invokeEntryPoint=(ptr,arg)=>{runtimeKeepaliveCounter=0;noExitRuntime=0;var result=getWasmTableEntry(ptr)(arg);function finish(result){if(keepRuntimeAlive()){EXITSTATUS=result;return}__emscripten_thread_exit(result)}finish(result)};var noExitRuntime=true;var registerTLSInit=tlsInitFunc=>PThread.tlsInitFunctions.push(tlsInitFunc);function pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(2,0,1,pthread_ptr,attr,startRoutine,arg);return ___pthread_create_js(pthread_ptr,attr,startRoutine,arg)}var _emscripten_has_threading_support=()=>typeof SharedArrayBuffer!="undefined";function ___pthread_create_js(pthread_ptr,attr,startRoutine,arg){pthread_ptr>>>=0;attr>>>=0;startRoutine>>>=0;arg>>>=0;if(!_emscripten_has_threading_support()){return 6}var transferList=[];var error=0;if(ENVIRONMENT_IS_PTHREAD&&(transferList.length===0||error)){return pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg)}if(error)return error;var threadParams={startRoutine,pthread_ptr,arg,transferList};if(ENVIRONMENT_IS_PTHREAD){threadParams.cmd="spawnThread";postMessage(threadParams,transferList);return 0}return spawnThread(threadParams)}function __emscripten_init_main_thread_js(tb){tb>>>=0;__emscripten_thread_init(tb,!ENVIRONMENT_IS_WORKER,1,!ENVIRONMENT_IS_WEB,65536,false);PThread.threadInitTLS()}var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var maybeExit=()=>{if(!keepRuntimeAlive()){try{if(ENVIRONMENT_IS_PTHREAD){if(_pthread_self())__emscripten_thread_exit(EXITSTATUS);return}_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};function __emscripten_thread_mailbox_await(pthread_ptr){pthread_ptr>>>=0;if(typeof Atomics.waitAsync==="function"){var wait=Atomics.waitAsync((growMemViews(),HEAP32),pthread_ptr>>>2,pthread_ptr);wait.value.then(checkMailbox);var waitingAsync=pthread_ptr+128;Atomics.store((growMemViews(),HEAP32),waitingAsync>>>2,1)}}var checkMailbox=()=>callUserCallback(()=>{var pthread_ptr=_pthread_self();if(pthread_ptr){__emscripten_thread_mailbox_await(pthread_ptr);__emscripten_check_mailbox()}});function __emscripten_notify_mailbox_postmessage(targetThread,currThreadId){targetThread>>>=0;currThreadId>>>=0;if(targetThread==currThreadId){setTimeout(checkMailbox)}else if(ENVIRONMENT_IS_PTHREAD){postMessage({targetThread,cmd:"checkMailbox"})}else{var worker=PThread.pthreads[targetThread];if(!worker){return}worker.postMessage({cmd:"checkMailbox"})}}var proxiedJSCallArgs=[];function __emscripten_receive_on_main_thread_js(funcIndex,emAsmAddr,callingThread,numCallArgs,args){emAsmAddr>>>=0;callingThread>>>=0;args>>>=0;numCallArgs/=2;proxiedJSCallArgs.length=numCallArgs;var b=args>>>3;for(var i=0;i<numCallArgs;i++){if((growMemViews(),HEAP64)[b+2*i>>>0]){proxiedJSCallArgs[i]=(growMemViews(),HEAP64)[b+2*i+1>>>0]}else{proxiedJSCallArgs[i]=(growMemViews(),HEAPF64)[b+2*i+1>>>0]}}var func=proxiedFunctionTable[funcIndex];PThread.currentProxiedOperationCallerThread=callingThread;var rtn=func(...proxiedJSCallArgs);PThread.currentProxiedOperationCallerThread=0;return rtn}function __emscripten_thread_cleanup(thread){thread>>>=0;if(!ENVIRONMENT_IS_PTHREAD)cleanupThread(thread);else postMessage({cmd:"cleanupThread",thread})}function __emscripten_thread_set_strongref(thread){thread>>>=0;if(ENVIRONMENT_IS_NODE){PThread.pthreads[thread].ref()}}var _emscripten_get_now=()=>performance.timeOrigin+performance.now();var _emscripten_check_blocking_allowed=()=>{};var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_exit_with_live_runtime=()=>{runtimeKeepalivePush();throw"unwind"};var getHeapMax=()=>4294901760;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize>>>=0;var oldSize=(growMemViews(),HEAPU8).length;if(requestedSize<=oldSize){return false}var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}var printCharBuffers=[null,[],[]];var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{idx>>>=0;var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer?heapOrArray.subarray(idx,endPtr):heapOrArray.slice(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};function _fd_write(fd,iov,iovcnt,pnum){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(3,0,1,fd,iov,iovcnt,pnum);iov>>>=0;iovcnt>>>=0;pnum>>>=0;var num=0;for(var i=0;i<iovcnt;i++){var ptr=(growMemViews(),HEAPU32)[iov>>>2>>>0];var len=(growMemViews(),HEAPU32)[iov+4>>>2>>>0];iov+=8;for(var j=0;j<len;j++){printChar(fd,(growMemViews(),HEAPU8)[ptr+j>>>0])}num+=len}(growMemViews(),HEAPU32)[pnum>>>2>>>0]=num;return 0}PThread.init();{initMemory();if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["wasmMemory"]=wasmMemory;var proxiedFunctionTable=[_proc_exit,exitOnMainThread,pthreadCreateProxied,_fd_write];var _skainet_fp32_matmul,_skainet_fp32_matmul_wt,_skainet_bf16_matmul,_skainet_fp16_matmul,_skainet_q4_0_matmul,_skainet_q4_0_matmul_rm,_skainet_q5_0_matmul,_malloc,_free,_skainet_q5_0_matmul_rm,_skainet_q5_1_matmul,_skainet_q5_1_matmul_rm,_skainet_q8_0_matmul,_skainet_q8_0_matmul_rm,_skainet_q4k_matmul,_skainet_q4k_matmul_rm,_skainet_q5k_matmul,_skainet_q5k_matmul_rm,_skainet_q6k_matmul,_skainet_q6k_matmul_rm,__emscripten_tls_init,_pthread_self,__emscripten_thread_init,__emscripten_thread_crashed,__emscripten_run_js_on_main_thread,__emscripten_thread_free_data,__emscripten_thread_exit,__emscripten_check_mailbox,_emscripten_stack_set_limits,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current;function assignWasmExports(wasmExports){Module["_skainet_fp32_matmul"]=_skainet_fp32_matmul=wasmExports["p"];Module["_skainet_fp32_matmul_wt"]=_skainet_fp32_matmul_wt=wasmExports["r"];Module["_skainet_bf16_matmul"]=_skainet_bf16_matmul=wasmExports["s"];Module["_skainet_fp16_matmul"]=_skainet_fp16_matmul=wasmExports["t"];Module["_skainet_q4_0_matmul"]=_skainet_q4_0_matmul=wasmExports["u"];Module["_skainet_q4_0_matmul_rm"]=_skainet_q4_0_matmul_rm=wasmExports["v"];Module["_skainet_q5_0_matmul"]=_skainet_q5_0_matmul=wasmExports["w"];Module["_malloc"]=_malloc=wasmExports["x"];Module["_free"]=_free=wasmExports["y"];Module["_skainet_q5_0_matmul_rm"]=_skainet_q5_0_matmul_rm=wasmExports["z"];Module["_skainet_q5_1_matmul"]=_skainet_q5_1_matmul=wasmExports["A"];Module["_skainet_q5_1_matmul_rm"]=_skainet_q5_1_matmul_rm=wasmExports["B"];Module["_skainet_q8_0_matmul"]=_skainet_q8_0_matmul=wasmExports["C"];Module["_skainet_q8_0_matmul_rm"]=_skainet_q8_0_matmul_rm=wasmExports["D"];Module["_skainet_q4k_matmul"]=_skainet_q4k_matmul=wasmExports["E"];Module["_skainet_q4k_matmul_rm"]=_skainet_q4k_matmul_rm=wasmExports["F"];Module["_skainet_q5k_matmul"]=_skainet_q5k_matmul=wasmExports["G"];Module["_skainet_q5k_matmul_rm"]=_skainet_q5k_matmul_rm=wasmExports["H"];Module["_skainet_q6k_matmul"]=_skainet_q6k_matmul=wasmExports["I"];Module["_skainet_q6k_matmul_rm"]=_skainet_q6k_matmul_rm=wasmExports["J"];__emscripten_tls_init=wasmExports["K"];_pthread_self=wasmExports["L"];__emscripten_thread_init=wasmExports["M"];__emscripten_thread_crashed=wasmExports["N"];__emscripten_run_js_on_main_thread=wasmExports["O"];__emscripten_thread_free_data=wasmExports["P"];__emscripten_thread_exit=wasmExports["Q"];__emscripten_check_mailbox=wasmExports["R"];_emscripten_stack_set_limits=wasmExports["S"];__emscripten_stack_restore=wasmExports["T"];__emscripten_stack_alloc=wasmExports["U"];_emscripten_stack_get_current=wasmExports["V"]}var wasmImports;function assignWasmImports(){wasmImports={g:___pthread_create_js,k:__emscripten_init_main_thread_js,n:__emscripten_notify_mailbox_postmessage,l:__emscripten_receive_on_main_thread_js,c:__emscripten_thread_cleanup,j:__emscripten_thread_mailbox_await,i:__emscripten_thread_set_strongref,e:_emscripten_check_blocking_allowed,h:_emscripten_exit_with_live_runtime,b:_emscripten_get_now,m:_emscripten_resize_heap,f:_exit,d:_fd_write,a:wasmMemory}}function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper_pp=f=>a0=>f(a0)>>>0;var makeWrapper_p=f=>()=>f()>>>0;wasmExports["x"]=makeWrapper_pp(wasmExports["x"]);wasmExports["L"]=makeWrapper_p(wasmExports["L"]);wasmExports["U"]=makeWrapper_pp(wasmExports["U"]);wasmExports["V"]=makeWrapper_p(wasmExports["V"]);return wasmExports}function run(){if(runDependencies>0){dependenciesFulfilled=run;return}if(ENVIRONMENT_IS_PTHREAD){readyPromiseResolve?.(Module);initRuntime();return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;if(!ENVIRONMENT_IS_PTHREAD){wasmExports=await (createWasm());run()}if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
;return moduleRtn}export default createSkainetKernels;var isPthread=globalThis.self?.name?.startsWith("em-pthread");var isNode=typeof process=="object"&&process.versions?.node&&process.type!="renderer";if(isNode)isPthread=(await import("worker_threads")).workerData==="em-pthread";isPthread&&createSkainetKernels();
"
-    const val MT_WASM: String = "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"
+    const val ST_MJS: String = "async function createSkainetKernels(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?.node&&process.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url.startsWith("file:")?import.meta.url:process.cwd()+"/")}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["c"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("skainet_kernels_st.wasm")}try{return new URL("skainet_kernels_st.wasm",import.meta.url).href}catch(e){return "skainet_kernels_st.wasm"}}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=applySignatureConversions(wasmExports);wasmMemory=wasmExports["b"];Module["wasmMemory"]=wasmMemory;updateMemoryViews();assignWasmExports(wasmExports);return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var getHeapMax=()=>4294901760;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize>>>=0;var oldSize=HEAPU8.length;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["wasmMemory"]=wasmMemory;var _skainet_fp32_matmul,_skainet_fp32_matmul_wt,_skainet_bf16_matmul,_skainet_fp16_matmul,_skainet_q4_0_matmul,_skainet_q4_0_matmul_rm,_skainet_q5_0_matmul,_malloc,_free,_skainet_q5_0_matmul_rm,_skainet_q5_1_matmul,_skainet_q5_1_matmul_rm,_skainet_q8_0_matmul,_skainet_q8_0_matmul_rm,_skainet_q4k_matmul,_skainet_q4k_matmul_rm,_skainet_q5k_matmul,_skainet_q5k_matmul_rm,_skainet_q6k_matmul,_skainet_q6k_matmul_rm,_skainet_ternary_f32_gemv,_skainet_ternary_lmhead_stage1,_skainet_bitnet_gemv_tq2_0;function assignWasmExports(wasmExports){Module["_skainet_fp32_matmul"]=_skainet_fp32_matmul=wasmExports["d"];Module["_skainet_fp32_matmul_wt"]=_skainet_fp32_matmul_wt=wasmExports["e"];Module["_skainet_bf16_matmul"]=_skainet_bf16_matmul=wasmExports["f"];Module["_skainet_fp16_matmul"]=_skainet_fp16_matmul=wasmExports["g"];Module["_skainet_q4_0_matmul"]=_skainet_q4_0_matmul=wasmExports["h"];Module["_skainet_q4_0_matmul_rm"]=_skainet_q4_0_matmul_rm=wasmExports["i"];Module["_skainet_q5_0_matmul"]=_skainet_q5_0_matmul=wasmExports["j"];Module["_malloc"]=_malloc=wasmExports["k"];Module["_free"]=_free=wasmExports["l"];Module["_skainet_q5_0_matmul_rm"]=_skainet_q5_0_matmul_rm=wasmExports["m"];Module["_skainet_q5_1_matmul"]=_skainet_q5_1_matmul=wasmExports["n"];Module["_skainet_q5_1_matmul_rm"]=_skainet_q5_1_matmul_rm=wasmExports["o"];Module["_skainet_q8_0_matmul"]=_skainet_q8_0_matmul=wasmExports["p"];Module["_skainet_q8_0_matmul_rm"]=_skainet_q8_0_matmul_rm=wasmExports["q"];Module["_skainet_q4k_matmul"]=_skainet_q4k_matmul=wasmExports["r"];Module["_skainet_q4k_matmul_rm"]=_skainet_q4k_matmul_rm=wasmExports["s"];Module["_skainet_q5k_matmul"]=_skainet_q5k_matmul=wasmExports["t"];Module["_skainet_q5k_matmul_rm"]=_skainet_q5k_matmul_rm=wasmExports["u"];Module["_skainet_q6k_matmul"]=_skainet_q6k_matmul=wasmExports["v"];Module["_skainet_q6k_matmul_rm"]=_skainet_q6k_matmul_rm=wasmExports["w"];Module["_skainet_ternary_f32_gemv"]=_skainet_ternary_f32_gemv=wasmExports["x"];Module["_skainet_ternary_lmhead_stage1"]=_skainet_ternary_lmhead_stage1=wasmExports["y"];Module["_skainet_bitnet_gemv_tq2_0"]=_skainet_bitnet_gemv_tq2_0=wasmExports["z"]}var wasmImports={a:_emscripten_resize_heap};function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper_pp=f=>a0=>f(a0)>>>0;var makeWrapper_p=f=>()=>f()>>>0;wasmExports["k"]=makeWrapper_pp(wasmExports["k"]);wasmExports["_emscripten_stack_alloc"]=makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);wasmExports["emscripten_stack_get_current"]=makeWrapper_p(wasmExports["emscripten_stack_get_current"]);return wasmExports}function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
;return moduleRtn}export default createSkainetKernels;
"
+    const val ST_WASM: String = "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"
+    const val MT_MJS: String = "async function createSkainetKernels(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&process.versions?.node&&process.type!="renderer";var ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&self.name?.startsWith("em-pthread");if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url.startsWith("file:")?import.meta.url:process.cwd()+"/");var worker_threads=require("worker_threads");global.Worker=worker_threads.Worker;ENVIRONMENT_IS_WORKER=!worker_threads.isMainThread;ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&worker_threads["workerData"]=="em-pthread"}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}if(!ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var defaultPrint=console.log.bind(console);var defaultPrintErr=console.error.bind(console);if(ENVIRONMENT_IS_NODE){var utils=require("util");var stringify=a=>typeof a=="object"?utils.inspect(a):a;defaultPrint=(...args)=>fs.writeSync(1,args.map(stringify).join(" ")+"\n");defaultPrintErr=(...args)=>fs.writeSync(2,args.map(stringify).join(" ")+"\n")}var out=defaultPrint;var err=defaultPrintErr;var wasmBinary;var wasmModule;var ABORT=false;var EXITSTATUS;var isFileURI=filename=>filename.startsWith("file://");function growMemViews(){if(wasmMemory.buffer!=HEAP8.buffer){updateMemoryViews()}}var readyPromiseResolve,readyPromiseReject;if(ENVIRONMENT_IS_NODE&&ENVIRONMENT_IS_PTHREAD){var parentPort=worker_threads["parentPort"];parentPort.on("message",msg=>global.onmessage?.({data:msg}));Object.assign(globalThis,{self:global,postMessage:msg=>parentPort["postMessage"](msg)});process.on("uncaughtException",err=>{postMessage({cmd:"uncaughtException",error:err});process.exit(1)})}var startWorker;if(ENVIRONMENT_IS_PTHREAD){var initializedJS=false;self.onunhandledrejection=e=>{throw e.reason||e};function handleMessage(e){try{var msgData=e["data"];var cmd=msgData.cmd;if(cmd==="load"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);startWorker=()=>{postMessage({cmd:"loaded"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};for(const handler of msgData.handlers){if(!Module[handler]||Module[handler].proxy){Module[handler]=(...args)=>{postMessage({cmd:"callHandler",handler,args})};if(handler=="print")out=Module[handler];if(handler=="printErr")err=Module[handler]}}wasmMemory=msgData.wasmMemory;updateMemoryViews();wasmModule=msgData.wasmModule;createWasm();run()}else if(cmd==="run"){establishStackSpace(msgData.pthread_ptr);__emscripten_thread_init(msgData.pthread_ptr,0,0,1,0,0);PThread.threadInitTLS();__emscripten_thread_mailbox_await(msgData.pthread_ptr);if(!initializedJS){initializedJS=true}try{invokeEntryPoint(msgData.start_routine,msgData.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(msgData.target==="setimmediate"){}else if(cmd==="checkMailbox"){if(initializedJS){checkMailbox()}}else if(cmd){err(`worker: received unknown command ${cmd}`);err(msgData)}}catch(ex){__emscripten_thread_crashed();throw ex}}self.onmessage=handleMessage}var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function initMemory(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["wasmMemory"]){wasmMemory=Module["wasmMemory"]}else{var INITIAL_MEMORY=Module["INITIAL_MEMORY"]||67108864;wasmMemory=new WebAssembly.Memory({initial:INITIAL_MEMORY/65536,maximum:65536,shared:true})}updateMemoryViews()}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(ENVIRONMENT_IS_PTHREAD)return startWorker();wasmExports["o"]()}function postRun(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("skainet_kernels_mt.wasm")}try{return new URL("skainet_kernels_mt.wasm",import.meta.url).href}catch(e){return "skainet_kernels_mt.wasm"}}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){assignWasmImports();return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=applySignatureConversions(wasmExports);registerTLSInit(wasmExports["N"]);wasmTable=wasmExports["q"];wasmModule=module;assignWasmExports(wasmExports);return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"],result["module"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}if(ENVIRONMENT_IS_PTHREAD){var instance=new WebAssembly.Instance(wasmModule,getWasmImports());return receiveInstance(instance,wasmModule)}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var terminateWorker=worker=>{worker.terminate();worker.onmessage=e=>{}};var cleanupThread=pthread_ptr=>{var worker=PThread.pthreads[pthread_ptr];PThread.returnWorkerToPool(worker)};var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var runDependencies=0;var dependenciesFulfilled=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var spawnThread=threadParams=>{var worker=PThread.getNewWorker();if(!worker){return 6}PThread.runningWorkers.push(worker);PThread.pthreads[threadParams.pthread_ptr]=worker;worker.pthread_ptr=threadParams.pthread_ptr;var msg={cmd:"run",start_routine:threadParams.startRoutine,arg:threadParams.arg,pthread_ptr:threadParams.pthread_ptr};if(ENVIRONMENT_IS_NODE){worker.unref()}worker.postMessage(msg,threadParams.transferList);return 0};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var proxyToMainThread=(funcIndex,emAsmAddr,sync,...callArgs)=>{var serializedNumCallArgs=callArgs.length*2;var sp=stackSave();var args=stackAlloc(serializedNumCallArgs*8);var b=args>>>3;for(var i=0;i<callArgs.length;i++){var arg=callArgs[i];if(typeof arg=="bigint"){(growMemViews(),HEAP64)[b+2*i>>>0]=1n;(growMemViews(),HEAP64)[b+2*i+1>>>0]=arg}else{(growMemViews(),HEAP64)[b+2*i>>>0]=0n;(growMemViews(),HEAPF64)[b+2*i+1>>>0]=arg}}var rtn=__emscripten_run_js_on_main_thread(funcIndex,emAsmAddr,serializedNumCallArgs,args,sync);stackRestore(sp);return rtn};function _proc_exit(code){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(0,0,1,code);EXITSTATUS=code;if(!keepRuntimeAlive()){PThread.terminateAllThreads();Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))}function exitOnMainThread(returnCode){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(1,0,0,returnCode);_exit(returnCode)}var exitJS=(status,implicit)=>{EXITSTATUS=status;if(ENVIRONMENT_IS_PTHREAD){exitOnMainThread(status);throw"unwind"}_proc_exit(status)};var _exit=exitJS;var PThread={unusedWorkers:[],runningWorkers:[],tlsInitFunctions:[],pthreads:{},init(){if(!ENVIRONMENT_IS_PTHREAD){PThread.initMainThread()}},initMainThread(){var pthreadPoolSize=4;while(pthreadPoolSize--){PThread.allocateUnusedWorker()}addOnPreRun(async()=>{var pthreadPoolReady=PThread.loadWasmModuleToAllWorkers();addRunDependency("loading-workers");await pthreadPoolReady;removeRunDependency("loading-workers")})},terminateAllThreads:()=>{for(var worker of PThread.runningWorkers){terminateWorker(worker)}for(var worker of PThread.unusedWorkers){terminateWorker(worker)}PThread.unusedWorkers=[];PThread.runningWorkers=[];PThread.pthreads={}},returnWorkerToPool:worker=>{var pthread_ptr=worker.pthread_ptr;delete PThread.pthreads[pthread_ptr];PThread.unusedWorkers.push(worker);PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker),1);worker.pthread_ptr=0;__emscripten_thread_free_data(pthread_ptr)},threadInitTLS(){PThread.tlsInitFunctions.forEach(f=>f())},loadWasmModuleToWorker:worker=>new Promise(onFinishedLoading=>{worker.onmessage=e=>{var d=e["data"];var cmd=d.cmd;if(d.targetThread&&d.targetThread!=_pthread_self()){var targetWorker=PThread.pthreads[d.targetThread];if(targetWorker){targetWorker.postMessage(d,d.transferList)}else{err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`)}return}if(cmd==="checkMailbox"){checkMailbox()}else if(cmd==="spawnThread"){spawnThread(d)}else if(cmd==="cleanupThread"){callUserCallback(()=>cleanupThread(d.thread))}else if(cmd==="loaded"){worker.loaded=true;if(ENVIRONMENT_IS_NODE&&!worker.pthread_ptr){worker.unref()}onFinishedLoading(worker)}else if(d.target==="setimmediate"){worker.postMessage(d)}else if(cmd==="uncaughtException"){worker.onerror(d.error)}else if(cmd==="callHandler"){Module[d.handler](...d.args)}else if(cmd){err(`worker sent an unknown command ${cmd}`)}};worker.onerror=e=>{var message="worker sent an error!";err(`${message} ${e.filename}:${e.lineno}: ${e.message}`);throw e};if(ENVIRONMENT_IS_NODE){worker.on("message",data=>worker.onmessage({data}));worker.on("error",e=>worker.onerror(e))}var handlers=[];var knownHandlers=["onExit","onAbort","print","printErr"];for(var handler of knownHandlers){if(Module.propertyIsEnumerable(handler)){handlers.push(handler)}}worker.postMessage({cmd:"load",handlers,wasmMemory,wasmModule})}),async loadWasmModuleToAllWorkers(){if(ENVIRONMENT_IS_PTHREAD){return}let pthreadPoolReady=Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker));return pthreadPoolReady},allocateUnusedWorker(){var worker;if(Module["mainScriptUrlOrBlob"]){var pthreadMainJs=Module["mainScriptUrlOrBlob"];if(typeof pthreadMainJs!="string"){pthreadMainJs=URL.createObjectURL(pthreadMainJs)}worker=new Worker(ENVIRONMENT_IS_NODE&&typeof pthreadMainJs=="string"&&pthreadMainJs.startsWith("data:")?new URL(pthreadMainJs):pthreadMainJs,{type:"module",workerData:"em-pthread",name:"em-pthread"})}else worker=new Worker(new URL("skainet_kernels_mt.mjs",import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});PThread.unusedWorkers.push(worker)},getNewWorker(){if(PThread.unusedWorkers.length==0){PThread.allocateUnusedWorker();PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0])}return PThread.unusedWorkers.pop()}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);function establishStackSpace(pthread_ptr){var stackHigh=(growMemViews(),HEAPU32)[pthread_ptr+52>>>2>>>0];var stackSize=(growMemViews(),HEAPU32)[pthread_ptr+56>>>2>>>0];var stackLow=stackHigh-stackSize;_emscripten_stack_set_limits(stackHigh,stackLow);stackRestore(stackHigh)}var wasmTableMirror=[];var wasmTable;var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var invokeEntryPoint=(ptr,arg)=>{runtimeKeepaliveCounter=0;noExitRuntime=0;var result=getWasmTableEntry(ptr)(arg);function finish(result){if(keepRuntimeAlive()){EXITSTATUS=result;return}__emscripten_thread_exit(result)}finish(result)};var noExitRuntime=true;var registerTLSInit=tlsInitFunc=>PThread.tlsInitFunctions.push(tlsInitFunc);function pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(2,0,1,pthread_ptr,attr,startRoutine,arg);return ___pthread_create_js(pthread_ptr,attr,startRoutine,arg)}var _emscripten_has_threading_support=()=>typeof SharedArrayBuffer!="undefined";function ___pthread_create_js(pthread_ptr,attr,startRoutine,arg){pthread_ptr>>>=0;attr>>>=0;startRoutine>>>=0;arg>>>=0;if(!_emscripten_has_threading_support()){return 6}var transferList=[];var error=0;if(ENVIRONMENT_IS_PTHREAD&&(transferList.length===0||error)){return pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg)}if(error)return error;var threadParams={startRoutine,pthread_ptr,arg,transferList};if(ENVIRONMENT_IS_PTHREAD){threadParams.cmd="spawnThread";postMessage(threadParams,transferList);return 0}return spawnThread(threadParams)}function __emscripten_init_main_thread_js(tb){tb>>>=0;__emscripten_thread_init(tb,!ENVIRONMENT_IS_WORKER,1,!ENVIRONMENT_IS_WEB,65536,false);PThread.threadInitTLS()}var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var maybeExit=()=>{if(!keepRuntimeAlive()){try{if(ENVIRONMENT_IS_PTHREAD){if(_pthread_self())__emscripten_thread_exit(EXITSTATUS);return}_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};function __emscripten_thread_mailbox_await(pthread_ptr){pthread_ptr>>>=0;if(typeof Atomics.waitAsync==="function"){var wait=Atomics.waitAsync((growMemViews(),HEAP32),pthread_ptr>>>2,pthread_ptr);wait.value.then(checkMailbox);var waitingAsync=pthread_ptr+128;Atomics.store((growMemViews(),HEAP32),waitingAsync>>>2,1)}}var checkMailbox=()=>callUserCallback(()=>{var pthread_ptr=_pthread_self();if(pthread_ptr){__emscripten_thread_mailbox_await(pthread_ptr);__emscripten_check_mailbox()}});function __emscripten_notify_mailbox_postmessage(targetThread,currThreadId){targetThread>>>=0;currThreadId>>>=0;if(targetThread==currThreadId){setTimeout(checkMailbox)}else if(ENVIRONMENT_IS_PTHREAD){postMessage({targetThread,cmd:"checkMailbox"})}else{var worker=PThread.pthreads[targetThread];if(!worker){return}worker.postMessage({cmd:"checkMailbox"})}}var proxiedJSCallArgs=[];function __emscripten_receive_on_main_thread_js(funcIndex,emAsmAddr,callingThread,numCallArgs,args){emAsmAddr>>>=0;callingThread>>>=0;args>>>=0;numCallArgs/=2;proxiedJSCallArgs.length=numCallArgs;var b=args>>>3;for(var i=0;i<numCallArgs;i++){if((growMemViews(),HEAP64)[b+2*i>>>0]){proxiedJSCallArgs[i]=(growMemViews(),HEAP64)[b+2*i+1>>>0]}else{proxiedJSCallArgs[i]=(growMemViews(),HEAPF64)[b+2*i+1>>>0]}}var func=proxiedFunctionTable[funcIndex];PThread.currentProxiedOperationCallerThread=callingThread;var rtn=func(...proxiedJSCallArgs);PThread.currentProxiedOperationCallerThread=0;return rtn}function __emscripten_thread_cleanup(thread){thread>>>=0;if(!ENVIRONMENT_IS_PTHREAD)cleanupThread(thread);else postMessage({cmd:"cleanupThread",thread})}function __emscripten_thread_set_strongref(thread){thread>>>=0;if(ENVIRONMENT_IS_NODE){PThread.pthreads[thread].ref()}}var _emscripten_get_now=()=>performance.timeOrigin+performance.now();var _emscripten_check_blocking_allowed=()=>{};var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_exit_with_live_runtime=()=>{runtimeKeepalivePush();throw"unwind"};var getHeapMax=()=>4294901760;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize>>>=0;var oldSize=(growMemViews(),HEAPU8).length;if(requestedSize<=oldSize){return false}var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}var printCharBuffers=[null,[],[]];var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{idx>>>=0;var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer?heapOrArray.subarray(idx,endPtr):heapOrArray.slice(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};function _fd_write(fd,iov,iovcnt,pnum){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(3,0,1,fd,iov,iovcnt,pnum);iov>>>=0;iovcnt>>>=0;pnum>>>=0;var num=0;for(var i=0;i<iovcnt;i++){var ptr=(growMemViews(),HEAPU32)[iov>>>2>>>0];var len=(growMemViews(),HEAPU32)[iov+4>>>2>>>0];iov+=8;for(var j=0;j<len;j++){printChar(fd,(growMemViews(),HEAPU8)[ptr+j>>>0])}num+=len}(growMemViews(),HEAPU32)[pnum>>>2>>>0]=num;return 0}PThread.init();{initMemory();if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["wasmMemory"]=wasmMemory;var proxiedFunctionTable=[_proc_exit,exitOnMainThread,pthreadCreateProxied,_fd_write];var _skainet_fp32_matmul,_skainet_fp32_matmul_wt,_skainet_bf16_matmul,_skainet_fp16_matmul,_skainet_q4_0_matmul,_skainet_q4_0_matmul_rm,_skainet_q5_0_matmul,_malloc,_free,_skainet_q5_0_matmul_rm,_skainet_q5_1_matmul,_skainet_q5_1_matmul_rm,_skainet_q8_0_matmul,_skainet_q8_0_matmul_rm,_skainet_q4k_matmul,_skainet_q4k_matmul_rm,_skainet_q5k_matmul,_skainet_q5k_matmul_rm,_skainet_q6k_matmul,_skainet_q6k_matmul_rm,_skainet_ternary_f32_gemv,_skainet_ternary_lmhead_stage1,_skainet_bitnet_gemv_tq2_0,__emscripten_tls_init,_pthread_self,__emscripten_thread_init,__emscripten_thread_crashed,__emscripten_run_js_on_main_thread,__emscripten_thread_free_data,__emscripten_thread_exit,__emscripten_check_mailbox,_emscripten_stack_set_limits,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current;function assignWasmExports(wasmExports){Module["_skainet_fp32_matmul"]=_skainet_fp32_matmul=wasmExports["p"];Module["_skainet_fp32_matmul_wt"]=_skainet_fp32_matmul_wt=wasmExports["r"];Module["_skainet_bf16_matmul"]=_skainet_bf16_matmul=wasmExports["s"];Module["_skainet_fp16_matmul"]=_skainet_fp16_matmul=wasmExports["t"];Module["_skainet_q4_0_matmul"]=_skainet_q4_0_matmul=wasmExports["u"];Module["_skainet_q4_0_matmul_rm"]=_skainet_q4_0_matmul_rm=wasmExports["v"];Module["_skainet_q5_0_matmul"]=_skainet_q5_0_matmul=wasmExports["w"];Module["_malloc"]=_malloc=wasmExports["x"];Module["_free"]=_free=wasmExports["y"];Module["_skainet_q5_0_matmul_rm"]=_skainet_q5_0_matmul_rm=wasmExports["z"];Module["_skainet_q5_1_matmul"]=_skainet_q5_1_matmul=wasmExports["A"];Module["_skainet_q5_1_matmul_rm"]=_skainet_q5_1_matmul_rm=wasmExports["B"];Module["_skainet_q8_0_matmul"]=_skainet_q8_0_matmul=wasmExports["C"];Module["_skainet_q8_0_matmul_rm"]=_skainet_q8_0_matmul_rm=wasmExports["D"];Module["_skainet_q4k_matmul"]=_skainet_q4k_matmul=wasmExports["E"];Module["_skainet_q4k_matmul_rm"]=_skainet_q4k_matmul_rm=wasmExports["F"];Module["_skainet_q5k_matmul"]=_skainet_q5k_matmul=wasmExports["G"];Module["_skainet_q5k_matmul_rm"]=_skainet_q5k_matmul_rm=wasmExports["H"];Module["_skainet_q6k_matmul"]=_skainet_q6k_matmul=wasmExports["I"];Module["_skainet_q6k_matmul_rm"]=_skainet_q6k_matmul_rm=wasmExports["J"];Module["_skainet_ternary_f32_gemv"]=_skainet_ternary_f32_gemv=wasmExports["K"];Module["_skainet_ternary_lmhead_stage1"]=_skainet_ternary_lmhead_stage1=wasmExports["L"];Module["_skainet_bitnet_gemv_tq2_0"]=_skainet_bitnet_gemv_tq2_0=wasmExports["M"];__emscripten_tls_init=wasmExports["N"];_pthread_self=wasmExports["O"];__emscripten_thread_init=wasmExports["P"];__emscripten_thread_crashed=wasmExports["Q"];__emscripten_run_js_on_main_thread=wasmExports["R"];__emscripten_thread_free_data=wasmExports["S"];__emscripten_thread_exit=wasmExports["T"];__emscripten_check_mailbox=wasmExports["U"];_emscripten_stack_set_limits=wasmExports["V"];__emscripten_stack_restore=wasmExports["W"];__emscripten_stack_alloc=wasmExports["X"];_emscripten_stack_get_current=wasmExports["Y"]}var wasmImports;function assignWasmImports(){wasmImports={g:___pthread_create_js,k:__emscripten_init_main_thread_js,n:__emscripten_notify_mailbox_postmessage,l:__emscripten_receive_on_main_thread_js,c:__emscripten_thread_cleanup,j:__emscripten_thread_mailbox_await,i:__emscripten_thread_set_strongref,e:_emscripten_check_blocking_allowed,h:_emscripten_exit_with_live_runtime,b:_emscripten_get_now,m:_emscripten_resize_heap,f:_exit,d:_fd_write,a:wasmMemory}}function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper_pp=f=>a0=>f(a0)>>>0;var makeWrapper_p=f=>()=>f()>>>0;wasmExports["x"]=makeWrapper_pp(wasmExports["x"]);wasmExports["O"]=makeWrapper_p(wasmExports["O"]);wasmExports["X"]=makeWrapper_pp(wasmExports["X"]);wasmExports["Y"]=makeWrapper_p(wasmExports["Y"]);return wasmExports}function run(){if(runDependencies>0){dependenciesFulfilled=run;return}if(ENVIRONMENT_IS_PTHREAD){readyPromiseResolve?.(Module);initRuntime();return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;if(!ENVIRONMENT_IS_PTHREAD){wasmExports=await (createWasm());run()}if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
;return moduleRtn}export default createSkainetKernels;var isPthread=globalThis.self?.name?.startsWith("em-pthread");var isNode=typeof process=="object"&&process.versions?.node&&process.type!="renderer";if(isNode)isPthread=(await import("worker_threads")).workerData==="em-pthread";isPthread&&createSkainetKernels();
"
+    const val MT_WASM: String = "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"
 }
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmCpuOps.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmCpuOps.kt
index eb1df89f..1bad1cb7 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmCpuOps.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmCpuOps.kt
@@ -66,21 +66,10 @@ public class WasmCpuOps(
                 if (x.shape.dimensions.last() == k) {
                     val m = if (k == 0) 0 else x.shape.volume / k
                     val out = FloatArray(m * n)
-                    if (m > 0 && n > 0) {
-                        val inPtr = WasmKernels.alloc(m * k * 4)
-                        val outPtr = WasmKernels.alloc(m * n * 4)
-                        try {
-                            WasmKernels.writeFloats(inPtr, a.buffer, 0, m * k)
-                            // Resident like a packed weight: a parameter is immutable once loaded, and
-                            // re-uploading it per call made single-token decode run at copy speed.
-                            val wPtr = WasmKernels.denseWeightHandle(w.buffer)
-                            WasmKernels.fp32MatmulWt(inPtr, wPtr, outPtr, m, n, k)
-                            WasmKernels.readFloats(outPtr, out, 0, m * n)
-                        } finally {
-                            WasmKernels.free(outPtr)
-                            WasmKernels.free(inPtr)
-                        }
-                    }
+                    // The provider kernel keeps a whole-array weight resident like a packed one: a
+                    // parameter is immutable once loaded, and re-uploading it per call made
+                    // single-token decode run at copy speed.
+                    if (m > 0 && n > 0) WasmFp32MatmulWtKernel.matmulWt(a.buffer, 0, w.buffer, 0, out, 0, m, n, k)
                     val outShape = if (x.rank == 1) Shape(n) else Shape(*(x.shape.dimensions.copyOf(x.rank - 1) + n))
                     val outData = dataFactory.adoptFloatArray<T, Float>(outShape, x.dtype, out) as TensorData<T, V>
                     return newTensor(outData, x.dtype, x, weight)
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernelProvider.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernelProvider.kt
index 77848742..5ee5e209 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernelProvider.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernelProvider.kt
@@ -3,6 +3,7 @@ package sk.ainet.exec.wasm
 import sk.ainet.backend.api.kernel.Bf16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp16MatmulKernel
 import sk.ainet.backend.api.kernel.Fp32MatmulKernel
+import sk.ainet.backend.api.kernel.Fp32MatmulWtKernel
 import sk.ainet.backend.api.kernel.KernelProvider
 import sk.ainet.backend.api.kernel.Q4KMatmulKernel
 import sk.ainet.backend.api.kernel.Q4_0MatmulKernel
@@ -23,6 +24,7 @@ public object WasmKernelProvider : KernelProvider {
     override fun isAvailable(): Boolean = WasmKernels.isReady
 
     override fun matmulFp32(): Fp32MatmulKernel = WasmFp32MatmulKernel
+    override fun matmulFp32Wt(): Fp32MatmulWtKernel = WasmFp32MatmulWtKernel
     override fun matmulBf16(): Bf16MatmulKernel = WasmBf16MatmulKernel
     override fun matmulFp16(): Fp16MatmulKernel = WasmFp16MatmulKernel
 
@@ -165,3 +167,36 @@ public object WasmFp32MatmulKernel : Fp32MatmulKernel {
         }
     }
 }
+
+/**
+ * `out(m,n) = x(m,k) · w(n,k)ᵀ` in the sidecar (`skainet_fp32_matmul_wt`). A whole-array weight is a
+ * parameter and stays resident after its first call ([WasmKernels.denseWeightHandle]); a windowed
+ * weight is staged per call, as the activation always is.
+ */
+public object WasmFp32MatmulWtKernel : Fp32MatmulWtKernel {
+    override fun matmulWt(
+        x: FloatArray, xOffset: Int,
+        w: FloatArray, wOffset: Int,
+        out: FloatArray, outOffset: Int,
+        m: Int, n: Int, k: Int,
+    ) {
+        require(m >= 0 && n >= 0 && k >= 0) { "m, n, k must be non-negative; got m=$m n=$n k=$k" }
+        if (m == 0 || n == 0) return
+        val resident = wOffset == 0 && w.size == n * k
+        val inPtr = WasmKernels.alloc(maxOf(m * k, 1) * 4)
+        val wPtr = if (resident) WasmKernels.denseWeightHandle(w) else WasmKernels.alloc(maxOf(n * k, 1) * 4)
+        val outPtr = WasmKernels.alloc(m * n * 4)
+        try {
+            if (k > 0) {
+                WasmKernels.writeFloats(inPtr, x, xOffset, m * k)
+                if (!resident) WasmKernels.writeFloats(wPtr, w, wOffset, n * k)
+            }
+            WasmKernels.fp32MatmulWt(inPtr, wPtr, outPtr, m, n, k)
+            WasmKernels.readFloats(outPtr, out, outOffset, m * n)
+        } finally {
+            WasmKernels.free(outPtr)
+            if (!resident) WasmKernels.free(wPtr)
+            WasmKernels.free(inPtr)
+        }
+    }
+}
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernels.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernels.kt
index 19b00a64..b3be1241 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernels.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmKernels.kt
@@ -213,6 +213,24 @@ public object WasmKernels {
     public fun narrowFloatMatmul(fnName: String, aPtr: Int, aStride: Int, bPtr: Int, bByteStride: Int, cPtr: Int, cStride: Int, m: Int, n: Int, k: Int): Unit =
         jsNarrowFloatMatmul(mod(), fnName, aPtr, aStride, bPtr, bByteStride, cPtr, cStride, m, n, k)
 
+    /**
+     * `skainet_ternary_f32_gemv`: one FP32 activation row against a sequentially packed BitNet b1.58
+     * weight (`inputDim / 4` bytes per output row), per-tensor scale not applied.
+     */
+    public fun ternaryF32Gemv(inPtr: Int, weightPtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+        jsTernaryF32Gemv(mod(), inPtr, weightPtr, inputDim, outputDim, outPtr)
+
+    /**
+     * `skainet_ternary_lmhead_stage1`: four planes at [planesPtr] (each [planeStrideBytes] apart) with
+     * the fused weights `{1, ⅓, ⅑, 1/27}`, times the FP16 row scales at [rowScalePtr].
+     */
+    public fun ternaryLmheadStage1(inPtr: Int, planesPtr: Int, planeStrideBytes: Int, rowScalePtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+        jsTernaryLmheadStage1(mod(), inPtr, planesPtr, planeStrideBytes, rowScalePtr, inputDim, outputDim, outPtr)
+
+    /** `skainet_bitnet_gemv_tq2_0`: int8 activation codes with one absmax scale against TQ2_0 blocks. */
+    public fun bitnetGemvTq2_0(activationPtr: Int, activationScale: Float, weightPtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+        jsBitnetGemvTq2_0(mod(), activationPtr, activationScale, weightPtr, inputDim, outputDim, outPtr)
+
     // ── diagnostics ───────────────────────────────────────────────────────────────────────────────
 
     /**
@@ -301,6 +319,15 @@ private fun jsFp32MatmulWt(mod: JsAny, inPtr: Int, wPtr: Int, outPtr: Int, m: In
 private fun jsNarrowFloatMatmul(mod: JsAny, fnName: String, aPtr: Int, aStride: Int, bPtr: Int, bByteStride: Int, cPtr: Int, cStride: Int, m: Int, n: Int, k: Int): Unit =
     js("mod[fnName](aPtr, 0, aStride, bPtr, 0, bByteStride, cPtr, 0, cStride, m, n, k)")
 
+private fun jsTernaryF32Gemv(mod: JsAny, inPtr: Int, weightPtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+    js("mod._skainet_ternary_f32_gemv(inPtr, 0, weightPtr, 0, inputDim, outputDim, outPtr, 0)")
+
+private fun jsTernaryLmheadStage1(mod: JsAny, inPtr: Int, planesPtr: Int, planeStrideBytes: Int, rowScalePtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+    js("mod._skainet_ternary_lmhead_stage1(inPtr, 0, planesPtr, 0, planeStrideBytes, rowScalePtr, 0, inputDim, outputDim, outPtr, 0)")
+
+private fun jsBitnetGemvTq2_0(mod: JsAny, activationPtr: Int, activationScale: Float, weightPtr: Int, inputDim: Int, outputDim: Int, outPtr: Int): Unit =
+    js("mod._skainet_bitnet_gemv_tq2_0(activationPtr, 0, activationScale, weightPtr, 0, inputDim, outputDim, outPtr, 0)")
+
 private fun jsCrossOriginIsolated(): Boolean = js("typeof crossOriginIsolated !== 'undefined' && crossOriginIsolated === true")
 
 private fun jsHardwareConcurrency(): Int = js(
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmSimd.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmSimd.kt
index 6038f5af..2e4379a9 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmSimd.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmSimd.kt
@@ -13,9 +13,10 @@ import sk.ainet.exec.tensor.ops.WasmCpuOpsOverride
  * ```
  *
  * [install] loads the SIMD128 sidecar (pthreads build when the page is cross-origin isolated),
- * registers [WasmKernelProvider] and [WasmSimdKernelPack], and makes every context built afterwards
- * use [WasmCpuOps]. Without it — or before it completes — the engine runs the common scalar lane,
- * so an application may start rendering before the sidecar is up and simply get faster later.
+ * registers [WasmKernelProvider], [WasmSimdKernelPack] and [WasmTernaryKernelPack], and makes every
+ * context built afterwards use [WasmCpuOps]. Without it — or before it completes — the engine runs
+ * the common scalar lane, so an application may start rendering before the sidecar is up and simply
+ * get faster later.
  */
 public object WasmSimd {
     public val isInstalled: Boolean get() = WasmKernels.isReady && WasmCpuOpsOverride.factory != null
@@ -27,6 +28,7 @@ public object WasmSimd {
         // the auto-install on the next dispatch picks the sidecar provider and this pack's kernels.
         KernelDispatch.clearForTesting()
         WasmSimdKernelPack.install()
+        WasmTernaryKernelPack.install()
         WasmCpuOpsOverride.factory = { factory, schedule -> WasmCpuOps(factory, schedule) }
         // The same one-line banner the JVM factory prints, so a console shows which tier runs.
         println("[SKaiNET] Using SIMD128 sidecar kernels (${WasmKernels.features()})")
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmTernaryKernelPack.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmTernaryKernelPack.kt
new file mode 100644
index 00000000..2e348c79
--- /dev/null
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsMain/kotlin/sk/ainet/exec/wasm/WasmTernaryKernelPack.kt
@@ -0,0 +1,124 @@
+package sk.ainet.exec.wasm
+
+import sk.ainet.backend.api.kernel.BitNetGemvNative
+import sk.ainet.backend.api.kernel.TernaryF32GemvNative
+import sk.ainet.backend.api.kernel.TernaryF32KernelPack
+import sk.ainet.backend.api.kernel.TernaryKernelPacks
+import sk.ainet.backend.api.kernel.TernaryLmheadNative
+import sk.ainet.backend.api.kernel.TernaryPlanesKernelPack
+import sk.ainet.backend.api.kernel.ViewKernelPack
+
+/**
+ * The ternary kernels of the browser pack — the wasm sibling of the JVM `FfmTernaryKernelPackFactory`
+ * and the Android JNI ternary pack. Three native faces over the sidecar's exports:
+ *
+ * - [WasmTernaryF32Gemv] — `skainet_ternary_f32_gemv`, exact FP32 activations × `BITNET_B1_58`;
+ * - [WasmTernaryLmhead] — `skainet_ternary_lmhead_stage1`, the fused four-plane `BITNET_PLANES` lm_head;
+ * - [WasmBitNetGemv] — `skainet_bitnet_gemv_tq2_0`, int8 activations × `TQ2_0`.
+ *
+ * Each hands its weight to the sidecar **once** ([WasmKernels.weightHandle]) and stages the
+ * activation and output per call, like every other kernel in this module. Without this pack a
+ * BitNet weight in a browser went to the decoding reference kernel — correct, and hours per
+ * projection at model size. Installed by [WasmSimd.install] after the sidecar is up; there is no
+ * `ServiceLoader` on wasm.
+ */
+public object WasmTernaryKernelPack : ViewKernelPack {
+    override val name: String = "wasm-simd128-ternary"
+
+    override fun install() {
+        if (!WasmKernels.isReady) return
+        TernaryF32KernelPack.install(WasmTernaryF32Gemv)
+        TernaryPlanesKernelPack.install(WasmTernaryLmhead)
+        TernaryKernelPacks.install(WasmBitNetGemv)
+    }
+}
+
+/** `skainet_ternary_f32_gemv` in the sidecar: the sequential b1.58 payload, scale applied by the pack. */
+public object WasmTernaryF32Gemv : TernaryF32GemvNative {
+    override val name: String get() = "wasm-simd128"
+
+    override fun gemvPacked(
+        activation: FloatArray, activationOffset: Int,
+        weight: ByteArray, weightByteOffset: Int,
+        inputDim: Int, outputDim: Int,
+        out: FloatArray, outOffset: Int,
+    ) {
+        require(inputDim % 4 == 0) { "WasmTernaryF32Gemv: inputDim must be a multiple of 4; got $inputDim" }
+        if (outputDim == 0) return
+        if (inputDim == 0) {
+            out.fill(0f, outOffset, outOffset + outputDim)
+            return
+        }
+        val weightPtr = WasmKernels.weightHandle(weight, 0, weight.size) + weightByteOffset
+        val inPtr = WasmKernels.alloc(inputDim * 4)
+        val outPtr = WasmKernels.alloc(outputDim * 4)
+        try {
+            WasmKernels.writeFloats(inPtr, activation, activationOffset, inputDim)
+            WasmKernels.ternaryF32Gemv(inPtr, weightPtr, inputDim, outputDim, outPtr)
+            WasmKernels.readFloats(outPtr, out, outOffset, outputDim)
+        } finally {
+            WasmKernels.free(outPtr)
+            WasmKernels.free(inPtr)
+        }
+    }
+}
+
+/** `skainet_ternary_lmhead_stage1` in the sidecar: planes and row scales read from the resident weight. */
+public object WasmTernaryLmhead : TernaryLmheadNative {
+    override val name: String get() = "wasm-simd128"
+
+    override fun lmheadStage1(
+        activation: FloatArray, activationOffset: Int,
+        weight: ByteArray, planesByteOffset: Int,
+        planeStrideBytes: Int, rowScaleByteOffset: Int,
+        inputDim: Int, outputDim: Int,
+        out: FloatArray, outOffset: Int,
+    ) {
+        require(inputDim % 4 == 0) { "WasmTernaryLmhead: inputDim must be a multiple of 4; got $inputDim" }
+        require(rowScaleByteOffset % 2 == 0) { "WasmTernaryLmhead: rowScaleByteOffset must be 2-byte aligned; got $rowScaleByteOffset" }
+        if (outputDim == 0) return
+        val weightPtr = WasmKernels.weightHandle(weight, 0, weight.size)
+        val inPtr = WasmKernels.alloc(maxOf(inputDim, 1) * 4)
+        val outPtr = WasmKernels.alloc(outputDim * 4)
+        try {
+            if (inputDim > 0) WasmKernels.writeFloats(inPtr, activation, activationOffset, inputDim)
+            WasmKernels.ternaryLmheadStage1(
+                inPtr, weightPtr + planesByteOffset, planeStrideBytes, weightPtr + rowScaleByteOffset,
+                inputDim, outputDim, outPtr,
+            )
+            WasmKernels.readFloats(outPtr, out, outOffset, outputDim)
+        } finally {
+            WasmKernels.free(outPtr)
+            WasmKernels.free(inPtr)
+        }
+    }
+}
+
+/** `skainet_bitnet_gemv_tq2_0` in the sidecar: one token's int8 codes against resident TQ2_0 blocks. */
+public object WasmBitNetGemv : BitNetGemvNative {
+    override val name: String get() = "wasm-simd128"
+
+    override fun gemvTq2_0(
+        activation: ByteArray, activationOffset: Int, activationScale: Float,
+        weight: ByteArray, weightByteOffset: Int,
+        inputDim: Int, outputDim: Int,
+        out: FloatArray, outOffset: Int,
+    ) {
+        if (outputDim == 0) return
+        if (inputDim == 0) {
+            out.fill(0f, outOffset, outOffset + outputDim)
+            return
+        }
+        val weightPtr = WasmKernels.weightHandle(weight, 0, weight.size) + weightByteOffset
+        val actPtr = WasmKernels.alloc(inputDim)
+        val outPtr = WasmKernels.alloc(outputDim * 4)
+        try {
+            WasmKernels.writeBytes(actPtr, activation, activationOffset, inputDim)
+            WasmKernels.bitnetGemvTq2_0(actPtr, activationScale, weightPtr, inputDim, outputDim, outPtr)
+            WasmKernels.readFloats(outPtr, out, outOffset, outputDim)
+        } finally {
+            WasmKernels.free(outPtr)
+            WasmKernels.free(actPtr)
+        }
+    }
+}
diff --git a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsTest/kotlin/sk/ainet/exec/wasm/WasmSimdParityTest.kt b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsTest/kotlin/sk/ainet/exec/wasm/WasmSimdParityTest.kt
index 31c96f6e..96eefaf4 100644
--- a/skainet-backends/skainet-backend-wasm-simd/src/wasmJsTest/kotlin/sk/ainet/exec/wasm/WasmSimdParityTest.kt
+++ b/skainet-backends/skainet-backend-wasm-simd/src/wasmJsTest/kotlin/sk/ainet/exec/wasm/WasmSimdParityTest.kt
@@ -1,11 +1,25 @@
 package sk.ainet.exec.wasm
 
 import kotlinx.coroutines.test.runTest
+import sk.ainet.backend.api.kernel.BitNetGemvKernel
 import sk.ainet.backend.api.kernel.KernelDispatch
 import sk.ainet.backend.api.kernel.KernelRegistry
 import sk.ainet.backend.api.kernel.KernelStrictness
 import sk.ainet.backend.api.kernel.NoSuchKernelException
+import sk.ainet.backend.api.kernel.TernaryF32GemvKernel
+import sk.ainet.backend.api.kernel.TernaryPlanesMatmulKernel
 import sk.ainet.context.DirectCpuExecutionContext
+import sk.ainet.lang.memory.I8Absmax
+import sk.ainet.lang.memory.Scope
+import sk.ainet.lang.memory.Storage
+import sk.ainet.lang.memory.TensorView
+import sk.ainet.lang.memory.TernaryBlockDecoder
+import sk.ainet.lang.memory.TernaryCodec
+import sk.ainet.lang.memory.trace.RecordingTraceSink
+import sk.ainet.lang.memory.trace.TraceEvent
+import sk.ainet.lang.tensor.data.BitNetB158TensorData
+import sk.ainet.lang.tensor.data.BitNetPlanesTensorData
+import sk.ainet.lang.tensor.storage.TensorEncoding
 import sk.ainet.exec.kernel.ScalarBf16MatmulKernel
 import sk.ainet.exec.kernel.ScalarFp16MatmulKernel
 import sk.ainet.exec.kernel.ScalarQ4_KMatmulKernel
@@ -36,8 +50,8 @@ import kotlin.test.assertTrue
 
 /**
  * SKEEP-007 §T1: the SIMD128 sidecar agrees with the common scalar lane on every path it takes
- * over — row-major packed matmuls (Q8_0, Q4_0, Q4_K via the pack), dense `x · Wᵀ`, and the dense
- * GEMM — and the wiring makes a freshly built context use [WasmCpuOps].
+ * over — row-major packed matmuls (Q8_0, Q4_0, Q4_K via the pack), dense `x · Wᵀ`, the dense GEMM
+ * and the three ternary kernels — and the wiring makes a freshly built context use [WasmCpuOps].
  *
  * Runs on Node (`wasmJsNodeTest`): the sidecar is loaded from the module's own resources. Lane
  * sums differ from the sequential scalar accumulation in the last bits, so comparisons are
@@ -70,6 +84,8 @@ class WasmSimdParityTest {
         WasmSimd.uninstall()
     }
 
+    private fun heapFloats(view: TensorView): FloatArray = checkNotNull((view.storage as Storage.Heap).floats)
+
     @Suppress("UNCHECKED_CAST")
     private fun q8(ctx: DirectCpuExecutionContext, n: Int, k: Int, seed: Int): Tensor<FP32, Float> =
         ctx.fromData(Q8_0Quantizer.quantize(pseudo(n * k, seed, 2f), Shape(n, k)) as TensorData<FP32, Float>, FP32::class)
@@ -282,5 +298,78 @@ class WasmSimdParityTest {
         val direct = FloatArray(m * n)
         WasmFp32MatmulKernel.matmul(x, 0, k, b, 0, n, direct, 0, n, m, n, k)
         assertClose(refMm, direct, "provider gemm")
+        // The direct `x · Wᵀ` provider kernel: whole-array weight (resident) and a windowed one (staged).
+        val provider = checkNotNull(KernelRegistry.bestAvailable())
+        val wt = checkNotNull(provider.matmulFp32Wt())
+        assertTrue(provider.supports("matmul_wt", listOf("Float32", "Float32")))
+        val directWt = FloatArray(m * n)
+        wt.matmulWt(x, 0, w, 0, directWt, 0, m, n, k)
+        assertClose(refWt, directWt, "provider x·Wᵀ")
+        val window = FloatArray(1 + n * k + 3).also { w.copyInto(it, 1) }
+        val windowed = FloatArray(2 + m * n)
+        wt.matmulWt(x, 0, window, 1, windowed, 2, m, n, k)
+        assertClose(refWt, windowed.copyOfRange(2, 2 + m * n), "windowed x·Wᵀ")
+    }
+
+    /**
+     * The ternary kernels reach the sidecar through the same `KernelDispatch` keys the JVM FFM and
+     * Android JNI packs serve, and agree with the Kotlin reference kernels. Row counts above the row
+     * pool's threshold (512) so the mt sidecar splits the rows over its workers.
+     */
+    @Test
+    fun `ternary weights run on the sidecar and match the reference kernels`() = runTest {
+        WasmSimd.install()
+        val rng = Random(31)
+
+        // BITNET_B1_58, exact FP32 activations, two rows so the pack's row loop runs.
+        run {
+            val k = 256; val n = 600; val rows = 2
+            val values = FloatArray(n * k) { (rng.nextInt(3) - 1) * 0.5f }
+            val w = BitNetB158TensorData.fromFloats(Shape(n, k), values).packedView
+            val a = TensorView.dense(Storage.Heap.wrap(FloatArray(rows * k) { rng.nextFloat() - 0.5f }), Shape(rows, k), FP32)
+            val out = TensorView.dense(Storage.Heap.floats(rows * n), Shape(rows, n), FP32)
+            val sink = RecordingTraceSink()
+            KernelDispatch.matmul(a, w, out, Scope.Ambient, sink)
+            assertEquals("ternary_f32_gemv/wasm-simd128", sink.eventsOf<TraceEvent.KernelRun>().single().kernel)
+            val ref = TensorView.dense(Storage.Heap.floats(rows * n), Shape(rows, n), FP32)
+            TernaryF32GemvKernel(TernaryF32GemvKernel.keyFor()).run(listOf(a, w), ref)
+            assertClose(heapFloats(ref), heapFloats(out), "ternary f32 gemv", rel = 1e-4f)
+        }
+
+        // BITNET_PLANES: the fused four-plane lm_head, two calls per row, against the 8-plane reference.
+        run {
+            val k = 64; val n = 520
+            val values = FloatArray(n * k) { (rng.nextFloat() - 0.5f) * 2f }
+            val w = BitNetPlanesTensorData.fromFloats(Shape(n, k), values).packedView
+            val a = TensorView.dense(Storage.Heap.wrap(FloatArray(k) { rng.nextFloat() - 0.5f }), Shape(1, k), FP32)
+            val out = TensorView.dense(Storage.Heap.floats(n), Shape(1, n), FP32)
+            val sink = RecordingTraceSink()
+            KernelDispatch.matmul(a, w, out, Scope.Ambient, sink)
+            assertEquals("ternary_planes_matmul/wasm-simd128", sink.eventsOf<TraceEvent.KernelRun>().single().kernel)
+            val ref = TensorView.dense(Storage.Heap.floats(n), Shape(1, n), FP32)
+            TernaryPlanesMatmulKernel(TernaryPlanesMatmulKernel.keyFor()).run(listOf(a, w), ref)
+            assertClose(heapFloats(ref), heapFloats(out), "ternary planes lm_head", rel = 1e-4f)
+        }
+
+        // TQ2_0 with int8 activations: integer block sums, so the match is exact up to the scale products.
+        run {
+            val k = 768; val n = 600
+            val values = FloatArray(n * k) { (rng.nextInt(3) - 1) * 0.5f }
+            val w = TensorView.packed(
+                Storage.Heap.wrap(TernaryCodec.encode(TensorEncoding.TQ2_0, values)), Shape(n, k),
+                TensorEncoding.TQ2_0, TernaryBlockDecoder(TensorEncoding.TQ2_0),
+            )
+            val a = I8Absmax.requantize(
+                TensorView.dense(Storage.Heap.wrap(FloatArray(k) { rng.nextFloat() - 0.5f }), Shape(1, k), FP32), Scope.Ambient,
+            )
+            val out = TensorView.dense(Storage.Heap.floats(n), Shape(1, n), FP32)
+            val sink = RecordingTraceSink()
+            KernelDispatch.matmul(a, w, out, Scope.Ambient, sink)
+            assertEquals("bitnet_gemv/wasm-simd128", sink.eventsOf<TraceEvent.KernelRun>().single().kernel)
+            val ref = TensorView.dense(Storage.Heap.floats(n), Shape(1, n), FP32)
+            BitNetGemvKernel(BitNetGemvKernel.keyFor(w.format)).run(listOf(a, w), ref)
+            assertClose(heapFloats(ref), heapFloats(out), "bitnet gemv tq2_0")
+        }
+        assertTrue(WasmKernels.residentWeightBytes() > 0, "the ternary weights stay resident")
     }
 }