@@ -405,6 +405,17 @@ All in `PM/commonTest`, so they run wherever the interpreter loads.
   `Status: partial`, `python-multiplatform-gradle-plugin/fixtures/artifact/.../WalkedArtifactCallbackTest.kt`; a value-returning slot
   (`() -> Float`) does not yet accept a Python callable (`M3ProofRenderTest.kt`
   `aValueReturningFunctionSlotDoesNotYetAcceptAPythonCallable`).
+  A parameter typed as a **functional interface** (a Java interface with one abstract method, such as
+  `java.lang.Runnable`, or a Kotlin `fun interface`) whose method returns `Unit`/`void` and which is
+  not generic takes a Python callable as well as a Kotlin handle (#216). Its slot type name is the
+  interface, `|`, and the equivalent `kotlin.FunctionN` (`java.lang.Runnable|kotlin.Function0()->kotlin.Unit`):
+  the binding layer makes a callable into that function type and checks a handle against the
+  interface, and generated source converts a wrapper with a SAM lambda (`java.lang.Runnable { f() }`)
+  and casts anything else, with no reflection. A JDK interface is read from the JDK the build runs
+  on, any other from the consumer's jars. The stub shows the slot as a `Callable`. A functional
+  interface whose method returns a value, or a generic one, is left as it was: a handle parameter
+  (Compose's `Alignment` is one). `Status: implemented` on desktop, `GP/artifact/SamParameterBindingTest.kt`,
+  `python-multiplatform-gradle-plugin/fixtures/artifact/.../WalkedArtifactSamParameterTest.kt`.
 - **B-6** `@Composable` functions are callable from Python inside a composition; a Python click reaches
   a Kotlin callback and the redraw shows it. `Status: implemented` on desktop,
   `python-multiplatform-compose/fixtures/compose/src/desktopTest/` (`ComposableRenderTest.kt`, `M3ProofRenderTest.kt`,
 
@@ -0,0 +1,22 @@
+// Walked by `:python-multiplatform-gradle-plugin-fixtures:artifact` (its `fixture.valueclass` include covers this
+// package): functional-interface parameters issue #216 fills with a Python callable.
+package fixture.valueclass.sam
+
+/** A Kotlin `fun interface` that is handed two values. */
+fun interface Listener {
+    fun onEvent(name: String, count: Int)
+}
+
+/** The `CoroutineDispatcher.dispatch(context, block: Runnable)` shape, which runs the block at once. */
+fun runRunnable(block: Runnable) = block.run()
+
+/** Hands the listener a name and its length. */
+fun notifyListener(listener: Listener, name: String) = listener.onEvent(name, name.length)
+
+private var heard = ""
+
+/** A listener Kotlin made, so the same slot is shown taking a Kotlin handle as well as a callable. */
+fun loggingListener(): Listener = Listener { name, count -> heard = "$name:$count" }
+
+/** What [loggingListener]'s listener heard last. */
+fun lastHeard(): String = heard
@@ -0,0 +1,76 @@
+package fixture.artifact
+
+import python.multiplatform.ffi.Python3
+import python.multiplatform.ffi.pythonx.PythonCallables
+import python.multiplatform.ffi.pythonx.PythonxAdapter
+import python.multiplatform.ffi.upcall.PythonProxySource
+import python.multiplatform.ffi.upcall.UpcallBootstrap
+import python.multiplatform.generated.FunctionTable
+import python.multiplatform.generated.artifacts.ArtifactTable
+import python.multiplatform.reflection.UpcallTable
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+
+/**
+ * Issue #216, end to end: a Python callable fills a `java.lang.Runnable` and a Kotlin `fun interface`
+ * parameter of a walked declaration (`fixture.valueclass.sam`), and Kotlin runs it.
+ *
+ * Red before #216: `run_runnable` and `notify_listener` do not exist, because the walker declined both.
+ */
+class WalkedArtifactSamParameterTest {
+
+    @BeforeTest
+    fun installBothProducers() {
+        Python3.initialize(silent = true)
+        UpcallTable.clear()
+        UpcallTable.install(FunctionTable.fragments + ArtifactTable.fragments)
+        check(UpcallBootstrap.publishToGlobals()) { "UpcallBootstrap.publishToGlobals() failed" }
+        PythonProxySource.install()
+        PythonxAdapter.install(PYTHONX_RAW_VALUE_CLASSES)
+    }
+
+    @AfterTest
+    fun cleanup() {
+        UpcallTable.clear()
+    }
+
+    @Test
+    fun aPythonCallableRunsAsARunnable() {
+        PythonCallables.withScope(PythonCallables.newScope()) {
+            Python3.exec(
+                """
+                from fixture.valueclass.sam import run_runnable
+                _sam_ran = []
+                run_runnable(lambda: _sam_ran.append('ran'))
+                assert _sam_ran == ['ran'], 'the Runnable did not run the Python callable: ' + repr(_sam_ran)
+                """.trimIndent(),
+            )
+        }
+    }
+
+    @Test
+    fun aPythonCallableRunsAsAFunInterfaceWithItsArguments() {
+        PythonCallables.withScope(PythonCallables.newScope()) {
+            Python3.exec(
+                """
+                from fixture.valueclass.sam import notify_listener
+                _sam_events = []
+                notify_listener(lambda name, count: _sam_events.append((name, count)), 'hello')
+                assert _sam_events == [('hello', 5)], repr(_sam_events)
+                """.trimIndent(),
+            )
+        }
+    }
+
+    @Test
+    fun aKotlinImplementationStillFillsTheSameSlot() {
+        Python3.exec(
+            """
+            from fixture.valueclass.sam import notify_listener, logging_listener, last_heard
+            notify_listener(logging_listener(), 'abc')
+            assert last_heard() == 'abc:3', 'a Kotlin Listener handle did not reach the slot: ' + repr(last_heard())
+            """.trimIndent(),
+        )
+    }
+}
@@ -71,6 +71,13 @@ class WalkedArtifactTableTest {
                 "fixture.valueclass.member.Tally.total=",
                 "fixture.valueclass.member.Tally.twin",
                 "fixture.valueclass.member.newSwitch",
+                // `fixture.valueclass.sam` (issue #216): functional-interface parameters, filled with a Python
+                // callable. `WalkedArtifactSamParameterTest` calls them.
+                "fixture.valueclass.sam.Listener.onEvent",
+                "fixture.valueclass.sam.lastHeard",
+                "fixture.valueclass.sam.loggingListener",
+                "fixture.valueclass.sam.notifyListener",
+                "fixture.valueclass.sam.runRunnable",
                 "fixture.valueclass.sumMeters",
                 "junit.runner.BaseTestRunner.getFilteredTrace",
                 "junit.runner.BaseTestRunner.getPreference__String",
 
@@ -6,6 +6,7 @@ import kotlin.metadata.KmType
 import kotlin.metadata.KmVariance
 import kotlin.metadata.MemberKind
 import kotlin.metadata.Visibility
+import kotlin.metadata.isFunInterface
 import kotlin.metadata.isNullable
 import kotlin.metadata.isSuspend
 import kotlin.metadata.isValue
@@ -587,7 +588,9 @@ internal object ArtifactScanner {
         // A zero-parameter member of a group -- there can be at most one, so this only ever has to
         // be distinct from the others, not descriptive.
         if (parts.isEmpty()) return "0"
-        return parts.joinToString("_") { name ->
+        return parts.joinToString("_") { slotName ->
+            // A functional-interface slot (issue #216) is named by its interface, not by the callable form.
+            val name = slotName.substringBefore(SAM_SEPARATOR)
             val chosen = if (qualified) name else name.substringAfterLast('.')
             chosen.map { if (it.isLetterOrDigit()) it else '_' }.joinToString("")
         }
@@ -1759,6 +1762,9 @@ internal object ArtifactScanner {
         val typeName: String? = null,
         val boundary: BoundaryType? = null,
         val declineReason: String? = null,
+        /** The type a stub shows for the slot when it is not the declared one: a functional
+         * interface's `kotlin.FunctionN` (issue #216). */
+        val modelType: KotlinTypeModel? = null,
     )
 
     /**
@@ -1851,6 +1857,142 @@ internal object ArtifactScanner {
         return FunctionSlot(typeName = name, boundary = BoundaryType("OBJECT", "(%s as $rendered)", "(%s)"))
     }
 
+    /**
+     * A parameter typed as a **functional interface** (issue #216): a Java interface with one abstract
+     * method (`java.lang.Runnable`) or a Kotlin `fun interface`, whose method returns `Unit` and which is
+     * not generic. `null` for anything else, which leaves the parameter exactly as it was -- an
+     * interface on the classpath still crosses as a handle (`Alignment` is a `fun interface` whose
+     * method returns an `IntOffset`, and its slots must keep taking `Alignment.Center`).
+     *
+     * The slot takes **both** a Python callable and a Kotlin handle. Its type name is the interface's,
+     * then [SAM_SEPARATOR], then the `kotlin.FunctionN` it is equivalent to
+     * (`java.lang.Runnable|kotlin.Function0()->kotlin.Unit`): the binding layer fills it from a callable
+     * through the wrapper path a function type has (B-5, `pythonx._make_function`) and checks a handle
+     * against the interface. The generated read converts a wrapper with a SAM lambda and casts anything
+     * else -- `((%s).let { v -> if (v is kotlin.Function0<*>) java.lang.Runnable { ... } else v as
+     * java.lang.Runnable })` -- which `kotlinc` compiles; nothing is looked up at run time (AGENTS.md §12).
+     *
+     * The interface is read off the consumer's classpath, or, for a `java.`/`javax.` one, off the JDK
+     * this build runs on ([jdkClassNode]): the walk's classpath is the consumer's jars and never held
+     * `java.lang.Runnable`, which is why `runRunnable(block: Runnable)` was declined.
+     */
+    private fun functionalInterfaceSlotOrNull(type: KmType, classpath: ArtifactClasspath): FunctionSlot? {
+        val classifier = type.classifier as? KmClassifier.Class ?: return null
+        val internal = classifier.name
+        if (internal.startsWith(KOTLIN_FUNCTION_INTERNAL_PREFIX)) return null
+        if (type.arguments.isNotEmpty()) return null
+        val binary = internal.replace('.', '$')
+        val node = classpath.classNode(binary) ?: jdkClassNode(binary) ?: return null
+        if (!node.access.hasFlag(Opcodes.ACC_INTERFACE) || !node.access.hasFlag(Opcodes.ACC_PUBLIC)) return null
+        if (node.signature?.startsWith("<") == true) return null
+        val kmClass = when (val metadata = kotlinClassMetadataOf(node)) {
+            null -> null
+            is KotlinClassMetadata.Class -> metadata.kmClass.takeIf { it.isFunInterface } ?: return null
+            else -> return null
+        }
+        val method = abstractMethodsOf(node, classpath)?.singleOrNull() ?: return null
+        val (descriptors, returns) = splitMethodDescriptor(method.desc)
+        if (returns != "V") return null
+        // A Kotlin `fun interface` says each parameter's nullability; a Java one does not, so an object
+        // parameter is taken as nullable there -- Java may pass `null`, and a non-null type would throw.
+        val parameterTypes: List<Pair<String, String>> = if (kmClass != null) {
+            val declared = kmClass.functions.singleOrNull { it.name == method.name } ?: return null
+            if (declared.valueParameters.size != descriptors.size) return null
+            declared.valueParameters.map { parameter ->
+                val name = kotlinClassifierNameOf(parameter.type) ?: return null
+                name to (renderKotlinSourceType(parameter.type, classpath, depth = 0) ?: return null)
+            }
+        } else {
+            descriptors.map { descriptor -> javaParameterTypeOf(descriptor, classpath) ?: return null }
+        }
+        val qualified = internal.replace('/', '.')
+        val arity = parameterTypes.size
+        val functionType = "kotlin.Function$arity<" + (parameterTypes.map { it.second } + UNIT_TYPE_NAME).joinToString(", ") + ">"
+        val star = "kotlin.Function$arity<" + List(arity + 1) { "*" }.joinToString(", ") + ">"
+        val names = (0 until arity).map { "p$it" }
+        val arrow = if (arity == 0) "" else names.joinToString(", ", postfix = " -> ")
+        val convert = "v -> if (v is $star) $qualified { $arrow(v as $functionType)(${names.joinToString(", ")}) } else v as $qualified"
+        val read = if (type.isNullable) "((%s)?.let { $convert })" else "((%s).let { $convert })"
+        return FunctionSlot(
+            typeName = qualified + SAM_SEPARATOR + KOTLIN_FUNCTION_PREFIX + arity +
+                "(" + parameterTypes.joinToString(",") { it.first } + ")" + FUNCTION_RETURNS + UNIT_TYPE_NAME,
+            boundary = BoundaryType("OBJECT", read, "(%s)"),
+            modelType = KotlinTypeModel(
+                "kotlin.Function$arity",
+                isNullable = type.isNullable,
+                arguments = parameterTypes.map { KotlinTypeModel(it.first) } + KotlinTypeModel(UNIT_TYPE_NAME),
+            ),
+        )
+    }
+
+    /** Separates a functional-interface slot's interface from the function type a callable fills it as
+     * (issue #216). Must match `pythonx`'s `_SAM_SEPARATOR`; not a character a classifier can contain. */
+    internal const val SAM_SEPARATOR: String = "|"
+
+    /** `Object`'s public methods, which an interface may redeclare without becoming non-functional. */
+    private val OBJECT_METHOD_SIGNATURES = setOf(
+        "equals" to "(Ljava/lang/Object;)Z",
+        "hashCode" to "()I",
+        "toString" to "()Ljava/lang/String;",
+    )
+
+    /**
+     * The abstract methods an interface leaves to an implementation, its superinterfaces' included and
+     * minus any a subinterface gives a default body; `null` when a superinterface cannot be read.
+     */
+    private fun abstractMethodsOf(node: ClassNode, classpath: ArtifactClasspath): List<org.objectweb.asm.tree.MethodNode>? {
+        val abstract = LinkedHashMap<Pair<String, String>, org.objectweb.asm.tree.MethodNode>()
+        val concrete = HashSet<Pair<String, String>>()
+        fun visit(current: ClassNode, depth: Int): Boolean {
+            if (depth > 8) return false
+            current.methods.filter { !it.access.hasFlag(Opcodes.ACC_STATIC) && !it.access.hasFlag(Opcodes.ACC_SYNTHETIC) }.forEach { method ->
+                val key = method.name to method.desc
+                if (key in OBJECT_METHOD_SIGNATURES || method.name.startsWith("<")) return@forEach
+                if (method.access.hasFlag(Opcodes.ACC_ABSTRACT)) abstract.putIfAbsent(key, method) else concrete += key
+            }
+            return current.interfaces.all { parent ->
+                val parentNode = classpath.classNode(parent) ?: jdkClassNode(parent) ?: return false
+                visit(parentNode, depth + 1)
+            }
+        }
+        if (!visit(node, 0)) return null
+        return abstract.filterKeys { it !in concrete }.values.toList()
+    }
+
+    /**
+     * A Java method parameter as `(slot type name, Kotlin source type)`: primitives and `String` by
+     * their Kotlin names, any other class by its name when it is nameable, an object type nullable.
+     */
+    private fun javaParameterTypeOf(descriptor: String, classpath: ArtifactClasspath): Pair<String, String>? {
+        val primitive = when (descriptor) {
+            "I" -> "kotlin.Int"; "J" -> "kotlin.Long"; "Z" -> "kotlin.Boolean"; "D" -> "kotlin.Double"
+            "F" -> "kotlin.Float"; "S" -> "kotlin.Short"; "B" -> "kotlin.Byte"; "C" -> "kotlin.Char"
+            else -> null
+        }
+        if (primitive != null) return primitive to primitive
+        if (!descriptor.startsWith("L") || !descriptor.endsWith(";")) return null
+        val binary = descriptor.substring(1, descriptor.length - 1)
+        val name = when (binary) {
+            "java/lang/String" -> "kotlin.String"
+            "java/lang/Object" -> "kotlin.Any"
+            else -> if (classpath.isNameablePublicClass(binary)) binary.replace('/', '.').replace('$', '.') else return null
+        }
+        return name to "$name?"
+    }
+
+    /**
+     * A `java.`/`javax.` class file, read from the JDK this build runs on -- the walk's classpath is the
+     * consumer's jars, which never contain the platform. Build time only, and only to recognise a
+     * functional interface ([functionalInterfaceSlotOrNull]); it does not make a JDK type nameable as a
+     * handle anywhere else.
+     */
+    private fun jdkClassNode(binaryName: String): ClassNode? {
+        if (!binaryName.startsWith("java/") && !binaryName.startsWith("javax/")) return null
+        val bytes = ClassLoader.getPlatformClassLoader().getResourceAsStream("$binaryName.class")?.use { it.readBytes() }
+            ?: return null
+        return readClassNodeOrNull(bytes)
+    }
+
     /** The Kotlin-source spelling of a function type: `kotlin.Function1<kotlin.Float, kotlin.Unit>`.
      * Written as the `FunctionN` classifier rather than as `(Float) -> Unit` because the two are the
      * same type and the first needs no bracket rules; assignability to an extension function type
@@ -2126,7 +2268,7 @@ internal object ArtifactScanner {
         // Read before `resolveKotlinType` is asked anything, because for a function-typed parameter
         // it is the one that would answer -- and would answer "no". See [functionSlotOrNull].
         val functionSlots = function.allParameterTypes.mapIndexed { index, type ->
-            functionSlotOrNull(type, paramDescriptors[index], classpath)
+            functionSlotOrNull(type, paramDescriptors[index], classpath) ?: functionalInterfaceSlotOrNull(type, classpath)
         }
         functionSlots.firstNotNullOfOrNull { it?.declineReason }?.let { return declined(it) }
 
@@ -2207,13 +2349,16 @@ internal object ArtifactScanner {
         // A member's defaults are not omittable yet (issue #215): no plan, so Python passes every
         // argument and the stub says so.
         val omittable = if (member != null) emptySet() else omittableParameterIndices(function, receiverIndex)
+        val modelParameters = model.parameters.mapIndexed { index, parameter ->
+            functionSlots[index + receiverIndex]?.modelType?.let { parameter.copy(type = it) } ?: parameter
+        }
         return Candidate(
             callable = callable,
             declaration = model.copy(
                 bindingName = qualifiedName,
                 returnBoundaryTag = returnType.tag,
                 receiverBoundaryTag = if (function.isExtension) resolvedParams.first().tag else model.receiverBoundaryTag,
-                parameters = model.parameters.mapIndexed { index, parameter ->
+                parameters = modelParameters.mapIndexed { index, parameter ->
                     parameter.copy(boundaryTag = resolvedParams[index + receiverIndex].tag)
                 },
             ),