Add toStableHlo(ResolvedComputeGraph) overload (W9 of #615)

Closes the dtype-policy RFC implementation loop: the HLO converter
now has an entry point that consumes the resolved graph produced
by DTypeConstraintResolutionPass (W7) and validated by the
ResolvedComputeGraph wrapper (W8).

Contract: callers that flow through this overload get a precondition
guarantee — every edge has a parseable dtype, every node carries
the `dtype_resolved` marker — before any MLIR string emission.
validate=true by default; validate=false escape hatch for
debugging.

Today the converter still delegates to the underlying ComputeGraph
emit path (so HLO output is byte-identical between the two entry
points). The wrapper is the *contract*, not a parallel emit. As
future passes start writing layout / backend metadata into the
resolved graph, the converter can read those typed accessors
directly via graph.resolvedLayout / graph.backendAssignment — the
hooks are in place.

Three tests:
- byte-identical output via both entry points for a valid graph
- default validate=true rejects an unresolved graph
- validate=false escape hatch still emits HLO

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

Author: michalharakal

skainet-compile/skainet-compile-hlo/src/commonMain/kotlin/sk/ainet/compile/hlo/dag2hlo.kt

@@ -55,6 +55,40 @@ public fun toStableHlo(graph: ComputeGraph, functionName: String = "main"): Stab
     return converter.convert(graph, functionName)
 }
 
+/**
+ * Export a [sk.ainet.lang.graph.ResolvedComputeGraph] into a StableHLO
+ * MLIR module — the dtype-resolved entry point that the W7
+ * `DTypeConstraintResolutionPass` produces.
+ *
+ * The contract this overload upholds vs the plain [ComputeGraph]
+ * variant: every edge's dtype has already been resolved to a typed
+ * [sk.ainet.lang.types.DType] (the wrapper's `validate()` would
+ * have caught any unparseable strings), and every node carries the
+ * `dtype_resolved` marker from the pass. Callers that flow through
+ * this overload get a precondition guarantee that the HLO emit
+ * step won't silently misinterpret a stray dtype string.
+ *
+ * Today the converter still consumes the underlying [ComputeGraph] —
+ * the wrapper is the *contract*, not a separate emit path. As
+ * future passes start writing layout / backend metadata into the
+ * resolved graph, the converter can read those typed accessors
+ * directly. This entry point gives them the stable hook to do so.
+ */
+public fun toStableHlo(
+    graph: sk.ainet.lang.graph.ResolvedComputeGraph,
+    functionName: String = "main",
+    validate: Boolean = true,
+): StableHloModule {
+    if (validate) {
+        graph.validate().requireValid()
+    }
+    // Delegate to the underlying ComputeGraph emit path — same HLO output
+    // for graphs that pass validation. Future versions can branch here to
+    // consume `graph.resolvedLayout(edgeId)` / `graph.backendAssignment(nodeId)`
+    // once those passes ship.
+    return toStableHlo(graph.delegate, functionName)
+}
+
 /**
  * Legacy implementation for backward compatibility.
  * 

skainet-compile/skainet-compile-hlo/src/commonTest/kotlin/sk/ainet/compile/hlo/ResolvedComputeGraphHloTest.kt

@@ -0,0 +1,94 @@
+package sk.ainet.compile.hlo
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import sk.ainet.lang.graph.DefaultComputeGraph
+import sk.ainet.lang.graph.GraphEdge
+import sk.ainet.lang.graph.GraphNode
+import sk.ainet.lang.graph.ResolvedComputeGraph
+import sk.ainet.lang.tensor.ops.GenericOperation
+import sk.ainet.lang.tensor.ops.TensorSpec
+
+/**
+ * Round-trip and byte-equivalence tests for the
+ * `toStableHlo(ResolvedComputeGraph)` overload added in W9 of #615.
+ *
+ * Key property: when the underlying graph passes resolved-graph
+ * validation, the two HLO entry points must produce byte-identical
+ * output. The wrapper is the *contract*, not a separate emit path.
+ */
+class ResolvedComputeGraphHloTest {
+
+    private fun buildSimpleGraph(): DefaultComputeGraph {
+        val g = DefaultComputeGraph()
+        val resolvedMeta = mapOf<String, Any>("dtype_resolved" to true)
+        val input = g.addNode(
+            GraphNode(
+                id = "input",
+                operation = GenericOperation("input"),
+                inputs = emptyList(),
+                outputs = listOf(TensorSpec("input-out", listOf(2, 3), "FP32")),
+                metadata = resolvedMeta,
+            ),
+        )
+        val relu = g.addNode(
+            GraphNode(
+                id = "relu",
+                operation = GenericOperation("relu"),
+                inputs = listOf(TensorSpec("input-out", listOf(2, 3), "FP32")),
+                outputs = listOf(TensorSpec("relu-out", listOf(2, 3), "FP32")),
+                metadata = resolvedMeta,
+            ),
+        )
+        g.addEdge(GraphEdge("e1", input, relu, tensorSpec = TensorSpec("e1", listOf(2, 3), "FP32")))
+        return g
+    }
+
+    @Test
+    fun resolved_overload_produces_same_module_as_plain_overload() {
+        val g = buildSimpleGraph()
+        val viaPlain = toStableHlo(g)
+        val viaResolved = toStableHlo(ResolvedComputeGraph(g))
+        // functionName + content are byte-identical.
+        assertEquals(viaPlain.functionName, viaResolved.functionName)
+        assertEquals(viaPlain.content, viaResolved.content)
+    }
+
+    @Test
+    fun resolved_overload_validates_by_default() {
+        // Build a graph that's missing the dtype_resolved marker.
+        val g = DefaultComputeGraph()
+        val node = g.addNode(
+            GraphNode(
+                id = "input",
+                operation = GenericOperation("input"),
+                inputs = emptyList(),
+                outputs = listOf(TensorSpec("input-out", listOf(2), "FP32")),
+                metadata = emptyMap(),
+            ),
+        )
+        // Default validate = true must reject this.
+        assertFailsWith<IllegalArgumentException> {
+            toStableHlo(ResolvedComputeGraph(g))
+        }
+    }
+
+    @Test
+    fun resolved_overload_skips_validation_when_opted_out() {
+        // Same unmarked graph, but validate = false.
+        val g = DefaultComputeGraph()
+        g.addNode(
+            GraphNode(
+                id = "input",
+                operation = GenericOperation("input"),
+                inputs = emptyList(),
+                outputs = listOf(TensorSpec("input-out", listOf(2), "FP32")),
+                metadata = emptyMap(),
+            ),
+        )
+        // No throw expected.
+        val module = toStableHlo(ResolvedComputeGraph(g), validate = false)
+        assertEquals("main", module.functionName)
+    }
+}