akanjs 3.0.2 → 3.1.0-rc.0

package/ui/overlayPosition.ts

@@ -89,3 +89,93 @@ export const useOverlayPosition = ({
 
   return position;
 };
+
+export type OverlaySide = "top" | "right" | "bottom" | "left";
+
+export interface AnchoredPosition {
+  top: number;
+  left: number;
+  /** The side the panel landed on: the asked one, or its opposite when that has more room. */
+  side: OverlaySide;
+  /** The trigger's centre along the panel's edge, held clear of its corners, for the pointer. */
+  arrowOffset: number;
+}
+
+const oppositeSide = { top: "bottom", bottom: "top", left: "right", right: "left" } as const;
+
+/** Like {@link useOverlayPosition}, for a panel centred on any side of its trigger, as a tooltip is. */
+export const useAnchoredPosition = ({
+  opened,
+  triggerRef,
+  panelRef,
+  side,
+  gap = TRIGGER_GAP + 2,
+}: {
+  opened: boolean;
+  triggerRef: RefObject<HTMLElement | null>;
+  panelRef: RefObject<HTMLElement | null>;
+  side: OverlaySide;
+  gap?: number;
+}) => {
+  const [position, setPosition] = useState<AnchoredPosition | null>(null);
+
+  const measure = useCallback(() => {
+    const trigger = triggerRef.current?.getBoundingClientRect();
+    const panel = panelRef.current;
+    if (!trigger || !panel) return;
+    const { offsetHeight: height, offsetWidth: width } = panel;
+    const room = {
+      top: trigger.top - gap - VIEWPORT_MARGIN,
+      bottom: window.innerHeight - trigger.bottom - gap - VIEWPORT_MARGIN,
+      left: trigger.left - gap - VIEWPORT_MARGIN,
+      right: window.innerWidth - trigger.right - gap - VIEWPORT_MARGIN,
+    };
+    const vertical = side === "top" || side === "bottom";
+    const need = vertical ? height : width;
+    const landed = room[side] >= need || room[side] >= room[oppositeSide[side]] ? side : oppositeSide[side];
+    const centerX = (trigger.left + trigger.right) / 2;
+    const centerY = (trigger.top + trigger.bottom) / 2;
+    const next: AnchoredPosition = vertical
+      ? {
+          top: landed === "top" ? trigger.top - gap - height : trigger.bottom + gap,
+          left: clamp(centerX - width / 2, VIEWPORT_MARGIN, window.innerWidth - VIEWPORT_MARGIN - width),
+          side: landed,
+          arrowOffset: 0,
+        }
+      : {
+          top: clamp(centerY - height / 2, VIEWPORT_MARGIN, window.innerHeight - VIEWPORT_MARGIN - height),
+          left: landed === "left" ? trigger.left - gap - width : trigger.right + gap,
+          side: landed,
+          arrowOffset: 0,
+        };
+    next.arrowOffset = vertical
+      ? clamp(centerX - next.left, POINTER_INSET / 2, width - POINTER_INSET / 2)
+      : clamp(centerY - next.top, POINTER_INSET / 2, height - POINTER_INSET / 2);
+    setPosition((prev) =>
+      prev &&
+      prev.top === next.top &&
+      prev.left === next.left &&
+      prev.side === next.side &&
+      prev.arrowOffset === next.arrowOffset
+        ? prev
+        : next,
+    );
+  }, [gap, panelRef, side, triggerRef]);
+
+  useLayoutEffect(() => {
+    if (opened) measure();
+    else setPosition(null);
+  }, [opened, measure]);
+
+  useEffect(() => {
+    if (!opened) return;
+    window.addEventListener("scroll", measure, true);
+    window.addEventListener("resize", measure);
+    return () => {
+      window.removeEventListener("scroll", measure, true);
+      window.removeEventListener("resize", measure);
+    };
+  }, [opened, measure]);
+
+  return position;
+};

package/ui/recipe/inputRecipe.ts

@@ -12,7 +12,14 @@ export const inputRecipe = recipe(
         select:
           "appearance-none bg-[image:linear-gradient(to_top_right,transparent_50%,currentColor_50%,currentColor_calc(50%+2px),transparent_calc(50%+2px)),linear-gradient(to_bottom_right,transparent_calc(50%-2px),currentColor_calc(50%-2px),currentColor_50%,transparent_50%)] bg-[length:5px_6px] bg-[position:calc(100%-14px)_50%,calc(100%-9px)_50%] bg-no-repeat pr-7 pl-3",
       },
-      size: { xs: "text-xs", sm: "text-sm", md: "text-sm", lg: "text-base", xl: "text-lg" },
+      
+      size: {
+        xs: "text-xs pointer-coarse:text-base",
+        sm: "text-sm pointer-coarse:text-base",
+        md: "text-sm pointer-coarse:text-base",
+        lg: "text-base",
+        xl: "text-lg",
+      },
       tone: {
         default: "",
         primary: "border-primary",

package/ui/styles.css

@@ -274,6 +274,158 @@ body.akan-mobile-document {
   padding-inline: 2rem;
 }
 
+/* A frame whose insets change with width carries one var per breakpoint (`topInset: { base, md }`, SSR only);
+   these pick the one in force. The breakpoints are Tailwind's defaults, which `ResponsiveInset` keys on. */
+[data-akan-frame-responsive] {
+  --akan-top-inset: var(--akan-top-inset-base);
+  --akan-bottom-inset: var(--akan-bottom-inset-base);
+  --akan-top-inset-visibility: var(--akan-top-inset-visibility-base);
+  --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-base);
+}
+@media (width >= 40rem) {
+  [data-akan-frame-responsive] {
+    --akan-top-inset: var(--akan-top-inset-sm);
+    --akan-bottom-inset: var(--akan-bottom-inset-sm);
+    --akan-top-inset-visibility: var(--akan-top-inset-visibility-sm);
+    --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-sm);
+  }
+}
+@media (width >= 48rem) {
+  [data-akan-frame-responsive] {
+    --akan-top-inset: var(--akan-top-inset-md);
+    --akan-bottom-inset: var(--akan-bottom-inset-md);
+    --akan-top-inset-visibility: var(--akan-top-inset-visibility-md);
+    --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-md);
+  }
+}
+@media (width >= 64rem) {
+  [data-akan-frame-responsive] {
+    --akan-top-inset: var(--akan-top-inset-lg);
+    --akan-bottom-inset: var(--akan-bottom-inset-lg);
+    --akan-top-inset-visibility: var(--akan-top-inset-visibility-lg);
+    --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-lg);
+  }
+}
+@media (width >= 80rem) {
+  [data-akan-frame-responsive] {
+    --akan-top-inset: var(--akan-top-inset-xl);
+    --akan-bottom-inset: var(--akan-bottom-inset-xl);
+    --akan-top-inset-visibility: var(--akan-top-inset-visibility-xl);
+    --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-xl);
+  }
+}
+@media (width >= 96rem) {
+  [data-akan-frame-responsive] {
+    --akan-top-inset: var(--akan-top-inset-2xl);
+    --akan-bottom-inset: var(--akan-bottom-inset-2xl);
+    --akan-top-inset-visibility: var(--akan-top-inset-visibility-2xl);
+    --akan-bottom-inset-visibility: var(--akan-bottom-inset-visibility-2xl);
+  }
+}
+
+/* Route transitions on the web: an RSC navigation tags itself `akan-<transition>-<push|pop>` from the route's
+   `.config({ transition })`, and the page content's ViewTransition takes that class. The rest of the page holds. */
+:root:active-view-transition-type(akan-nav)::view-transition-old(root),
+:root:active-view-transition-type(akan-nav)::view-transition-new(root) {
+  animation: none;
+}
+::view-transition-old(.akan-stack-push) {
+  animation: 260ms cubic-bezier(0.32, 0.72, 0, 1) both akan-vt-out-left;
+}
+::view-transition-new(.akan-stack-push) {
+  animation: 260ms cubic-bezier(0.32, 0.72, 0, 1) both akan-vt-in-right;
+}
+::view-transition-old(.akan-stack-pop) {
+  animation: 260ms cubic-bezier(0.32, 0.72, 0, 1) both akan-vt-out-right;
+}
+::view-transition-new(.akan-stack-pop) {
+  animation: 260ms cubic-bezier(0.32, 0.72, 0, 1) both akan-vt-in-left;
+}
+::view-transition-old(.akan-bottomUp-push),
+::view-transition-new(.akan-bottomUp-pop) {
+  animation: none;
+}
+::view-transition-new(.akan-bottomUp-push) {
+  animation: 280ms cubic-bezier(0.32, 0.72, 0, 1) both akan-vt-in-up;
+}
+::view-transition-old(.akan-bottomUp-pop) {
+  animation: 240ms ease-in both akan-vt-out-down;
+}
+::view-transition-old(.akan-fade-push),
+::view-transition-old(.akan-fade-pop) {
+  animation: 180ms ease-in both akan-vt-fade-out;
+}
+::view-transition-new(.akan-fade-push),
+::view-transition-new(.akan-fade-pop) {
+  animation: 180ms ease-out both akan-vt-fade-in;
+}
+::view-transition-old(.akan-scaleOut-push) {
+  animation: 220ms ease-in both akan-vt-shrink-out;
+}
+::view-transition-new(.akan-scaleOut-push) {
+  animation: 220ms ease-out both akan-vt-fade-in;
+}
+::view-transition-old(.akan-scaleOut-pop) {
+  animation: 200ms ease-in both akan-vt-fade-out;
+}
+::view-transition-new(.akan-scaleOut-pop) {
+  animation: 220ms ease-out both akan-vt-grow-in;
+}
+@keyframes akan-vt-in-right {
+  from {
+    transform: translateX(100%);
+  }
+}
+@keyframes akan-vt-out-left {
+  to {
+    transform: translateX(-30%);
+    opacity: 0.6;
+  }
+}
+@keyframes akan-vt-in-left {
+  from {
+    transform: translateX(-30%);
+    opacity: 0.6;
+  }
+}
+@keyframes akan-vt-out-right {
+  to {
+    transform: translateX(100%);
+  }
+}
+@keyframes akan-vt-in-up {
+  from {
+    transform: translateY(100%);
+  }
+}
+@keyframes akan-vt-out-down {
+  to {
+    transform: translateY(100%);
+  }
+}
+@keyframes akan-vt-fade-in {
+  from {
+    opacity: 0;
+  }
+}
+@keyframes akan-vt-fade-out {
+  to {
+    opacity: 0;
+  }
+}
+@keyframes akan-vt-shrink-out {
+  to {
+    transform: scale(0.94);
+    opacity: 0;
+  }
+}
+@keyframes akan-vt-grow-in {
+  from {
+    transform: scale(0.94);
+    opacity: 0;
+  }
+}
+
 /* Always-included keyframes (non-theme animations) */
 @keyframes smaller {
   0% {

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeActivity.kt

@@ -221,6 +221,11 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
         if (debuggable && intent.hasExtra(EXTRA_ENV)) webView.reload()
     }
 
+    override fun onResume() {
+        super.onResume()
+        if (AkanNativeFeatures.UPDATES && !unsupportedWebView) AkanNativeUpdateReports.flush()
+    }
+
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
         if (unsupportedWebView) return
@@ -373,10 +378,14 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
             }
         }
 
+        //? Armed when the page starts, not when it finishes: a bundle stuck in a script never finishes loading.
+        override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {
+            startReadyTimer()
+        }
+
         override fun onPageFinished(view: WebView, url: String) {
             root.requestApplyInsets() // push insets into the new document
             if (splashConfig.optBoolean("autoHide", true)) hideSplash(SPLASH_FADE_MS)
-            startReadyTimer()
         }
 
         override fun doUpdateVisitedHistory(view: WebView, url: String, isReload: Boolean) {
@@ -841,7 +850,16 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
     // ---------------------------------------------------------------- web bundle updates (UP-2)
 
     private val readyTimeout = Runnable {
-        if (AkanNativeFeatures.UPDATES && AkanNativeUpdates.onTrial) serveBundle(AkanNativeUpdates.rollback())
+        if (!AkanNativeFeatures.UPDATES || !AkanNativeUpdates.onTrial) return@Runnable
+        val (root, trial) = AkanNativeUpdates.rollback()
+        // A renderer stuck in a script never runs the next navigation: one that does not answer is ended, and
+        // onRenderProcessGone makes the activity again, on the bundle the rollback made active.
+        var answered = false
+        webView.evaluateJavascript("0") { answered = true }
+        webView.postDelayed({
+            trial?.let { AkanNativeUpdateReports.record("rolledBack", it, if (answered) "timeout" else "hang") }
+            if (answered || webView.webViewRenderProcess?.terminate() != true) serveBundle(root)
+        }, RENDERER_PROBE_MS)
     }
 
     /** A bundle on trial must call notifyReady() within updates.readyTimeout of loading. */
@@ -977,6 +995,8 @@ class AkanNativeActivity : Activity(), AkanNativePluginContext.Host {
         const val EXTRA_ENV = "akanNativeEnv"
         private const val STATE_PENDING = "akan-native.pendingResults"
         private const val SPLASH_FADE_MS = 200L
+        /** How long a page on trial has to answer before its renderer counts as stuck. */
+        private const val RENDERER_PROBE_MS = 2_000L
         // Must match @akanjs/native/core protocol.ts INIT_PREFIX / INIT_SUFFIX.
         private const val INIT_PREFIX = "window.__AKAN_NATIVE__=(function(o,b,e){for(var k in b)o[k]=b[k];o.env=e;return o})(window.__AKAN_NATIVE__||{},"
         private const val INIT_SUFFIX = ");\n"

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeKernel.kt

@@ -3,6 +3,7 @@ package com.akanjs.runtime
 import java.nio.ByteBuffer
 import java.nio.charset.CharacterCodingException
 import java.nio.charset.CodingErrorAction
+import java.security.MessageDigest
 
 /*
  * Decisions every akan-native host makes the same way (docs/architecture.md §5): a port of
@@ -21,6 +22,13 @@ sealed class AkanNativeRoute {
     object NotFound : AkanNativeRoute()
 }
 
+/** kernel.ts UpdateDecision: what a verified web bundle manifest means to this binary (updates protocol v2). */
+data class AkanNativeUpdateDecision(val kind: Kind, val baseline: Double = 0.0, val revoke: List<String> = emptyList()) {
+    enum class Kind(val wire: String) { UNTRUSTED("untrusted"), REVOKED("revoked"), SELF_REVOKE("self-revoke"), REVOKE_LATER("revoke-later"), TAKE("take"), STALE("stale") }
+
+    val wire: String get() = if (kind == Kind.TAKE || kind == Kind.STALE) "${kind.wire}:${baseline.toLong()}:${revoke.joinToString(",")}" else kind.wire
+}
+
 sealed class AkanNativeRangeAnswer {
     object Whole : AkanNativeRangeAnswer()
     /** First and last byte, inclusive. */
@@ -321,4 +329,33 @@ object AkanNativeKernel {
         if (!topLevel) return if (scheme in AkanNativeContract.FRAME_SCHEMES) AkanNativeNavigation.LOAD else AkanNativeNavigation.DROP
         return if (scheme in externalSchemes(extra)) AkanNativeNavigation.OPEN else AkanNativeNavigation.DROP
     }
+
+    /**
+     * kernel.ts updateDecision: a key revokes only keys listed before it (a leaked online key, listed first, cannot
+     * revoke the spares that recover from it), and resetSequence counts only when it newly revokes a key.
+     */
+    fun updateDecision(
+        ring: List<String>, revoked: List<String>, signer: String, revokeKeys: List<String>, resetSequence: Boolean,
+        sequence: Double, embedded: Double, running: Pair<Double, String>?,
+    ): AkanNativeUpdateDecision {
+        val index = ring.indexOf(signer)
+        if (index < 0) return AkanNativeUpdateDecision(AkanNativeUpdateDecision.Kind.UNTRUSTED)
+        if (signer in revoked) return AkanNativeUpdateDecision(AkanNativeUpdateDecision.Kind.REVOKED)
+        if (signer in revokeKeys) return AkanNativeUpdateDecision(AkanNativeUpdateDecision.Kind.SELF_REVOKE)
+        if (revokeKeys.any { ring.indexOf(it) > index }) return AkanNativeUpdateDecision(AkanNativeUpdateDecision.Kind.REVOKE_LATER)
+        val revoke = ring.filter { it in revokeKeys && it !in revoked }
+        val bar = running?.takeIf { it.second !in revoked && it.second !in revoke }?.first ?: 0.0
+        val baseline = if (resetSequence && revoke.isNotEmpty()) embedded else maxOf(embedded, bar)
+        val kind = if (sequence > baseline) AkanNativeUpdateDecision.Kind.TAKE else AkanNativeUpdateDecision.Kind.STALE
+        return AkanNativeUpdateDecision(kind, baseline, revoke)
+    }
+
+    /** kernel.ts updateManifestUrl: one envelope per channel and native API. */
+    fun updateManifestUrl(url: String, platform: String, channel: String, nativeApi: String): String = "$url/$platform/$channel/$nativeApi.json"
+
+    /** The first 8 bytes of the raw public key's SHA-256, in hex: what an envelope names its signer by. */
+    fun updateKeyId(publicKey: ByteArray): String =
+        MessageDigest.getInstance("SHA-256").digest(publicKey).take(8).joinToString("") { "%02x".format(it) }
+
+    fun isUpdateKeyId(s: String): Boolean = s.length == 16 && s.all { it in '0'..'9' || it in 'a'..'f' }
 }

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeUpdateReports.kt

@@ -0,0 +1,169 @@
+// What became of each web bundle release (F-S2), posted to updates.report.url: the Android twin of
+// native/ios/Sources/AkanNativeUpdateReports.swift, same file and wire format.
+//
+// noBackupFilesDir/akan-native-updates/report.json: { installId, nextId, events: [{ id, event, bundle, sequence, reason,
+// at }], retryAt?, seen: [key] }. reset() rewrites state.json only, so the installId (random, not a device identifier)
+// and the id counter live as long as the install, and an id is never used twice.
+// Sent from the activity's onResume, so at launch and on each return to the foreground: oldest first, 20 to a request,
+// one request at a time. A 2xx removes the batch; a 4xx other than 408 and 429 drops it, since the same body would be
+// refused forever; a 408 (a body slower than the server waits for), a 429, a 5xx or no answer keeps it for the next time
+// (after Retry-After). At most 100 wait, the oldest dropped first. Main thread only; the request runs on a worker thread.
+package com.akanjs.runtime
+
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.AtomicFile
+import android.util.Log
+import java.io.File
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.SecureRandom
+import java.time.Instant
+import java.time.temporal.ChronoUnit
+import org.json.JSONArray
+import org.json.JSONObject
+
+object AkanNativeUpdateReports {
+    private const val TAG = "AkanNativeUpdates"
+    private const val LIMIT = 100
+    private const val BATCH = 20
+    private val main = Handler(Looper.getMainLooper())
+    private var sending = false
+
+    private class Report(
+        val installId: String,
+        var nextId: Long,
+        val events: MutableList<JSONObject>,
+        var retryAt: Double?,
+        val seen: MutableList<String>,
+    )
+
+    private val file get() = AtomicFile(File(AkanNativeUpdates.directory, "report.json"))
+
+    /**
+     * downloaded, applied, confirmed, rolledBack (timeout, relaunch, hang, verify) or failed (download, verify, disk,
+     * signature, manifest). Nothing is kept when the build names no report URL.
+     */
+    fun record(event: String, bundle: String?, sequence: Double?, reason: String? = null) {
+        if (AkanNativeUpdates.config?.reportUrl == null || bundle == null || !AkanNativeKernel.isBundleId(bundle)) return
+        val report = read()
+        // A check runs at every launch: the same failure of the same release is one event, not one per launch.
+        val key = "$event|$bundle|${reason ?: ""}"
+        if (key in report.seen) return
+        report.seen.add(key)
+        while (report.seen.size > LIMIT) report.seen.removeAt(0)
+        val number: Any = sequence?.let { if (it == Math.rint(it) && Math.abs(it) < 9e15) it.toLong() else it } ?: JSONObject.NULL
+        report.events.add(
+            JSONObject().put("id", report.nextId).put("event", event).put("bundle", bundle).put("sequence", number)
+                .put("reason", reason ?: JSONObject.NULL).put("at", Instant.now().truncatedTo(ChronoUnit.MILLIS).toString()),
+        )
+        while (report.events.size > LIMIT) report.events.removeAt(0)
+        report.nextId++
+        write(report)
+    }
+
+    fun record(event: String, entry: AkanNativeUpdateEntry, reason: String? = null) = record(event, entry.bundle, entry.sequence, reason)
+
+    fun flush() {
+        val config = AkanNativeUpdates.config ?: return
+        val address = config.reportUrl ?: return
+        if (sending) return
+        val report = read()
+        val now = System.currentTimeMillis() / 1000.0
+        // A Retry-After more than a day out is a clock that moved, not the server's wish.
+        report.retryAt?.let { if (it > now && it < now + 86_400) return }
+        val events = report.events.take(BATCH)
+        if (events.isEmpty()) return
+        val body = JSONObject()
+            .put("app", config.app).put("platform", config.platform).put("channel", config.channel).put("installId", report.installId)
+            .put("nativeApi", config.nativeApi).put("appVersion", config.version).put("os", "Android ${Build.VERSION.RELEASE}")
+            .put("events", JSONArray(events))
+            .toString().toByteArray()
+        val ids = events.map { it.optLong("id") }.toSet()
+        sending = true
+        Thread {
+            var status = 0
+            var retryAfter: String? = null
+            try {
+                val connection = URL(address).openConnection() as HttpURLConnection
+                try {
+                    connection.requestMethod = "POST"
+                    connection.doOutput = true
+                    connection.connectTimeout = 30_000
+                    connection.readTimeout = 30_000
+                    connection.useCaches = false
+                    connection.setRequestProperty("Content-Type", "application/json")
+                    connection.setFixedLengthStreamingMode(body.size)
+                    connection.outputStream.use { it.write(body) }
+                    status = connection.responseCode
+                    retryAfter = connection.getHeaderField("Retry-After")
+                } finally {
+                    connection.disconnect()
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "cannot post update reports: $e")
+            }
+            main.post {
+                sending = false
+                settle(ids, status, retryAfter)
+            }
+        }.start()
+    }
+
+    private fun settle(ids: Set<Long>, status: Int, retryAfter: String?) {
+        val report = read()
+        if (status !in 200..299 && (status !in 400..499 || status == 408 || status == 429)) {
+            report.retryAt = retryAfter?.trim()?.toDoubleOrNull()?.let { System.currentTimeMillis() / 1000.0 + it }
+            write(report)
+            return
+        }
+        report.events.removeAll { it.optLong("id") in ids }
+        report.retryAt = null
+        write(report)
+        flush()
+    }
+
+    private fun read(): Report {
+        val o = try {
+            JSONObject(String(file.readFully()))
+        } catch (e: Exception) {
+            JSONObject()
+        }
+        val installId = o.optString("installId")
+        if (!Regex("[0-9a-fA-F]{32}").matches(installId)) return Report(newInstallId(), 0, mutableListOf(), null, mutableListOf())
+        val events = o.optJSONArray("events")
+        val seen = o.optJSONArray("seen")
+        return Report(
+            installId,
+            o.optLong("nextId"),
+            MutableList(events?.length() ?: 0) { events?.optJSONObject(it) }.filterNotNull().toMutableList(),
+            if (o.has("retryAt")) o.optDouble("retryAt") else null,
+            MutableList(seen?.length() ?: 0) { seen?.optString(it).orEmpty() }.filter { it.isNotEmpty() }.toMutableList(),
+        )
+    }
+
+    private fun write(report: Report) {
+        AkanNativeUpdates.directory.mkdirs()
+        val o = JSONObject().put("installId", report.installId).put("nextId", report.nextId).put("events", JSONArray(report.events))
+            .put("seen", JSONArray(report.seen))
+        report.retryAt?.let { o.put("retryAt", it) }
+        val target = file
+        val out = try {
+            target.startWrite()
+        } catch (e: IOException) {
+            Log.w(TAG, "cannot write report.json: $e")
+            return
+        }
+        try {
+            out.write(o.toString().toByteArray())
+            target.finishWrite(out)
+        } catch (e: IOException) {
+            target.failWrite(out)
+            Log.w(TAG, "cannot write report.json: $e")
+        }
+    }
+
+    private fun newInstallId(): String = ByteArray(16).also { SecureRandom().nextBytes(it) }.joinToString("") { "%02x".format(it) }
+}