craft-native 0.0.113 → 0.0.115

package/dist/android/src/index.js

@@ -415,6 +415,12 @@ async function init(options) {
   const mainActivityTemplate = readFileSync(join(TEMPLATES_DIR, config.renderer === "native" ? "MainActivityNative.kt.template" : "MainActivity.kt.template"), "utf-8");
   const mainActivity = mainActivityTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name);
   writeFileSync(join(output, "app/src/main/java", packagePath, "MainActivity.kt"), mainActivity);
+  if (config.renderer === "native") {
+    const mutationTemplate = readFileSync(join(TEMPLATES_DIR, "CraftNativeMutation.kt.template"), "utf-8");
+    const flatListTemplate = readFileSync(join(TEMPLATES_DIR, "CraftNativeFlatList.kt.template"), "utf-8");
+    writeFileSync(join(output, "app/src/main/java", packagePath, "CraftNativeMutation.kt"), mutationTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
+    writeFileSync(join(output, "app/src/main/java", packagePath, "CraftNativeFlatList.kt"), flatListTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
+  }
   const craftBridgeTemplate = readFileSync(join(TEMPLATES_DIR, "CraftBridge.kt.template"), "utf-8");
   const craftBridge = craftBridgeTemplate.replace(/\{\{PROMISE_RUNTIME\}\}/g, () => renderAndroidPromiseRuntime("            ")).replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{ENABLE_SPEECH\}\}/g, String(Boolean(config.enableSpeechRecognition))).replace(/\{\{ENABLE_HAPTICS\}\}/g, String(Boolean(config.enableHaptics))).replace(/\{\{ENABLE_SHARE\}\}/g, String(Boolean(config.enableShare))).replace(/\{\{ENABLE_CAMERA\}\}/g, String(Boolean(config.enableCamera))).replace(/\{\{ENABLE_BIOMETRIC\}\}/g, String(Boolean(config.enableBiometric))).replace(/\{\{ENABLE_PUSH\}\}/g, String(Boolean(config.enablePushNotifications))).replace(/\{\{ENABLE_SECURE_STORAGE\}\}/g, String(Boolean(config.enableSecureStorage))).replace(/\{\{ENABLE_GEOLOCATION\}\}/g, String(Boolean(config.enableGeolocation))).replace(/\{\{ENABLE_BACKGROUND_LOCATION\}\}/g, String(Boolean(config.enableBackgroundLocation))).replace(/\{\{ENABLE_KEEP_AWAKE\}\}/g, String(Boolean(config.enableKeepAwake))).replace(/\{\{ENABLE_DEEP_LINKS\}\}/g, String(Boolean(config.enableDeepLinks))).replace(/\{\{ENABLE_HEALTH_CONNECT\}\}/g, String(Boolean(config.enableHealthConnect))).replace(/\{\{FIREBASE_IMPORT\}\}/g, config.enablePushNotifications ? "import com.google.firebase.messaging.FirebaseMessaging" : "").replace(/\{\{REGISTER_PUSH_IMPLEMENTATION\}\}/g, config.enablePushNotifications ? `activity.runOnUiThread {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU

package/dist/android/templates/CraftNativeFlatList.kt.template

@@ -0,0 +1,181 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import org.json.JSONObject
+import kotlin.math.ceil
+
+internal typealias CraftNativeRenderItem = (node: JSONObject, identity: String, previous: View?) -> View
+
+/** A stable-key RecyclerView host for stx-native FlatList nodes. */
+internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
+    private data class Item(
+        val identity: String,
+        val node: JSONObject,
+        val signature: String,
+        val chrome: Boolean,
+    )
+
+    private class Holder(val host: FrameLayout) : ViewHolder(host) {
+        var identity: String? = null
+        val hostedView: View? get() = host.getChildAt(0)
+    }
+
+    private val listAdapter = object : ListAdapter<Item, Holder>(object : DiffUtil.ItemCallback<Item>() {
+        override fun areItemsTheSame(oldItem: Item, newItem: Item) = oldItem.identity == newItem.identity
+        override fun areContentsTheSame(oldItem: Item, newItem: Item) = oldItem.signature == newItem.signature
+    }) {
+        init { setHasStableIds(true) }
+
+        override fun getItemId(position: Int): Long = stableId(getItem(position).identity)
+
+        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = Holder(FrameLayout(parent.context).apply {
+            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)
+        })
+
+        override fun onBindViewHolder(holder: Holder, position: Int) {
+            val item = getItem(position)
+            if (holder.identity != null && holder.identity != item.identity) release(holder)
+            val view = renderItem?.invoke(item.node, item.identity, holder.hostedView) ?: View(holder.host.context)
+            holder.identity = item.identity
+            if (holder.hostedView !== view) {
+                (view.parent as? ViewGroup)?.removeView(view)
+                holder.host.removeAllViews()
+                holder.host.addView(view, FrameLayout.LayoutParams(
+                    LayoutParams.MATCH_PARENT,
+                    LayoutParams.WRAP_CONTENT,
+                ))
+            }
+        }
+
+        override fun onViewRecycled(holder: Holder) {
+            release(holder)
+            super.onViewRecycled(holder)
+        }
+
+        private fun release(holder: Holder) {
+            holder.identity?.let { recycleItem?.invoke(it) }
+            holder.host.removeAllViews()
+            holder.identity = null
+        }
+    }
+
+    private var renderItem: CraftNativeRenderItem? = null
+    private var recycleItem: ((String) -> Unit)? = null
+    private var endReached: (() -> Unit)? = null
+    private var threshold = 0.1
+    private var endReachedSignature: String? = null
+    private var horizontal = false
+    private var columns = 1
+
+    init {
+        adapter = listAdapter
+        itemAnimator = null
+        addOnScrollListener(object : OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) = evaluateEndReached()
+        })
+    }
+
+    fun apply(
+        nodes: List<JSONObject>,
+        horizontal: Boolean,
+        columns: Int,
+        inverted: Boolean,
+        endReachedThreshold: Double,
+        renderItem: CraftNativeRenderItem,
+        recycleItem: (String) -> Unit,
+        endReached: (() -> Unit)?,
+    ) {
+        this.renderItem = renderItem
+        this.recycleItem = recycleItem
+        this.endReached = endReached
+        threshold = endReachedThreshold.coerceAtLeast(0.0)
+
+        val nextColumns = columns.coerceAtLeast(1)
+        val layoutChanged = this.horizontal != horizontal || this.columns != nextColumns
+        val retainedState = if (layoutChanged) null else layoutManager?.onSaveInstanceState()
+        this.horizontal = horizontal
+        this.columns = nextColumns
+        if (layoutChanged || layoutManager == null) configureLayoutManager()
+
+        val seen = mutableMapOf<String, Int>()
+        val next = nodes.mapIndexed { index, node ->
+            val base = identity(node) ?: "index:$index"
+            val occurrence = seen.getOrDefault(base, 0)
+            seen[base] = occurrence + 1
+            val unique = if (occurrence == 0) base else "$base#$occurrence"
+            val role = node.optJSONObject("props")?.optString("listRole").orEmpty()
+            Item(unique, node, node.toString(), role.isNotBlank() && role != "item")
+        }.let { if (inverted) it.reversed() else it }
+
+        val oldIds = listAdapter.currentList.mapTo(mutableSetOf()) { it.identity }
+        val nextIds = next.mapTo(mutableSetOf()) { it.identity }
+        (oldIds - nextIds).forEach(recycleItem)
+        val dataItems = next.filterNot { it.chrome }
+        val contentSignature = "${dataItems.size}:${dataItems.lastOrNull()?.identity.orEmpty()}"
+        if (contentSignature != endReachedSignature) endReachedSignature = null
+        listAdapter.submitList(next) {
+            retainedState?.let { layoutManager?.onRestoreInstanceState(it) }
+            evaluateEndReached()
+        }
+    }
+
+    fun discardAll() {
+        listAdapter.currentList.forEach { recycleItem?.invoke(it.identity) }
+        listAdapter.submitList(emptyList())
+        renderItem = null
+        recycleItem = null
+        endReached = null
+    }
+
+    private fun configureLayoutManager() {
+        layoutManager = when {
+            horizontal -> LinearLayoutManager(context, HORIZONTAL, false)
+            columns > 1 -> GridLayoutManager(context, columns).also { grid ->
+                grid.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
+                    override fun getSpanSize(position: Int): Int =
+                        if (listAdapter.currentList.getOrNull(position)?.chrome == true) columns else 1
+                }
+            }
+            else -> LinearLayoutManager(context)
+        }
+    }
+
+    private fun evaluateEndReached() {
+        val manager = layoutManager as? LinearLayoutManager ?: return
+        val lastVisible = manager.findLastVisibleItemPosition()
+        val dataPositions = listAdapter.currentList.indices.filter { !listAdapter.currentList[it].chrome }
+        val lastDataOrdinal = dataPositions.indexOfLast { it <= lastVisible }
+        if (dataPositions.isEmpty() || lastDataOrdinal < 0 || endReached == null) return
+        val remaining = dataPositions.size - lastDataOrdinal - 1
+        val thresholdItems = maxOf(1, ceil(dataPositions.size * threshold).toInt())
+        if (remaining > thresholdItems) return
+        val lastIdentity = listAdapter.currentList[dataPositions.last()].identity
+        val signature = "${dataPositions.size}:$lastIdentity"
+        if (endReachedSignature == signature) return
+        endReachedSignature = signature
+        endReached?.invoke()
+    }
+
+    private fun identity(node: JSONObject): String? {
+        val props = node.optJSONObject("props") ?: JSONObject()
+        return listOf(node.optString("id"), node.optString("key"), props.optString("key"), props.optString("testID"))
+            .firstOrNull { it.isNotBlank() }
+    }
+
+    private fun stableId(value: String): Long {
+        var hash = -0x340d631b7bdddcdbL
+        for (byte in value.encodeToByteArray()) {
+            hash = hash xor (byte.toLong() and 0xff)
+            hash *= 0x100000001b3L
+        }
+        return hash
+    }
+}

package/dist/android/templates/CraftNativeMutation.kt.template

@@ -0,0 +1,335 @@
+package {{PACKAGE_NAME}}
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+const val CRAFT_NATIVE_MUTATION_PROTOCOL_VERSION = 1
+
+data class CraftNativeMutationFailure(
+    val code: String,
+    override val message: String,
+    val operationIndex: Int? = null
+) : Exception(message)
+
+data class CraftNativeMutationResult(
+    val batchId: String,
+    val revision: Int,
+    val document: JSONObject?,
+    val updatedNodeIds: List<String>,
+    val affectedNodeIds: List<String>,
+    val requiresFullRender: Boolean
+)
+
+/** Validates a complete batch against a copy before committing any state. */
+class CraftNativeMutationDocument {
+    private data class Node(
+        val id: String,
+        var type: String,
+        var props: JSONObject,
+        var style: JSONObject,
+        var events: JSONObject,
+        var text: MutableList<String>,
+        var children: MutableList<String>,
+        var parent: String?
+    ) {
+        fun duplicate(): Node = copy(
+            props = JSONObject(props.toString()),
+            style = JSONObject(style.toString()),
+            events = JSONObject(events.toString()),
+            text = text.toMutableList(),
+            children = children.toMutableList()
+        )
+    }
+
+    private var nodes = linkedMapOf<String, Node>()
+    private var rootId: String? = null
+    var revision: Int = 0
+        private set
+
+    fun replace(document: JSONObject) {
+        val replacement = linkedMapOf<String, Node>()
+        val root = importNode(document, "root", null, replacement)
+        nodes = replacement
+        rootId = root
+        revision = 0
+    }
+
+    fun apply(payload: JSONObject): CraftNativeMutationResult {
+        val batchId = payload.optString("batchId")
+        if (batchId.isBlank()) fail("INVALID_BATCH", "batchId must be a non-empty string")
+        if (strictInteger(payload.opt("version")) != CRAFT_NATIVE_MUTATION_PROTOCOL_VERSION) {
+            fail(
+                "UNSUPPORTED_VERSION",
+                "mutation protocol version must be $CRAFT_NATIVE_MUTATION_PROTOCOL_VERSION"
+            )
+        }
+        if (strictInteger(payload.opt("baseRevision")) != revision) {
+            fail("REVISION_MISMATCH", "baseRevision must equal the current revision $revision")
+        }
+        val nextRevision = strictInteger(payload.opt("revision"))
+        if (nextRevision != revision + 1) {
+            fail("INVALID_REVISION", "revision must advance exactly once from $revision")
+        }
+        val operations = payload.opt("operations") as? JSONArray
+        if (operations == null || operations.length() == 0) {
+            fail("INVALID_BATCH", "operations must be a non-empty array")
+        }
+
+        val candidateNodes = linkedMapOf<String, Node>().apply {
+            nodes.forEach { (id, node) -> put(id, node.duplicate()) }
+        }
+        var candidateRoot = rootId
+        val updatedNodeIds = mutableListOf<String>()
+        val affectedNodeIds = mutableListOf<String>()
+        var requiresFullRender = false
+        for (index in 0 until operations.length()) {
+            val operation = operations.opt(index) as? JSONObject
+                ?: failAt("INVALID_OPERATION", "operation must be an object with an op string", index)
+            val name = operation.opt("op") as? String
+            if (name.isNullOrBlank()) {
+                failAt("INVALID_OPERATION", "operation must be an object with an op string", index)
+            }
+            try {
+                when (name) {
+                    "createNode" -> {
+                        if (operation.opt("root") == true) requiresFullRender = true
+                        candidateRoot = createNode(operation, candidateNodes, candidateRoot)
+                    }
+                    "updateNode" -> {
+                        updateNode(operation, candidateNodes)
+                        operation.optString("id").let {
+                            if (it !in updatedNodeIds) updatedNodeIds.add(it)
+                            if (it !in affectedNodeIds) affectedNodeIds.add(it)
+                        }
+                    }
+                    "insertChild" -> {
+                        insertChild(operation, candidateNodes)
+                        operation.optString("parentId").takeIf { it !in affectedNodeIds }?.let { affectedNodeIds.add(it) }
+                    }
+                    "moveChild" -> {
+                        moveChild(operation, candidateNodes)
+                        operation.optString("parentId").takeIf { it !in affectedNodeIds }?.let { affectedNodeIds.add(it) }
+                    }
+                    "removeNode" -> {
+                        val parent = candidateNodes[operation.optString("id")]?.parent
+                        if (parent == null) requiresFullRender = true
+                        else if (parent !in affectedNodeIds) affectedNodeIds.add(parent)
+                        candidateRoot = removeNode(operation, candidateNodes, candidateRoot)
+                    }
+                    else -> fail("UNKNOWN_OPERATION", "unsupported operation $name")
+                }
+            }
+            catch (failure: CraftNativeMutationFailure) {
+                throw CraftNativeMutationFailure(failure.code, failure.message, index)
+            }
+        }
+        if (candidateRoot == null && candidateNodes.isNotEmpty()) {
+            fail("MISSING_ROOT", "a non-empty document must have one root node")
+        }
+        if (candidateRoot != null) {
+            val root = candidateNodes[candidateRoot]
+            if (root == null || root.parent != null) {
+                fail("INVALID_TREE", "root node must not have a parent")
+            }
+            if (descendants(candidateRoot, candidateNodes).size + 1 != candidateNodes.size) {
+                fail("INVALID_TREE", "all nodes must be reachable from the root")
+            }
+        }
+
+        nodes = candidateNodes
+        rootId = candidateRoot
+        revision = nextRevision!!
+        return CraftNativeMutationResult(
+            batchId,
+            revision,
+            candidateRoot?.let { materialize(it, candidateNodes) },
+            updatedNodeIds,
+            affectedNodeIds,
+            requiresFullRender
+        )
+    }
+
+    fun node(id: String): JSONObject? = materialize(id, nodes)
+
+    private fun createNode(
+        operation: JSONObject,
+        nodes: MutableMap<String, Node>,
+        root: String?
+    ): String? {
+        val id = requiredId(operation, "id", "createNode")
+        if (nodes.containsKey(id)) fail("DUPLICATE_NODE", "node $id already exists")
+        val value = operation.opt("node") as? JSONObject
+            ?: fail("INVALID_NODE", "createNode.node.type must be a non-empty string")
+        val type = value.opt("type") as? String
+        if (type.isNullOrBlank()) fail("INVALID_NODE", "createNode.node.type must be a non-empty string")
+        val makeRoot = operation.opt("root") == true
+        if (makeRoot && root != null) fail("ROOT_EXISTS", "the document already has a root node")
+        nodes[id] = Node(
+            id,
+            type,
+            dictionary(value.opt("props")),
+            dictionary(value.opt("style")),
+            dictionary(value.opt("events")),
+            textChildren(if (value.has("children")) value.opt("children") else value.opt("text")),
+            mutableListOf(),
+            null
+        )
+        return if (makeRoot) id else root
+    }
+
+    private fun updateNode(operation: JSONObject, nodes: MutableMap<String, Node>) {
+        val id = requiredId(operation, "id", "updateNode")
+        val node = nodes[id] ?: fail("UNKNOWN_NODE", "node $id does not exist")
+        val patch = operation.opt("patch") as? JSONObject
+            ?: fail("INVALID_PATCH", "updateNode.patch must be an object")
+        val allowed = setOf("props", "style", "events", "children", "text")
+        val unknown = patch.keys().asSequence().filter { it !in allowed }.sorted().firstOrNull()
+        if (unknown != null) fail("INVALID_PATCH", "unsupported patch field $unknown")
+        if (patch.has("props")) node.props = dictionary(patch.opt("props"))
+        if (patch.has("style")) node.style = dictionary(patch.opt("style"))
+        if (patch.has("events")) node.events = dictionary(patch.opt("events"))
+        if (patch.has("children") || patch.has("text")) {
+            node.text = textChildren(if (patch.has("children")) patch.opt("children") else patch.opt("text"))
+        }
+    }
+
+    private fun insertChild(operation: JSONObject, nodes: MutableMap<String, Node>) {
+        val parentId = requiredId(operation, "parentId", "insertChild")
+        val childId = requiredId(operation, "childId", "insertChild")
+        val parent = nodes[parentId] ?: fail("UNKNOWN_PARENT", "parent node $parentId does not exist")
+        val child = nodes[childId] ?: fail("UNKNOWN_NODE", "node $childId does not exist")
+        if (!acceptsChildren(parent.type)) fail("INVALID_PARENT", "node $parentId cannot contain child nodes")
+        if (child.parent != null) fail("NODE_ATTACHED", "node $childId already has a parent")
+        if (parentId == childId || parentId in descendants(childId, nodes)) {
+            fail("CYCLE", "inserting node $childId would create a cycle")
+        }
+        val index = insertionIndex(operation, parent.children.size)
+        parent.children.add(index, childId)
+        child.parent = parentId
+    }
+
+    private fun moveChild(operation: JSONObject, nodes: MutableMap<String, Node>) {
+        val parentId = requiredId(operation, "parentId", "moveChild")
+        val childId = requiredId(operation, "childId", "moveChild")
+        val parent = nodes[parentId] ?: fail("UNKNOWN_PARENT", "parent node $parentId does not exist")
+        val oldIndex = parent.children.indexOf(childId)
+        if (nodes[childId]?.parent != parentId || oldIndex < 0) {
+            fail("NOT_A_CHILD", "node $childId is not a child of $parentId")
+        }
+        parent.children.removeAt(oldIndex)
+        parent.children.add(insertionIndex(operation, parent.children.size), childId)
+    }
+
+    private fun removeNode(
+        operation: JSONObject,
+        nodes: MutableMap<String, Node>,
+        root: String?
+    ): String? {
+        val id = requiredId(operation, "id", "removeNode")
+        val node = nodes[id] ?: fail("UNKNOWN_NODE", "node $id does not exist")
+        node.parent?.let { nodes[it]?.children?.remove(id) }
+        (descendants(id, nodes) + id).forEach { nodes.remove(it) }
+        return if (root == id) null else root
+    }
+
+    private fun requiredId(operation: JSONObject, field: String, name: String): String {
+        val id = operation.opt(field) as? String
+        if (id.isNullOrBlank()) fail("INVALID_NODE", "$name.$field must be a non-empty string")
+        return id
+    }
+
+    private fun insertionIndex(operation: JSONObject, count: Int): Int {
+        val index = strictInteger(operation.opt("index"))
+        if (index == null || index < 0 || index > count) {
+            fail("INVALID_INDEX", "index must be between 0 and $count")
+        }
+        return index
+    }
+
+    private fun textChildren(value: Any?): MutableList<String> {
+        if (value == null || value == JSONObject.NULL) return mutableListOf()
+        if (value is String) return mutableListOf(value)
+        val values = value as? JSONArray
+            ?: fail("INVALID_NODE", "node children may contain text only; use insertChild for node relationships")
+        val result = mutableListOf<String>()
+        for (index in 0 until values.length()) {
+            val text = values.opt(index) as? String
+                ?: fail("INVALID_NODE", "node children may contain text only; use insertChild for node relationships")
+            result.add(text)
+        }
+        return result
+    }
+
+    private fun acceptsChildren(type: String): Boolean =
+        type == "View" || type == "SafeAreaView" || type == "ScrollView"
+
+    private fun descendants(id: String, nodes: Map<String, Node>): Set<String> {
+        val result = linkedSetOf<String>()
+        nodes[id]?.children?.forEach { child ->
+            result.add(child)
+            result.addAll(descendants(child, nodes))
+        }
+        return result
+    }
+
+    private fun materialize(id: String, nodes: Map<String, Node>): JSONObject? {
+        val node = nodes[id] ?: return null
+        val children = JSONArray()
+        node.text.forEach { children.put(it) }
+        node.children.forEach { child -> materialize(child, nodes)?.let { children.put(it) } }
+        return JSONObject()
+            .put("id", node.id)
+            .put("type", node.type)
+            .put("props", node.props)
+            .put("style", node.style)
+            .put("events", node.events)
+            .put("children", children)
+    }
+
+    private fun importNode(
+        value: JSONObject,
+        preferredId: String,
+        parent: String?,
+        nodes: MutableMap<String, Node>
+    ): String {
+        val props = dictionary(value.opt("props"))
+        val explicit = (value.opt("id") as? String)?.takeIf { it.isNotBlank() }
+        val key = listOf(value.opt("key"), props.opt("key"), props.opt("testID"))
+            .filterIsInstance<String>().firstOrNull { it.isNotBlank() }
+        var id = explicit ?: key?.let { "${parent ?: "root"}/key:$it" } ?: preferredId
+        if (nodes.containsKey(id)) id = "$preferredId#${nodes.size}"
+        val children = value.optJSONArray("children") ?: JSONArray()
+        val node = Node(
+            id,
+            value.optString("type", "View"),
+            props,
+            dictionary(value.opt("style")),
+            dictionary(value.opt("events")),
+            mutableListOf(),
+            mutableListOf(),
+            parent
+        )
+        nodes[id] = node
+        for (index in 0 until children.length()) {
+            when (val child = children.opt(index)) {
+                is String -> node.text.add(child)
+                is JSONObject -> node.children.add(importNode(child, "$id/index:$index", id, nodes))
+            }
+        }
+        return id
+    }
+
+    private fun dictionary(value: Any?): JSONObject =
+        if (value is JSONObject) JSONObject(value.toString()) else JSONObject()
+
+    private fun strictInteger(value: Any?): Int? {
+        if (value !is Number) return null
+        val integer = value.toInt()
+        return integer.takeIf { value.toDouble() == integer.toDouble() }
+    }
+
+    private fun fail(code: String, message: String): Nothing = throw CraftNativeMutationFailure(code, message)
+
+    private fun failAt(code: String, message: String, index: Int): Nothing =
+        throw CraftNativeMutationFailure(code, message, index)
+}