one 2.0.0-beta.150.1 → 2.0.0-beta.159.1

package/One.podspec

@@ -35,16 +35,16 @@ Pod::Spec.new do |s|
   s.source_files = 'ios/**/*.{h,m,swift,mm,cpp}', 'cpp/**/*.{h,cpp}'
   # c entries the app's bridging header imports without importing the one module.
   # nitrogen appends its own public headers after these.
-  s.public_header_files = 'ios/Nitro/OneUpdatesLauncherBridge.h', 'ios/Nitro/OneLaunchScreen.h', 'ios/Nitro/OneBackgroundTasksBridge.h'
+  s.public_header_files = 'ios/Nitro/OneUpdatesLauncherBridge.h', 'ios/Nitro/OneLaunchScreen.h', 'ios/Nitro/OneBackgroundTasksBridge.h', 'ios/Nitro/OneAppIntentsBridge.h'
 
   # nitro hybrid objects: nitrogen generates the specs and bridges from
   # src/specs/*.nitro.ts into nitrogen/generated (see README).
   load 'nitrogen/generated/ios/One+autolinking.rb'
   add_nitrogen_files(s)
   # objc++ units build without clang modules, so One-Swift.h skips its
-  # own @import lines (React, UserNotifications) and never sees the nitro
-  # bridge types its c++ section names; every unit gets them first.
-  s.prefix_header_contents = "#ifdef __OBJC__\n#import <React/RCTView.h>\n#import <UserNotifications/UserNotifications.h>\n#endif\n#ifdef __cplusplus\n#include \"One-Swift-Cxx-Bridge.hpp\"\n#endif"
+  # own @import lines (React, UserNotifications, Social) and never sees the
+  # nitro bridge types its c++ section names; every unit gets them first.
+  s.prefix_header_contents = "#ifdef __OBJC__\n#import <React/RCTView.h>\n#import <UserNotifications/UserNotifications.h>\n#import <Social/Social.h>\n#endif\n#ifdef __cplusplus\n#include \"One-Swift-Cxx-Bridge.hpp\"\n#endif"
 
   s.dependency 'RNWorklets'
 

package/android/CMakeLists.txt

@@ -13,13 +13,18 @@ find_package(ReactAndroid REQUIRED CONFIG)
 find_package(react-native-worklets REQUIRED CONFIG)
 
 # one library for the package's C++: the sync-state JSI host object (shared
-# with iOS; only the registry trampolines differ, Swift there, JNI here) and
+# with iOS; only the registry trampolines differ, Swift there, JNI here), the
+# One.Storage engine (shared; only its directory lookup is per platform), the
+# crypto random source, and
 # the nitrogen-generated Nitro hybrid objects. JNI_OnLoad in
 # OneNativeSyncJni.cpp registers both.
 add_library(
   One SHARED
   ${JNI_DIR}/OneNativeSyncJni.cpp
-  ${CPP_DIR}/OneNativeSyncHost.cpp)
+  ${JNI_DIR}/OneStorageDirectory.cpp
+  ${CPP_DIR}/OneNativeSyncHost.cpp
+  ${CPP_DIR}/HybridOneStorage.cpp
+  ${CPP_DIR}/HybridOneCrypto.cpp)
 
 target_include_directories(One PRIVATE ${CPP_DIR} ${JNI_DIR})
 

package/android/build.gradle

@@ -132,6 +132,8 @@ dependencies {
     implementation "androidx.browser:browser:1.9.0"
     implementation "com.google.android.material:material:1.13.0"
     implementation "androidx.activity:activity:1.9.3"
+    // setContent and BackHandler for the share-target compose activity.
+    implementation "androidx.activity:activity-compose:1.9.3"
     implementation "androidx.core:core:1.13.1"
     // folding features for reserved regions (Jetpack WindowManager).
     implementation "androidx.window:window:1.5.1"

package/android/src/main/cpp/OneStorageDirectory.cpp

@@ -0,0 +1,21 @@
+#include <fbjni/fbjni.h>
+
+#include "OneStorageDirectory.hpp"
+
+#include <stdexcept>
+
+namespace margelo::nitro::one {
+
+std::string storageDirectory() {
+  static const auto directoryClass =
+      facebook::jni::findClassStatic("com/margelo/nitro/one/OneStorageDirectory");
+  static const auto path =
+      directoryClass->getStaticMethod<facebook::jni::local_ref<facebook::jni::JString>()>("path");
+  auto directory = path(directoryClass);
+  if (!directory) {
+    throw std::runtime_error("E_STORAGE_UNAVAILABLE: Storage: React context is not ready");
+  }
+  return directory->toStdString();
+}
+
+} // namespace margelo::nitro::one

package/android/src/main/java/com/margelo/nitro/one/HybridOneAdaptive.kt

@@ -28,9 +28,10 @@ import com.margelo.nitro.core.Promise
 // window-layout changes. hinge status comes from the WindowInfoTracker
 // FoldingFeature (FLAT fullyOpen, HALF_OPENED partiallyOpen) with the angle
 // from the hinge-angle sensor in radians; a hinge sensor with no
-// FoldingFeature in the current window reads closed, and a device with no
-// hinge sensor reads null. the first listener starts the monitors and the
-// last removal stops them, including the sensor.
+// FoldingFeature in the current window reads closed only on an official
+// 0-degree sensor reading and unknown otherwise, preserving the sensor
+// angle; a device with no hinge sensor reads null. the first listener starts
+// the monitors and the last removal stops them, including the sensor.
 class HybridOneAdaptive : HybridOneAdaptiveSpec() {
     private val sizeClassListeners = mutableMapOf<Int, (SizeClass) -> Unit>()
     private val hingeListeners = mutableMapOf<Int, (HingeState?) -> Unit>()
@@ -118,8 +119,8 @@ class HybridOneAdaptive : HybridOneAdaptiveSpec() {
 
     private fun computeHinge(): HingeState? {
         if (!hasHingeSensor()) return null
-        val angleRad =
-            synchronized(this) { lastAngleDeg }?.let { (it * Math.PI / 180.0) }
+        val angleDeg = synchronized(this) { lastAngleDeg }
+        val angleRad = angleDeg?.let { (it * Math.PI / 180.0) }
         val features = currentFoldingFeatures()
         val feature = features.firstOrNull()
         return when (feature?.state) {
@@ -127,7 +128,13 @@ class HybridOneAdaptive : HybridOneAdaptiveSpec() {
                 HingeState(HingeStatus.FULLYOPEN, angleRad ?: Math.PI)
             FoldingFeature.State.HALF_OPENED ->
                 HingeState(HingeStatus.PARTIALLYOPEN, angleRad ?: (Math.PI / 2.0))
-            else -> HingeState(HingeStatus.CLOSED, angleRad ?: 0.0)
+            else -> {
+                if (angleDeg == 0f) {
+                    HingeState(HingeStatus.CLOSED, 0.0)
+                } else {
+                    HingeState(HingeStatus.UNKNOWN, angleRad ?: 0.0)
+                }
+            }
         }
     }
 

package/android/src/main/java/com/margelo/nitro/one/OneStorageDirectory.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.one
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import java.io.File
+
+// hands One.Storage's c++ engine the app's private directory, which only the
+// android context knows. null until react has set the context.
+@DoNotStrip
+object OneStorageDirectory {
+    @JvmStatic
+    @DoNotStrip
+    fun path(): String? {
+        val context = NitroModules.applicationContext ?: return null
+        val directory = File(context.filesDir, "one")
+        directory.mkdirs()
+        return directory.absolutePath
+    }
+}

package/android/src/main/java/dev/onejs/one/OneKotlinHostEvents.kt

@@ -0,0 +1,39 @@
+package dev.onejs.one
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+internal class OneKotlinHostEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val name: String,
+    private val args: String,
+) : Event<OneKotlinHostEvent>(surfaceId, viewTag) {
+    override fun getEventName(): String = "topHostEvent"
+
+    override fun canCoalesce(): Boolean = false
+
+    override fun getEventData(): WritableMap =
+        Arguments.createMap().apply {
+            putString("name", name)
+            putString("args", args)
+        }
+}
+
+internal class OneKotlinHostSizeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val width: Double,
+    private val height: Double,
+) : Event<OneKotlinHostSizeEvent>(surfaceId, viewTag) {
+    override fun getEventName(): String = "topHostSizeChange"
+
+    override fun canCoalesce(): Boolean = false
+
+    override fun getEventData(): WritableMap =
+        Arguments.createMap().apply {
+            putDouble("width", width)
+            putDouble("height", height)
+        }
+}

package/android/src/main/java/dev/onejs/one/OneKotlinHostManager.kt

@@ -0,0 +1,79 @@
+package dev.onejs.one
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.OneKotlinHostManagerDelegate
+import com.facebook.react.viewmanagers.OneKotlinHostManagerInterface
+
+@ReactModule(name = OneKotlinHostManager.REACT_CLASS)
+class OneKotlinHostManager :
+    ViewGroupManager<OneKotlinHostView>(),
+    OneKotlinHostManagerInterface<OneKotlinHostView> {
+
+    private val delegate: ViewManagerDelegate<OneKotlinHostView> =
+        OneKotlinHostManagerDelegate(this)
+
+    init {
+        setupViewRecycling()
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): OneKotlinHostView =
+        OneKotlinHostView(reactContext)
+
+    override fun getDelegate(): ViewManagerDelegate<OneKotlinHostView> = delegate
+
+    override fun needsCustomLayoutForChildren(): Boolean = true
+
+    override fun onAfterUpdateTransaction(view: OneKotlinHostView) {
+        super.onAfterUpdateTransaction(view)
+        view.commitPendingProps()
+    }
+
+    override fun prepareToRecycleView(
+        reactContext: ThemedReactContext,
+        view: OneKotlinHostView,
+    ): OneKotlinHostView? {
+        val recyclable = super.prepareToRecycleView(reactContext, view) ?: return null
+        recyclable.resetForReuse()
+        return recyclable
+    }
+
+    override fun onDropViewInstance(view: OneKotlinHostView) {
+        view.resetForReuse()
+        super.onDropViewInstance(view)
+    }
+
+    override fun setSource(view: OneKotlinHostView, value: String?) {
+        view.stageSource(value)
+    }
+
+    override fun setView(view: OneKotlinHostView, value: String?) {
+        view.stageView(value)
+    }
+
+    override fun setContractHash(view: OneKotlinHostView, value: String?) {
+        view.stageContractHash(value)
+    }
+
+    override fun setProps(view: OneKotlinHostView, value: String?) {
+        view.stageProps(value)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
+        val events =
+            super.getExportedCustomDirectEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
+        events["topHostEvent"] =
+            mapOf("registrationName" to "onHostEvent")
+        events["topHostSizeChange"] =
+            mapOf("registrationName" to "onHostSizeChange")
+        return events
+    }
+
+    companion object {
+        const val REACT_CLASS = "OneKotlinHost"
+    }
+}

package/android/src/main/java/dev/onejs/one/OneKotlinHostView.kt

@@ -0,0 +1,211 @@
+package dev.onejs.one
+
+import android.content.Context
+import android.view.ViewGroup
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.views.view.ReactViewGroup
+
+class OneKotlinHostView(context: Context) : ReactViewGroup(context) {
+    private val composeView =
+        ComposeView(context).apply {
+            layoutParams =
+                ViewGroup.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                )
+            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnDetachedFromWindow)
+        }
+
+    private var stagedSource: String? = null
+    private var stagedView: String? = null
+    private var stagedContractHash: String? = null
+    private var stagedProps: String? = null
+
+    private var committedSource by mutableStateOf("")
+    private var committedView by mutableStateOf("")
+    private var committedContractHash by mutableStateOf("")
+    private var committedProps by mutableStateOf("{}")
+
+    private val contentLayout = Runnable { layoutComposeContent() }
+
+    private var reportedWidth = -1.0
+    private var reportedHeight = -1.0
+
+    init {
+        clipChildren = false
+        addView(composeView)
+        composeView.setContent {
+            val source = committedSource
+            val view = committedView
+            val hash = committedContractHash
+            val props = committedProps
+
+            if (source.isNotEmpty() && view.isNotEmpty()) {
+                val dispatch = OneNativeSourceViewRegistry.get(source)
+                if (dispatch.contractHash != hash) {
+                    error(
+                        "native view $source.$view changed (contract hash mismatch: expected $hash, got ${dispatch.contractHash}); rebuild the app"
+                    )
+                }
+                dispatch.Content(
+                    view = view,
+                    propsJson = props,
+                    emit = { eventName, eventArgs ->
+                        onHostEvent(source, view, eventName, eventArgs)
+                    },
+                )
+            }
+        }
+    }
+
+    internal fun stageSource(value: String?) {
+        stagedSource = value
+    }
+
+    internal fun stageView(value: String?) {
+        stagedView = value
+    }
+
+    internal fun stageContractHash(value: String?) {
+        stagedContractHash = value
+    }
+
+    internal fun stageProps(value: String?) {
+        stagedProps = value
+    }
+
+    internal fun commitPendingProps() {
+        val nextSource = stagedSource ?: ""
+        val nextView = stagedView ?: ""
+        val nextHash = stagedContractHash ?: ""
+        val nextProps = stagedProps ?: "{}"
+
+        val sourceOrViewChanged = nextSource != committedSource || nextView != committedView
+        if (sourceOrViewChanged) {
+            reportedWidth = -1.0
+            reportedHeight = -1.0
+        }
+
+        if (sourceOrViewChanged || nextHash != committedContractHash || nextProps != committedProps) {
+            committedSource = nextSource
+            committedView = nextView
+            committedContractHash = nextHash
+            committedProps = nextProps
+            requestLayout()
+        }
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        if (isAttachedToWindow) {
+            removeCallbacks(contentLayout)
+            post(contentLayout)
+        }
+    }
+
+    private fun onHostEvent(eventSource: String, eventView: String, name: String, args: String) {
+        // discard events from a detached or replaced source/view
+        if (!isAttachedToWindow || eventSource != committedSource || eventView != committedView) return
+        val reactContext = UIManagerHelper.getReactContext(this) ?: return
+        val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id) ?: return
+        dispatcher.dispatchEvent(
+            OneKotlinHostEvent(
+                surfaceId = UIManagerHelper.getSurfaceId(this),
+                viewTag = id,
+                name = name,
+                args = args,
+            )
+        )
+    }
+
+    private fun onContentSizeChanged(
+        sizeSource: String,
+        sizeView: String,
+        widthPx: Int,
+        heightPx: Int,
+    ) {
+        if (!isAttachedToWindow || sizeSource != committedSource || sizeView != committedView) return
+        val density = resources.displayMetrics.density.toDouble()
+        if (density <= 0.0) return
+        val widthDp = widthPx / density
+        val heightDp = heightPx / density
+        if (widthDp == reportedWidth && heightDp == reportedHeight) return
+        reportedWidth = widthDp
+        reportedHeight = heightDp
+        val reactContext = UIManagerHelper.getReactContext(this) ?: return
+        val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id) ?: return
+        dispatcher.dispatchEvent(
+            OneKotlinHostSizeEvent(
+                surfaceId = UIManagerHelper.getSurfaceId(this),
+                viewTag = id,
+                width = widthDp,
+                height = heightDp,
+            )
+        )
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        super.onLayout(changed, left, top, right, bottom)
+        layoutComposeContent()
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        post(contentLayout)
+    }
+
+    private fun layoutComposeContent() {
+        if (!composeView.isAttachedToWindow || committedSource.isEmpty() || committedView.isEmpty()) return
+        // measure content before letting yoga apply the outer constraints.
+        composeView.measure(
+            MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+            MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+        )
+        val naturalWidth = composeView.measuredWidth
+        var naturalHeight = composeView.measuredHeight
+        if (width > 0 && width != naturalWidth) {
+            composeView.measure(
+                MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+                MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+            )
+            naturalHeight = composeView.measuredHeight
+        }
+        onContentSizeChanged(
+            committedSource,
+            committedView,
+            naturalWidth,
+            naturalHeight,
+        )
+        composeView.measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+        )
+        composeView.layout(0, 0, width, height)
+    }
+
+    override fun onDetachedFromWindow() {
+        removeCallbacks(contentLayout)
+        super.onDetachedFromWindow()
+        composeView.disposeComposition()
+    }
+
+    internal fun resetForReuse() {
+        removeCallbacks(contentLayout)
+        reportedWidth = -1.0
+        reportedHeight = -1.0
+        committedSource = ""
+        committedView = ""
+        committedContractHash = ""
+        committedProps = "{}"
+        stagedSource = null
+        stagedView = null
+        stagedContractHash = null
+        stagedProps = null
+        composeView.disposeComposition()
+    }
+}

package/android/src/main/java/dev/onejs/one/OneNativeSourceViewDispatch.kt

@@ -0,0 +1,13 @@
+package dev.onejs.one
+
+import androidx.compose.runtime.Composable
+
+// generated per .kt source that declares public @Composable functions: renders
+// one of them from the host's json props. a callback reports its arguments
+// through emit as a json array.
+interface OneNativeSourceViewDispatch {
+    val contractHash: String
+
+    @Composable
+    fun Content(view: String, propsJson: String, emit: (String, String) -> Unit)
+}

package/android/src/main/java/dev/onejs/one/OneNativeSourceViewRegistry.kt

@@ -0,0 +1,21 @@
+package dev.onejs.one
+
+import java.util.concurrent.ConcurrentHashMap
+
+internal object OneNativeSourceViewRegistry {
+    private val instances = ConcurrentHashMap<String, OneNativeSourceViewDispatch>()
+
+    fun get(sourceId: String): OneNativeSourceViewDispatch {
+        return instances.computeIfAbsent(sourceId) { id ->
+            val name = "OneNativeSourceViews_$id"
+            try {
+                val type = Class.forName(name)
+                type.getDeclaredConstructor().newInstance() as OneNativeSourceViewDispatch
+            } catch (e: ClassNotFoundException) {
+                error("native view dispatch $name is not linked; rebuild the app")
+            } catch (e: Exception) {
+                error("failed to instantiate $name: ${e.message}")
+            }
+        }
+    }
+}

package/android/src/main/java/dev/onejs/one/OnePackage.kt

@@ -81,6 +81,7 @@ class OnePackage : BaseReactPackage() {
             OneNativeMaskManager(),
             OneNativeUiMapManager(),
             OneNativePictureInPictureManager(),
+            OneKotlinHostManager(),
         )
 
     companion object {

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

@@ -0,0 +1,122 @@
+package dev.onejs.one.sharetarget
+
+import android.content.Context
+import android.net.Uri
+import android.util.AtomicFile
+import java.io.IOException
+import java.io.File
+import java.util.UUID
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal data class StoredShareDraft(
+    val id: String,
+    val destinationId: String?,
+    val editedText: String,
+    val items: List<ShareItem>,
+    val pendingDelivery: Boolean = false,
+)
+
+// durable store for one in-flight share draft per id, under the app's
+// private files dir. a draft's attachment files live alongside its json so
+// deleting the draft directory on success/cancel reclaims both in one call.
+internal class OneShareDraftStore(private val context: Context) {
+    private fun rootDir(): File = File(context.filesDir, "one-sharetarget").apply { mkdirs() }
+
+    private fun draftDir(id: String): File = File(rootDir(), id)
+
+    private fun draftFile(id: String): File = File(draftDir(id), "draft.json")
+
+    fun newDraftId(): String = UUID.randomUUID().toString()
+
+    fun itemsDirectory(id: String): File = draftDir(id).apply { mkdirs() }
+
+    fun load(id: String): StoredShareDraft? {
+        val file = draftFile(id)
+        if (!file.exists() && !File(file.path + ".bak").exists()) return null
+        return try {
+            val json = JSONObject(AtomicFile(file).openRead().bufferedReader().use { it.readText() })
+            val items = mutableListOf<ShareItem>()
+            val itemsJson = json.optJSONArray("items") ?: JSONArray()
+            for (i in 0 until itemsJson.length()) {
+                val entry = itemsJson.getJSONObject(i)
+                when (entry.getString("type")) {
+                    "text" -> items.add(ShareItem.Text(entry.getString("value")))
+                    "url" -> items.add(ShareItem.Url(entry.getString("value")))
+                    "file" ->
+                        items.add(
+                            ShareItem.File(
+                                uri = Uri.parse(entry.getString("uri")),
+                                name = entry.getString("name"),
+                                mimeType = entry.getString("mimeType"),
+                                size = entry.getLong("size"),
+                            )
+                        )
+                    else -> continue
+                }
+            }
+            StoredShareDraft(
+                id = id,
+                destinationId = json.optString("destinationId", "").takeIf { it.isNotEmpty() },
+                editedText = json.optString("editedText", ""),
+                items = items,
+                pendingDelivery = json.optBoolean("pendingDelivery", false),
+            )
+        } catch (error: Exception) {
+            throw IOException("Could not read share draft $id", error)
+        }
+    }
+
+    fun save(draft: StoredShareDraft) {
+        val itemsJson = JSONArray()
+        for (item in draft.items) {
+            val entry = JSONObject()
+            when (item) {
+                is ShareItem.Text -> entry.put("type", "text").put("value", item.value)
+                is ShareItem.Url -> entry.put("type", "url").put("value", item.value)
+                is ShareItem.File ->
+                    entry
+                        .put("type", "file")
+                        .put("uri", item.uri.toString())
+                        .put("name", item.name)
+                        .put("mimeType", item.mimeType)
+                        .put("size", item.size)
+            }
+            itemsJson.put(entry)
+        }
+        val json =
+            JSONObject()
+                .put("destinationId", draft.destinationId ?: JSONObject.NULL)
+                .put("editedText", draft.editedText)
+                .put("items", itemsJson)
+                .put("pendingDelivery", draft.pendingDelivery)
+
+        val dir = draftDir(draft.id).apply { mkdirs() }
+        val file = File(dir, "draft.json")
+        val atomic = AtomicFile(file)
+        val output = atomic.startWrite()
+        try {
+            output.write(json.toString().toByteArray(Charsets.UTF_8))
+            atomic.finishWrite(output)
+        } catch (error: Exception) {
+            atomic.failWrite(output)
+            throw error
+        }
+    }
+
+    fun delete(id: String) {
+        val directory = draftDir(id)
+        if (directory.exists() && !directory.deleteRecursively()) throw IOException("Could not discard share draft $id")
+    }
+
+    // drops every file under a draft's dir except a pending draft.json, used
+    // to clear partial copies left by an intake that never finished (e.g. the
+    // process died mid-copy on rotation) before that intake is retried for
+    // the same draft id -- otherwise the retry's files pile up alongside the
+    // orphaned ones from the killed attempt.
+    fun clearItems(id: String) {
+        draftDir(id).listFiles()?.forEach { entry ->
+            if (entry.name != "draft.json" && entry.name != "draft.json.tmp") entry.deleteRecursively()
+        }
+    }
+}