Add Bf16LoadPolicy.toDTypePolicy() adapter (W2 of #615)

Bridges the existing BF16-specific load-policy enum onto the
generalised DTypePolicy sealed type from W1:

  DEQUANT_TO_FP32 -> Require(FP32)
  KEEP_NATIVE     -> Require(BF16)

Existing call sites keep using the enum verbatim (no signature
changes), while new code paths — and the dtype-policy-aware
SafeTensors entry point in W0b — can flow through DTypePolicy
uniformly.

The exhaustive-when test guards against future enum additions
that forget to update the adapter: any new Bf16LoadPolicy arm
forces a compile error in toDTypePolicy() until it's mapped.

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

Author: michalharakal

skainet-io/skainet-io-safetensors/src/commonMain/kotlin/sk/ainet/io/safetensors/Bf16LoadPolicy.kt

@@ -1,5 +1,9 @@
 package sk.ainet.io.safetensors
 
+import sk.ainet.lang.types.BF16
+import sk.ainet.lang.types.DTypePolicy
+import sk.ainet.lang.types.FP32
+
 /**
  * Controls how the SafeTensors loader handles `BFLOAT16` (BF16) tensors.
  *
@@ -53,4 +57,23 @@ public enum class Bf16LoadPolicy {
      * transformer case).
      */
     KEEP_NATIVE,
+    ;
+
+    /**
+     * Maps this BF16-specific enum onto the generalised
+     * [DTypePolicy] sealed type. [DEQUANT_TO_FP32] becomes
+     * `Require(FP32)` (the loader must hand consumers an FP32
+     * tensor); [KEEP_NATIVE] becomes `Require(BF16)` (consumers
+     * dispatch on the native BF16 dtype).
+     *
+     * Bridge for the RFC's policy-driven loader work
+     * (`rfc.md`, issue #615): existing call sites keep using this
+     * enum verbatim while new code paths can flow through
+     * [DTypePolicy] uniformly. The two are equivalent for BF16 —
+     * this method is the explicit equivalence proof.
+     */
+    public fun toDTypePolicy(): DTypePolicy = when (this) {
+        DEQUANT_TO_FP32 -> DTypePolicy.Require(FP32)
+        KEEP_NATIVE -> DTypePolicy.Require(BF16)
+    }
 }

skainet-io/skainet-io-safetensors/src/commonTest/kotlin/sk/ainet/io/safetensors/Bf16LoadPolicyToDTypePolicyTest.kt

@@ -0,0 +1,41 @@
+package sk.ainet.io.safetensors
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import sk.ainet.lang.types.BF16
+import sk.ainet.lang.types.DTypePolicy
+import sk.ainet.lang.types.FP32
+
+/**
+ * Verifies the [Bf16LoadPolicy.toDTypePolicy] adapter — the bridge
+ * between the BF16-specific enum (existing prior art) and the
+ * generalised [DTypePolicy] sealed type (W1 of #615). Confirms
+ * both arms of the enum land on equivalent `Require` policies so
+ * downstream code paths can flow through `DTypePolicy` uniformly.
+ */
+class Bf16LoadPolicyToDTypePolicyTest {
+
+    @Test
+    fun dequant_to_fp32_maps_to_require_fp32() {
+        val policy = Bf16LoadPolicy.DEQUANT_TO_FP32.toDTypePolicy()
+        assertEquals(DTypePolicy.Require(FP32), policy)
+    }
+
+    @Test
+    fun keep_native_maps_to_require_bf16() {
+        val policy = Bf16LoadPolicy.KEEP_NATIVE.toDTypePolicy()
+        assertEquals(DTypePolicy.Require(BF16), policy)
+    }
+
+    @Test
+    fun adapter_covers_every_enum_arm() {
+        // Defensive: if a new arm is added to Bf16LoadPolicy without
+        // also updating toDTypePolicy, this test surfaces it because
+        // toDTypePolicy's `when` is exhaustive — Kotlin emits a
+        // compile error rather than silently dropping the case.
+        for (arm in Bf16LoadPolicy.entries) {
+            val mapped = arm.toDTypePolicy()
+            assertEquals(true, mapped is DTypePolicy.Require, "$arm must map to Require, got $mapped")
+        }
+    }
+}