Extract transformer-core: NN primitives reusable on all targets incl. androidNative

llm-core's transformer primitives (KV-cache family, MultiHeadAttention, Embedding,
RMSNormalization, RoPE, SwiGLU/GeGLU FFN, ResidualAdd, LinearProjection, …) only need
skainet-lang-core (which has androidNative), but were trapped in llm-core, whose other
deps (io-gguf/io-core/compile-*/backend-cpu) have no androidNative — so ARM-native
consumers (the Amlogic box) couldn't reuse them and had to reimplement.

Move the 15 lang-core-only NN files (transformer/, layers/, normalization/,
dsl/TransformerDsl.kt) into a new transformer-core module that depends ONLY on
skainet-lang-core and declares the full matrix INCLUDING androidNativeArm32/Arm64.
llm-core api-depends on transformer-core (re-exports), so existing consumers are
unaffected. dsl/decoder/* stays in llm-core (DecoderTransformerNetwork needs
apps.llm.HybridTransformerBlock, which is compile-opt-coupled).

Decoupled the one back-reference: MultiHeadAttention's diagnostic dumpStats call now
goes through a settable `mhaStatSink` (default no-op) that HybridTransformerBlock wires
to llm-core's platform dumpStats — no functionality lost.

Verified: transformer-core compiles for jvm + androidNativeArm32 + arm64; llm-core
builds + jvmTest green (5/5).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: michalharakal

llm-core/build.gradle.kts

@@ -48,6 +48,7 @@ kotlin {
             // versions. Bumping the engine is then a one-line change at the
             // top of `gradle/libs.versions.toml`.
             implementation(project.dependencies.platform(project(":llm-bom")))
+            api(project(":transformer-core"))
             implementation(libs.skainet.lang.core)
             implementation(libs.skainet.compile.dag)
             implementation(libs.skainet.compile.opt)

llm-core/src/commonMain/kotlin/sk/ainet/apps/llm/HybridTransformerBlock.kt

@@ -168,7 +168,11 @@ public class HybridTransformerBlock<T : DType, V>(
             // the same name — so MHA can't gate its own dump on the block id.
             // Toggle the static flag from here, where we know which block we're in.
             val isMhaCall = dumpMha && module is MultiHeadAttention<*, *>
-            if (isMhaCall) sk.ainet.lang.nn.transformer.MultiHeadAttentionDiag.shouldDumpThisCall = true
+            if (isMhaCall) {
+                // wire transformer-core's MHA diagnostic sink to llm-core's platform dumpStats (idempotent)
+                sk.ainet.lang.nn.transformer.mhaStatSink = { l, t -> sk.ainet.apps.llm.diag.dumpStats(l, t) }
+                sk.ainet.lang.nn.transformer.MultiHeadAttentionDiag.shouldDumpThisCall = true
+            }
             tmp = module.forward(tmp, ctx)
             if (isMhaCall) sk.ainet.lang.nn.transformer.MultiHeadAttentionDiag.shouldDumpThisCall = false
             outputs[i + 1] = tmp

settings.gradle.kts

@@ -24,6 +24,7 @@ if (providers.gradleProperty("useLocalSkainet").orNull == "true") {
 rootProject.name = "SKaiNET-transformers"
 
 include("llm-api")
+include("transformer-core")
 include("llm-core")
 include("llm-agent")
 include("llm-providers")

transformer-core/build.gradle.kts

@@ -0,0 +1,43 @@
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.androidMultiplatformLibrary)
+    alias(libs.plugins.vanniktech.mavenPublish)
+}
+
+// Framework NN primitives (attention, KV-cache family, embedding, norms, RoPE, FFNs) extracted from
+// llm-core so they build on the FULL target matrix — including androidNative (the 32-bit box + phones).
+// Depends ONLY on skainet-lang-core (which has androidNative); no io/compile/backend deps. llm-core
+// re-exports this module, so existing consumers are unaffected; ARM-native consumers depend on it directly.
+kotlin {
+    android {
+        namespace = "sk.ainet.lang.nn"
+        compileSdk = libs.versions.android.compileSdk.get().toInt()
+        minSdk = libs.versions.android.minSdk.get().toInt()
+        compilerOptions { jvmTarget.set(JvmTarget.JVM_11) }
+    }
+
+    jvm()
+    androidNativeArm32()
+    androidNativeArm64()
+    iosArm64()
+    iosSimulatorArm64()
+    linuxX64()
+    linuxArm64()
+    macosArm64()
+    js { browser() }
+    @OptIn(ExperimentalWasmDsl::class) wasmJs { browser() }
+    @OptIn(ExperimentalWasmDsl::class) wasmWasi { nodejs() }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(project.dependencies.platform(project(":llm-bom")))
+            api(libs.skainet.lang.core)   // public API is lang-core-typed (Tensor/Module/ExecutionContext)
+        }
+        commonTest.dependencies {
+            implementation(libs.kotlin.test)
+        }
+    }
+}

…n/sk/ainet/lang/nn/dsl/TransformerDsl.kt …n/sk/ainet/lang/nn/dsl/TransformerDsl.ktllm-core/src/commonMain/kotlin/sk/ainet/lang/nn/dsl/TransformerDsl.kt renamed to transformer-core/src/commonMain/kotlin/sk/ainet/lang/nn/dsl/TransformerDsl.kt llm-core/src/commonMain/kotlin/sk/ainet/lang/nn/dsl/TransformerDsl.kt renamed to transformer-core/src/commonMain/kotlin/sk/ainet/lang/nn/dsl/TransformerDsl.kt

@@ -15,7 +15,7 @@ import kotlin.reflect.KClass
  *
  * Computes: down_proj(gelu(gate_proj(x)) * up_proj(x))
  *
- * Identical parameter layout to [SwiGLUFFN] so [sk.ainet.apps.llm.weights.LlamaGGUFNameResolver]
+ * Identical parameter layout to [SwiGLUFFN] so `LlamaGGUFNameResolver` (llm-core)
  * maps the same GGUF tensor names. The only difference is the activation
  * (GELU instead of SiLU).
  *