Optimize debug log sheet: batch updates and remove scroll animation

AppLog: replace per-append ArrayList copy with dirty flag + periodic
flush (100ms timer in DebugLogSheet). Batches rapid log calls into a
single copy + recomposition instead of one per log line.

DebugLogSheet: animateScrollToItem → scrollToItem to prevent jank
when logs flow rapidly.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: slipNET

app/src/main/java/app/slipnet/presentation/home/DebugLogSheet.kt

@@ -29,6 +29,7 @@ import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import kotlinx.coroutines.delay
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -52,14 +53,22 @@ fun DebugLogSheet(onDismiss: () -> Unit) {
         onDispose { AppLog.removeObserver() }
     }
 
+    // Flush dirty buffer → StateFlow every 100ms (batches rapid log calls)
+    LaunchedEffect(Unit) {
+        while (true) {
+            delay(100)
+            AppLog.flushIfDirty()
+        }
+    }
+
     val lines by AppLog.lines.collectAsState()
     val listState = rememberLazyListState()
     val clipboardManager = LocalClipboardManager.current
 
     // Auto-scroll to bottom when new lines arrive
     LaunchedEffect(lines.size) {
         if (lines.isNotEmpty()) {
-            listState.animateScrollToItem(lines.size - 1)
+            listState.scrollToItem(lines.size - 1)
         }
     }
 

app/src/main/java/app/slipnet/util/AppLog.kt

@@ -6,6 +6,7 @@ import kotlinx.coroutines.flow.asStateFlow
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 
 data class LogEntry(val id: Long, val raw: String, val level: Char)
@@ -34,6 +35,11 @@ object AppLog {
     @Volatile var observerCount = 0
         private set
 
+    // Dirty flag: set by append(), cleared by flush().
+    // Avoids creating an ArrayList copy on every single log call — instead
+    // the UI polls via flushIfDirty() on each collection (every frame).
+    private val dirty = AtomicBoolean(false)
+
     private val dateFormat = object : ThreadLocal<SimpleDateFormat>() {
         override fun initialValue() = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US)
     }
@@ -50,7 +56,20 @@ object AppLog {
         synchronized(buffer) {
             buffer.addLast(entry)
             while (buffer.size > MAX_LINES) buffer.removeFirst()
-            if (observerCount > 0) {
+        }
+        if (observerCount > 0) {
+            dirty.set(true)
+        }
+    }
+
+    /**
+     * Copy the buffer to the StateFlow if anything changed since the last flush.
+     * Called by the debug sheet on a periodic timer (~100ms) so we batch many
+     * rapid log calls into a single ArrayList copy + recomposition.
+     */
+    fun flushIfDirty() {
+        if (dirty.compareAndSet(true, false)) {
+            synchronized(buffer) {
                 _lines.value = ArrayList(buffer)
             }
         }