one 2.0.0-beta.148.1 → 2.0.0-beta.158.1

package/android/src/main/java/dev/onejs/one/sharetarget/OneShareIntake.kt

@@ -0,0 +1,344 @@
+package dev.onejs.one.sharetarget
+
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.OpenableColumns
+import android.util.Patterns
+import java.io.File
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+
+// every field is required: a caller must make an explicit, bounded decision
+// for each limit rather than inherit an unbounded default. acceptedFileMimePrefixes
+// may still be null (any file type accepted), but that is now a choice the
+// caller wrote down, not a fallback.
+data class OneShareIntakeLimits(
+    val maxItems: Int,
+    val maxItemBytes: Long,
+    val maxTotalBytes: Long,
+    // null accepts any file mime type; entries may end in "/*" as a prefix match
+    val acceptedFileMimePrefixes: Set<String>?,
+    val acceptedText: Boolean,
+    val acceptedUrls: Boolean,
+)
+
+enum class OneShareIntakeIssueReason {
+    UNACCEPTED_TYPE,
+    OVER_ITEM_LIMIT,
+    OVER_SIZE_LIMIT,
+    READ_ERROR,
+}
+
+data class OneShareIntakeIssue(val label: String, val reason: OneShareIntakeIssueReason)
+
+data class OneShareIntakeResult(
+    // EXTRA_TEXT verbatim, meant for the editable composer field; never also
+    // duplicated into items.
+    val text: String,
+    val items: List<ShareItem>,
+    val truncated: Boolean,
+    val issues: List<OneShareIntakeIssue>,
+)
+
+// thrown for a failure that isn't a single rejected/oversized/unreadable
+// item (those become OneShareIntakeIssue entries and the loop continues).
+// callers must handle this rather than let it crash the host activity.
+class OneShareIntakeException(message: String, cause: Throwable? = null) : Exception(message, cause)
+
+// reads an incoming ACTION_SEND/ACTION_SEND_MULTIPLE intent into a bounded,
+// private-storage-owned result. never reads a whole stream into memory and
+// never decodes image bytes: every file is copied in fixed-size chunks
+// straight to disk so size limits hold regardless of what the sender claims.
+// text/url entries count against maxItems and their utf-8 byte length counts
+// against maxTotalBytes exactly like files do.
+internal object OneShareIntake {
+    private const val COPY_BUFFER_BYTES = 8192
+
+    // every resolver query, stream read and file write below is blocking
+    // disk/binder i/o; this always runs on Dispatchers.IO regardless of
+    // what dispatcher the caller is on, so a caller invoking this from a
+    // Main-dispatched coroutine (as the activity's LaunchedEffect does)
+    // never blocks the UI thread on it.
+    suspend fun intake(
+        context: Context,
+        intent: Intent,
+        destinationDir: File,
+        limits: OneShareIntakeLimits,
+    ): OneShareIntakeResult =
+        withContext(Dispatchers.IO) {
+            try {
+                intakeOrThrow(context, intent, destinationDir, limits)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                throw OneShareIntakeException("Failed to read shared content: ${e.message}", e)
+            }
+        }
+
+    // no-drop: a single rejected/oversized/unreadable entry anywhere in the
+    // intent (including EXTRA_TEXT itself) aborts the whole intake rather
+    // than silently continuing without it. any files already copied in this
+    // call are deleted before returning, so a caller never sees a partial
+    // item set it could accidentally send -- the caller is expected to
+    // surface the single issue and block sending, not offer a truncated
+    // result as success.
+    private suspend fun intakeOrThrow(
+        context: Context,
+        intent: Intent,
+        destinationDir: File,
+        limits: OneShareIntakeLimits,
+    ): OneShareIntakeResult {
+        val resolver = context.contentResolver
+        // exact CharSequence bytes, never trimmed: whitespace the sender put
+        // in EXTRA_TEXT is part of what the user agreed to share.
+        val rawPrimaryText = intent.getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString().orEmpty()
+
+        val seenTextValues = mutableSetOf<String>()
+        val items = mutableListOf<ShareItem>()
+        val copiedFiles = mutableListOf<File>()
+        var itemCount = 0
+        var totalBytes = 0L
+        var primaryText = ""
+
+        fun abort(issue: OneShareIntakeIssue): OneShareIntakeResult {
+            copiedFiles.forEach { it.delete() }
+            return OneShareIntakeResult(text = "", items = emptyList(), truncated = true, issues = listOf(issue))
+        }
+
+        if (rawPrimaryText.isNotEmpty()) {
+            val isUrl = isUrl(rawPrimaryText)
+            if (isUrl && !limits.acceptedUrls) {
+                return abort(OneShareIntakeIssue(rawPrimaryText, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+            }
+            if (!isUrl && !limits.acceptedText) {
+                return abort(OneShareIntakeIssue(rawPrimaryText, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+            }
+            val bytes = rawPrimaryText.toByteArray(Charsets.UTF_8).size.toLong()
+            if (bytes > limits.maxItemBytes || bytes > limits.maxTotalBytes) {
+                return abort(OneShareIntakeIssue(rawPrimaryText, OneShareIntakeIssueReason.OVER_SIZE_LIMIT))
+            }
+            if (limits.maxItems < 1) return abort(OneShareIntakeIssue(rawPrimaryText, OneShareIntakeIssueReason.OVER_ITEM_LIMIT))
+            itemCount += 1
+            primaryText = rawPrimaryText
+            totalBytes += bytes
+            seenTextValues.add(rawPrimaryText)
+        }
+
+        for (entry in collectEntries(intent)) {
+            currentCoroutineContext().ensureActive()
+
+            when (entry) {
+                is Entry.CharSequenceEntry -> {
+                    val value = entry.value
+                    if (!seenTextValues.add(value)) continue
+
+                    val isUrl = isUrl(value)
+                    if (isUrl && !limits.acceptedUrls) {
+                        return abort(OneShareIntakeIssue(value, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+                    }
+                    if (!isUrl && !limits.acceptedText) {
+                        return abort(OneShareIntakeIssue(value, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+                    }
+                    if (itemCount >= limits.maxItems) {
+                        return abort(OneShareIntakeIssue(value, OneShareIntakeIssueReason.OVER_ITEM_LIMIT))
+                    }
+                    val bytes = value.toByteArray(Charsets.UTF_8).size.toLong()
+                    if (bytes > limits.maxItemBytes || totalBytes + bytes > limits.maxTotalBytes) {
+                        return abort(OneShareIntakeIssue(value, OneShareIntakeIssueReason.OVER_SIZE_LIMIT))
+                    }
+
+                    items.add(if (isUrl) ShareItem.Url(value) else ShareItem.Text(value))
+                    itemCount += 1
+                    totalBytes += bytes
+                }
+
+                is Entry.UriEntry -> {
+                    val uri = entry.uri
+                    val label = uri.toString()
+                    // incoming senders must use a permission-granted provider uri.
+                    // a file uri would be opened under the receiver's own uid.
+                    if (uri.scheme != ContentResolver.SCHEME_CONTENT) {
+                        return abort(OneShareIntakeIssue(label, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+                    }
+                    val mimeType = resolver.getType(uri) ?: "application/octet-stream"
+
+                    if (!isAcceptedMime(mimeType, limits.acceptedFileMimePrefixes)) {
+                        return abort(OneShareIntakeIssue(label, OneShareIntakeIssueReason.UNACCEPTED_TYPE))
+                    }
+                    if (itemCount >= limits.maxItems) {
+                        return abort(OneShareIntakeIssue(label, OneShareIntakeIssueReason.OVER_ITEM_LIMIT))
+                    }
+                    val remainingTotal = limits.maxTotalBytes - totalBytes
+                    if (remainingTotal <= 0) {
+                        return abort(OneShareIntakeIssue(label, OneShareIntakeIssueReason.OVER_SIZE_LIMIT))
+                    }
+
+                    val (displayName, declaredSize) = queryMetadata(resolver, uri)
+                    val cap = minOf(limits.maxItemBytes, remainingTotal)
+                    if (declaredSize != null && declaredSize > cap) {
+                        return abort(OneShareIntakeIssue(displayName ?: label, OneShareIntakeIssueReason.OVER_SIZE_LIMIT))
+                    }
+
+                    val copied = boundedCopy(resolver, uri, destinationDir, displayName, cap)
+                    if (copied == null) {
+                        return abort(OneShareIntakeIssue(displayName ?: label, OneShareIntakeIssueReason.READ_ERROR))
+                    }
+                    if (copied.hitLimit) {
+                        copied.file.delete()
+                        return abort(OneShareIntakeIssue(displayName ?: label, OneShareIntakeIssueReason.OVER_SIZE_LIMIT))
+                    }
+
+                    copiedFiles.add(copied.file)
+                    items.add(
+                        ShareItem.File(
+                            uri = Uri.fromFile(copied.file),
+                            name = displayName ?: copied.file.name,
+                            mimeType = mimeType,
+                            size = copied.bytesCopied,
+                        )
+                    )
+                    itemCount += 1
+                    totalBytes += copied.bytesCopied
+                }
+            }
+        }
+
+        return OneShareIntakeResult(
+            text = primaryText,
+            items = items,
+            truncated = false,
+            issues = emptyList(),
+        )
+    }
+
+    private sealed class Entry {
+        data class UriEntry(val uri: Uri) : Entry()
+
+        data class CharSequenceEntry(val value: String) : Entry()
+    }
+
+    // EXTRA_STREAM (single/multiple) and every ClipData item: a ClipData
+    // item carries either a content uri (file) or inline text/url, and a
+    // uri already seen via EXTRA_STREAM or an earlier ClipData item is
+    // never copied twice.
+    private fun collectEntries(intent: Intent): List<Entry> {
+        val seenUris = linkedSetOf<Uri>()
+        val entries = mutableListOf<Entry>()
+
+        fun addUri(uri: Uri) {
+            if (seenUris.add(uri)) entries.add(Entry.UriEntry(uri))
+        }
+
+        when (intent.action) {
+            Intent.ACTION_SEND -> {
+                @Suppress("DEPRECATION")
+                intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM)?.let(::addUri)
+            }
+            Intent.ACTION_SEND_MULTIPLE -> {
+                @Suppress("DEPRECATION")
+                intent.getParcelableArrayListExtra<Uri>(Intent.EXTRA_STREAM)?.forEach(::addUri)
+            }
+        }
+
+        intent.clipData?.let { clipData ->
+            for (i in 0 until clipData.itemCount) {
+                val item = clipData.getItemAt(i)
+                val uri = item.uri
+                if (uri != null) {
+                    addUri(uri)
+                    continue
+                }
+                val text = item.text?.toString()
+                if (!text.isNullOrEmpty()) entries.add(Entry.CharSequenceEntry(text))
+            }
+        }
+
+        return entries
+    }
+
+    private fun isUrl(value: String): Boolean = Patterns.WEB_URL.matcher(value).matches()
+
+    private fun isAcceptedMime(mimeType: String, prefixes: Set<String>?): Boolean {
+        if (prefixes == null) return true
+        return prefixes.any { prefix ->
+            if (prefix.endsWith("/*")) mimeType.startsWith(prefix.removeSuffix("*"))
+            else mimeType == prefix
+        }
+    }
+
+    private fun queryMetadata(resolver: ContentResolver, uri: Uri): Pair<String?, Long?> =
+        try {
+            resolver
+                .query(uri, arrayOf(OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE), null, null, null)
+                ?.use { cursor ->
+                    if (!cursor.moveToFirst()) return@use null to null
+                    val nameIdx = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                    val sizeIdx = cursor.getColumnIndex(OpenableColumns.SIZE)
+                    val name = if (nameIdx >= 0) cursor.getString(nameIdx) else null
+                    val size = if (sizeIdx >= 0 && !cursor.isNull(sizeIdx)) cursor.getLong(sizeIdx) else null
+                    name to size
+                } ?: (null to null)
+        } catch (_: Exception) {
+            null to null
+        }
+
+    private data class CopyResult(val file: File, val bytesCopied: Long, val hitLimit: Boolean)
+
+    // streams uri -> destinationDir in COPY_BUFFER_BYTES chunks, checking
+    // cancellation and the byte cap every chunk; a cancelled coroutine or a
+    // cap overrun both leave the partial file for the caller to delete.
+    private suspend fun boundedCopy(
+        resolver: ContentResolver,
+        uri: Uri,
+        destinationDir: File,
+        displayName: String?,
+        capBytes: Long,
+    ): CopyResult? {
+        val input = try {
+            resolver.openInputStream(uri)
+        } catch (_: Exception) {
+            null
+        } ?: return null
+
+        destinationDir.mkdirs()
+        val file = File(destinationDir, uniqueFileName(displayName))
+        return try {
+            input.use { stream ->
+                file.outputStream().use { out ->
+                    val buffer = ByteArray(COPY_BUFFER_BYTES)
+                    var total = 0L
+                    while (true) {
+                        currentCoroutineContext().ensureActive()
+                        val read = stream.read(buffer)
+                        if (read < 0) break
+                        total += read
+                        if (total > capBytes) {
+                            return@use CopyResult(file, total, true)
+                        }
+                        out.write(buffer, 0, read)
+                    }
+                    CopyResult(file, total, false)
+                }
+            }
+        } catch (e: Exception) {
+            file.delete()
+            if (e is CancellationException) throw e
+            null
+        }
+    }
+
+    private fun uniqueFileName(displayName: String?): String {
+        val sanitized = displayName
+            ?.replace(Regex("[^A-Za-z0-9._-]"), "_")
+            ?.trim('.', '_')
+            ?.takeLast(120)
+            ?.takeIf { it.isNotEmpty() }
+            ?: "item"
+        return "${System.nanoTime()}-$sanitized"
+    }
+}

package/android/src/main/java/dev/onejs/one/sharetarget/OneShareModels.kt

@@ -0,0 +1,36 @@
+package dev.onejs.one.sharetarget
+
+import android.net.Uri
+
+// a place the user can send a share submission to (an account, a channel,
+// a conversation...); the generated adapter decides what these mean.
+data class ShareDestination(
+    val id: String,
+    val title: String,
+    val subtitle: String? = null,
+)
+
+sealed class ShareItem {
+    data class Text(val value: String) : ShareItem()
+
+    data class Url(val value: String) : ShareItem()
+
+    // uri points at a file this process owns (copied into private storage
+    // by OneShareIntake), never at the original content:// uri the sender
+    // granted only for the lifetime of the share intent.
+    data class File(
+        val uri: Uri,
+        val name: String,
+        val mimeType: String,
+        val size: Long,
+    ) : ShareItem()
+}
+
+// id is the stable draft id, stable across rotation/process recreation so
+// the adapter and any retry logic can recognize a resubmission.
+data class ShareSubmission(
+    val id: String,
+    val destinationId: String,
+    val text: String,
+    val items: List<ShareItem>,
+)

package/android/src/main/java/dev/onejs/one/sharetarget/OneShareSessionModel.kt

@@ -0,0 +1,207 @@
+package dev.onejs.one.sharetarget
+
+import android.content.Context
+import android.content.Intent
+import androidx.lifecycle.ViewModel
+import java.util.UUID
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+internal enum class SharePhase { LOADING, READY, FAILED, SENDING, CANCELLING, DELIVERED, CANCELLED }
+
+internal data class ShareSessionState(
+    val id: String = "",
+    val phase: SharePhase = SharePhase.LOADING,
+    val text: String = "",
+    val items: List<ShareItem> = emptyList(),
+    val destinations: List<ShareDestination> = emptyList(),
+    val destinationId: String? = null,
+    val error: String? = null,
+    val pendingDelivery: Boolean = false,
+)
+
+// the activity only renders this retained owner. rotation never creates a
+// second sender or loses the phase of a submission already in flight.
+internal class OneShareSessionModel(
+    private val context: Context,
+    private val adapter: OneShareTargetAdapter,
+    private val limits: OneShareIntakeLimits,
+) : ViewModel() {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    private val store = OneShareDraftStore(context)
+    private val writes = Mutex()
+    private val mutableState = MutableStateFlow(ShareSessionState())
+    val state: StateFlow<ShareSessionState> = mutableState
+    private var loading: Job? = null
+    private val transitions = Mutex()
+    private var incoming: Intent? = null
+
+    fun open(intent: Intent, restoredId: String? = null) {
+        if (state.value.id.isNotEmpty()) return
+        start(intent, restoredId ?: UUID.randomUUID().toString())
+    }
+
+    fun receive(intent: Intent) {
+        scope.launch { transitions.withLock {
+            val previous = state.value
+            if (previous.phase == SharePhase.LOADING || previous.phase == SharePhase.FAILED) {
+                loading?.cancelAndJoin()
+                // persist a completed intake; remove only an incomplete one.
+                writes.withLock {
+                    withContext(Dispatchers.IO) {
+                        if (store.load(previous.id) == null) store.delete(previous.id)
+                    }
+                }
+            }
+            start(intent, UUID.randomUUID().toString())
+        } }
+    }
+
+    private fun start(intent: Intent, id: String) {
+        incoming = intent
+        mutableState.value = ShareSessionState(id = id)
+        load()
+    }
+
+    fun retry() {
+        if (state.value.phase != SharePhase.FAILED) return
+        mutableState.value = state.value.copy(phase = SharePhase.LOADING, error = null)
+        load()
+    }
+
+    private fun load() {
+        val id = state.value.id
+        val intent = incoming
+        loading = scope.launch {
+            try {
+                val restored = withContext(Dispatchers.IO) { store.load(id) }
+                if (restored != null) {
+                    mutableState.value = state.value.copy(text = restored.editedText, items = restored.items,
+                        destinationId = restored.destinationId, pendingDelivery = restored.pendingDelivery)
+                } else {
+                    val directory = withContext(Dispatchers.IO) {
+                        store.clearItems(id)
+                        store.itemsDirectory(id)
+                    }
+                    val result = OneShareIntake.intake(context, requireNotNull(intent), directory, limits)
+                    require(result.issues.isEmpty()) { result.issues.joinToString { "${it.label}: ${it.reason}" } }
+                    mutableState.value = state.value.copy(text = result.text, items = result.items)
+                    persist(state.value)
+                }
+                val destinations = adapter.destinations()
+                val current = state.value
+                if (current.id != id) return@launch
+                require(!current.pendingDelivery || destinations.any { it.id == current.destinationId }) {
+                    "The original destination is unavailable. Retry when it reconnects."
+                }
+                mutableState.value = current.copy(phase = SharePhase.READY, destinations = destinations,
+                    destinationId = current.destinationId?.takeIf { selected -> destinations.any { it.id == selected } }
+                        ?: destinations.firstOrNull()?.id, error = if (current.pendingDelivery) "Earlier delivery may have been accepted. Retry sends the same submission." else null)
+                persist(state.value)
+            } catch (error: CancellationException) {
+                throw error
+            } catch (error: Exception) {
+                if (state.value.id == id) mutableState.value = state.value.copy(phase = SharePhase.FAILED, error = error.message)
+            }
+        }
+    }
+
+    fun edit(text: String) {
+        if (state.value.phase != SharePhase.READY || state.value.pendingDelivery) return
+        mutableState.value = state.value.copy(text = text)
+        saveEdit()
+    }
+
+    fun select(id: String) {
+        if (state.value.phase != SharePhase.READY || state.value.pendingDelivery || state.value.destinations.none { it.id == id }) return
+        mutableState.value = state.value.copy(destinationId = id)
+        saveEdit()
+    }
+
+    private fun saveEdit() {
+        val snapshot = state.value
+        scope.launch {
+            try { persist(snapshot) }
+            catch (error: Exception) {
+                if (state.value.id == snapshot.id && state.value.phase == SharePhase.READY)
+                    mutableState.value = state.value.copy(phase = SharePhase.FAILED, error = error.message)
+            }
+        }
+    }
+
+    private suspend fun persist(snapshot: ShareSessionState, sending: Boolean = false) = writes.withLock {
+        // a queued edit cannot write after the send or cancellation barrier.
+        val current = state.value
+        if (!sending && (current.id != snapshot.id || current.phase == SharePhase.SENDING ||
+                current.phase == SharePhase.CANCELLING || current.phase == SharePhase.DELIVERED || current.phase == SharePhase.CANCELLED)) return@withLock
+        withContext(Dispatchers.IO) {
+            store.save(StoredShareDraft(snapshot.id, snapshot.destinationId, snapshot.text, snapshot.items, sending))
+        }
+    }
+
+    fun canSend(snapshot: ShareSessionState = state.value): Boolean {
+        val bytes = snapshot.text.toByteArray(Charsets.UTF_8).size.toLong()
+        val itemBytes = snapshot.items.sumOf { when (it) {
+            is ShareItem.File -> it.size
+            is ShareItem.Text -> it.value.toByteArray(Charsets.UTF_8).size.toLong()
+            is ShareItem.Url -> it.value.toByteArray(Charsets.UTF_8).size.toLong()
+        } }
+        return snapshot.phase == SharePhase.READY && snapshot.destinationId != null &&
+            snapshot.destinations.any { it.id == snapshot.destinationId } &&
+            bytes <= limits.maxItemBytes && bytes + itemBytes <= limits.maxTotalBytes &&
+            snapshot.items.size + (if (snapshot.text.isEmpty()) 0 else 1) <= limits.maxItems &&
+            (snapshot.text.isNotEmpty() || snapshot.items.isNotEmpty())
+    }
+
+    fun send() {
+        val snapshot = state.value
+        if (!canSend(snapshot)) return
+        mutableState.value = snapshot.copy(phase = SharePhase.SENDING, error = null)
+        scope.launch {
+            try {
+                // mark the attempt durably before transport; process recovery
+                // keeps this id so a retry uses the adapter's idempotency key.
+                persist(snapshot, sending = true)
+                if (state.value.id == snapshot.id) mutableState.value = state.value.copy(pendingDelivery = true)
+                adapter.send(ShareSubmission(snapshot.id, requireNotNull(snapshot.destinationId), snapshot.text, snapshot.items))
+                writes.withLock { withContext(Dispatchers.IO) { store.delete(snapshot.id) } }
+                if (state.value.id == snapshot.id) mutableState.value = state.value.copy(phase = SharePhase.DELIVERED)
+            } catch (error: CancellationException) {
+                throw error
+            } catch (error: Exception) {
+                if (state.value.id == snapshot.id) mutableState.value = state.value.copy(phase = SharePhase.READY, error = error.message)
+            }
+        }
+    }
+
+    fun discard() {
+        val snapshot = state.value
+        if (snapshot.pendingDelivery || snapshot.phase == SharePhase.SENDING || snapshot.phase == SharePhase.CANCELLING ||
+            snapshot.phase == SharePhase.DELIVERED || snapshot.phase == SharePhase.CANCELLED) return
+        mutableState.value = snapshot.copy(phase = SharePhase.CANCELLING)
+        scope.launch {
+            try {
+                loading?.cancelAndJoin()
+                writes.withLock { withContext(Dispatchers.IO) { store.delete(snapshot.id) } }
+                if (state.value.id == snapshot.id) mutableState.value = state.value.copy(phase = SharePhase.CANCELLED)
+            } catch (error: CancellationException) {
+                throw error
+            } catch (error: Exception) {
+                if (state.value.id == snapshot.id) mutableState.value = state.value.copy(phase = SharePhase.FAILED, error = error.message)
+            }
+        }
+    }
+
+    override fun onCleared() { scope.cancel() }
+}