ubriot-updates-rn 0.1.4 → 0.2.0

package/README.md

@@ -14,8 +14,15 @@ native + JS runtime that consumes those updates in a bare app.
 - Talks to the existing `GET /ubriot/updates/manifest` endpoint (Expo-Updates-style
   manifest contract, including the `expo-runtime-version`, `expo-channel-name`, and
   `expo-current-update-id` request headers).
-- Downloads the manifest's `launchAsset` bundle to app storage (iOS
-  `Library/ubriot-updates/`, Android `filesDir/ubriot-updates/`).
+- Downloads the manifest's `launchAsset` bundle AND every asset in `manifest.assets`
+  (fonts, images, anything the bundle references) into one folder per update (iOS
+  `Library/ubriot-updates/<id>/`, Android `filesDir/ubriot-updates/<id>/`). Redirects are
+  followed and each file's SHA-256 is checked when the manifest carries a `hash`. The
+  update is only staged once every file is present and verified; any failure discards
+  it and the app keeps running what it has.
+- Resolves the bundle's `require('./font.ttf')` / `require('./image.png')` references to
+  the downloaded files (matched by content hash), falling back to the copy embedded in
+  the native build for anything the update did not ship.
 - Persists which bundle is `pending`, `active`, `verified`, and `lastKnownGood` in a
   small `state.json` next to the bundles.
 - Boots the verified/active downloaded bundle instead of the embedded one, with
@@ -47,6 +54,8 @@ UbriotUpdates.configure({
   appSlug: "your-app-slug",
   channel: "production",
   runtimeVersion: "your-app-1.0.0",
+  nativeBuildId: "358",
+  nativeBuildCreatedAt: "2026-09-26T00:00:00.000Z",
 });
 
 // Convenience: check -> download -> apply (does not restart by default)
@@ -57,25 +66,60 @@ const { available, manifestId } = await UbriotUpdates.checkForUpdate();
 const { ready } = await UbriotUpdates.downloadUpdate();
 await UbriotUpdates.applyUpdate({ restart: true }); // reload JS now
 
-// Call once the app has rendered and run OK. Promotes the active bundle to
-// "verified" so it becomes the rollback target instead of being rolled back.
+// Call once the first real screen has rendered (not the splash). Promotes the
+// running bundle to "verified" so it becomes the rollback target instead of being
+// rolled back on the next launch.
 UbriotUpdates.markLaunchSuccessful();
+
+// Fallback only: mark the launch after a delay if you cannot hook a render.
+// Returns a cancel function. An explicit markLaunchSuccessful() cancels it.
+const cancel = UbriotUpdates.markLaunchSuccessfulAfter(4000);
 ```
 
-Recommended app-start pattern:
+Import the package once at the top of your entry file (`index.js` / `App.tsx`) so its
+asset resolver is installed before any font or image is resolved:
 
 ```ts
-useEffect(() => {
-  UbriotUpdates.configure({ /* ... */ });
-  UbriotUpdates.sync().catch(() => {});
-  const t = setTimeout(() => UbriotUpdates.markLaunchSuccessful(), 4000);
-  return () => clearTimeout(t);
-}, []);
+import * as UbriotUpdates from "ubriot-updates-rn";
 ```
 
+Recommended app-start pattern:
+
+```tsx
+function Root() {
+  useEffect(() => {
+    UbriotUpdates.configure({ /* ... */ });
+    UbriotUpdates.sync().catch(() => {});
+  }, []);
+  return <App onFirstScreenRendered={() => UbriotUpdates.markLaunchSuccessful()} />;
+}
+```
+
+Call `markLaunchSuccessful()` from the first screen that proves the app works (for
+example in a `useEffect` of the signed-in or signed-out home screen, after fonts have
+loaded). Do not call it from a timer on the splash: a timer marks a hung or broken
+update as good, and then it is never rolled back. `markLaunchSuccessfulAfter(ms)` exists
+only as a fallback for apps that cannot hook a render; it gives crash-on-launch
+protection but not hang protection.
+
 `sync()` downloads and stages the update; it applies on the next launch. Use
 `applyUpdate({ restart: true })` if you want to reload immediately.
 
+`nativeBuildId` and `nativeBuildCreatedAt` are optional and let the server-side
+staleness guard tell a stale native shell apart from a stale OTA bundle. Expo apps can
+read these from `Constants.expoConfig?.extra?.ubriotBuild` (set by the config plugin at
+build time) and pass them straight into `configure()`. Bare RN apps that don't use Expo
+config can supply their own build metadata the same way. `nativeBuildCreatedAt` must be
+a UTC ISO string (e.g. `2026-09-26T00:00:00.000Z`).
+
+Apps that use a dynamic Expo config (`app.config.js` / `app.config.ts` instead of
+`app.json` / `app.config.json`) are not auto-stamped: the Ubriot build worker only
+writes `expo.extra.ubriotBuild` into static JSON config files, and skips dynamic config
+with a warning in the build logs. Those apps must supply `nativeBuildId` and
+`nativeBuildCreatedAt` to `configure()` themselves (for example, by reading build
+metadata baked in through `app.config.js`'s own logic), otherwise per-device OTA
+staleness checks are skipped for that app.
+
 ## Rollback model
 
 - A freshly applied bundle is `active` but unverified.
@@ -84,8 +128,19 @@ useEffect(() => {
 - If the app boots that bundle again while still unverified (meaning the previous launch
   never reached `markLaunchSuccessful()`, e.g. it crashed on load), the client reverts to
   the last known good bundle (or the embedded bundle) instead.
-- `markLaunchSuccessful()` marks the active bundle verified and records it as the new last
-  known good.
+- `markLaunchSuccessful()` marks the bundle that is actually running verified and records
+  it as the new last known good. An update that was downloaded and applied during this
+  session (and has not run yet) is never marked verified by it.
+- An update that was rolled back is remembered (`failedUpdateIds`) and is not downloaded
+  again, so a bad update cannot loop.
+
+## Upgrading from 0.1.x
+
+0.2.0 changes native code, so it needs a new native build (TestFlight / Play). On an old
+native build the new JS falls back to the old bundle-only download. Replace any
+`setTimeout(() => markLaunchSuccessful(), 4000)` with a call from your first rendered
+screen. If you added your own asset source transformer as a workaround for missing OTA
+assets, remove it, or register it after importing this package.
 
 ## Native integration
 

package/android/src/main/java/dev/ubriot/updates/UbriotUpdatesModule.kt

@@ -1,21 +1,30 @@
 package dev.ubriot.updates
 
 import android.content.Context
+import android.util.Base64
 import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableMap
+import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
 import java.net.HttpURLConnection
 import java.net.URL
+import java.security.MessageDigest
+import java.util.UUID
+import java.util.concurrent.Executors
 
 data class UbriotUpdateEntry(val id: String, val bundlePath: String)
 
+data class UbriotDownloadAsset(val key: String, val url: String, val hash: String?, val fileExtension: String)
+
 class UbriotUpdateState(
   var runningId: String? = null,
   var active: UbriotUpdateEntry? = null,
@@ -24,6 +33,7 @@ class UbriotUpdateState(
   var lastKnownGood: UbriotUpdateEntry? = null,
   var launchCount: Int = 0,
   var revertedFromId: String? = null,
+  var failedUpdateIds: MutableList<String> = mutableListOf(),
 )
 
 class UbriotUpdatesModule(
@@ -34,6 +44,19 @@ class UbriotUpdatesModule(
 
   private fun filesDir(): File = reactContext.applicationContext.filesDir
 
+  override fun getConstants(): MutableMap<String, Any?> {
+    val constants = HashMap<String, Any?>()
+    constants["embeddedBundleUrl"] = null
+    constants["supportsAssets"] = true
+    constants["runningUpdate"] = try {
+      val entry = runningEntry
+      if (entry == null) null else hashMapOf<String, Any?>("id" to entry.id, "assets" to assetFileUrls(entry.bundlePath, filesDir()))
+    } catch (_: Throwable) {
+      null
+    }
+    return constants
+  }
+
   @ReactMethod
   fun getState(promise: Promise) {
     try {
@@ -43,6 +66,73 @@ class UbriotUpdatesModule(
     }
   }
 
+  @ReactMethod
+  fun downloadUpdate(request: ReadableMap, promise: Promise) {
+    val manifestId = if (request.hasKey("id") && request.getType("id") == ReadableType.String) request.getString("id") else null
+    if (manifestId.isNullOrEmpty()) {
+      promise.reject("ubriot_updates_bad_args", "id is required")
+      return
+    }
+    val launchAsset = if (request.hasKey("launchAsset") && request.getType("launchAsset") == ReadableType.Map) request.getMap("launchAsset") else null
+    val launchUrl = launchAsset?.let { optString(it, "url") }
+    if (launchUrl.isNullOrEmpty()) {
+      promise.reject("ubriot_updates_bad_args", "launchAsset.url is required")
+      return
+    }
+    val launchHash = launchAsset?.let { optString(it, "hash") }
+    val assets = mutableListOf<UbriotDownloadAsset>()
+    if (request.hasKey("assets") && request.getType("assets") == ReadableType.Array) {
+      val array = request.getArray("assets")
+      if (array != null) {
+        for (index in 0 until array.size()) {
+          val item = if (array.getType(index) == ReadableType.Map) array.getMap(index) else null
+          val key = item?.let { optString(it, "key") }
+          val url = item?.let { optString(it, "url") }
+          if (item == null || key.isNullOrEmpty() || url.isNullOrEmpty()) {
+            promise.reject("ubriot_updates_bad_args", "Asset key and url are required")
+            return
+          }
+          assets.add(UbriotDownloadAsset(key, url, optString(item, "hash"), optString(item, "fileExtension") ?: ""))
+        }
+      }
+    }
+
+    downloadExecutor.execute {
+      var staging: File? = null
+      try {
+        val root = updatesDir(filesDir())
+        if (!root.exists()) root.mkdirs()
+        val safeId = sanitize(manifestId)
+        staging = File(root, ".staging-$safeId-${UUID.randomUUID()}")
+        val failure = stageUpdate(staging, launchUrl, launchHash, assets)
+        if (failure != null) {
+          staging.deleteRecursively()
+          promise.reject("ubriot_updates_download_failed", failure)
+          return@execute
+        }
+        val finalDirectory = File(root, safeId)
+        if (finalDirectory.exists()) finalDirectory.deleteRecursively()
+        if (!staging.renameTo(finalDirectory)) {
+          staging.deleteRecursively()
+          promise.reject("ubriot_updates_write_failed", "Could not persist update")
+          return@execute
+        }
+        val bundle = File(finalDirectory, BUNDLE_FILE)
+        val state = readState(filesDir())
+        state.pending = UbriotUpdateEntry(manifestId, bundle.absolutePath)
+        writeState(filesDir(), state)
+
+        val result = Arguments.createMap()
+        result.putBoolean("ready", true)
+        result.putString("bundlePath", bundle.absolutePath)
+        promise.resolve(result)
+      } catch (error: Throwable) {
+        staging?.deleteRecursively()
+        promise.reject("ubriot_updates_download_failed", error)
+      }
+    }
+  }
+
   @ReactMethod
   fun downloadBundle(url: String, manifestId: String, promise: Promise) {
     Thread {
@@ -113,11 +203,17 @@ class UbriotUpdatesModule(
     try {
       val state = readState(filesDir())
       val active = state.active
-      if (active != null && !state.verified) {
+      val runningId = state.runningId
+      val activeIsRunning = active != null && runningId != null && active.id == runningId
+      val running = runningEntry
+      if (activeIsRunning && !state.verified) {
         state.verified = true
         state.lastKnownGood = active
         state.launchCount = 0
         writeState(filesDir(), state)
+      } else if (!activeIsRunning && runningId != null && state.lastKnownGood?.id != runningId && running != null && running.id == runningId) {
+        state.lastKnownGood = running
+        writeState(filesDir(), state)
       }
       promise.resolve(null)
     } catch (error: Throwable) {
@@ -144,7 +240,7 @@ class UbriotUpdatesModule(
       UiThreadUtil.runOnUiThread {
         try {
           if (application is ReactApplication) {
-            application.reactHost.reload("Ubriot OTA update")
+            application.reactHost?.reload("Ubriot OTA update")
           }
         } catch (_: Throwable) {
         }
@@ -164,6 +260,9 @@ class UbriotUpdatesModule(
     map.putMap("lastKnownGood", entryToWritableMap(state.lastKnownGood))
     map.putInt("launchCount", state.launchCount)
     map.putString("revertedFromId", state.revertedFromId)
+    val failed = Arguments.createArray()
+    state.failedUpdateIds.forEach { failed.pushString(it) }
+    map.putArray("failedUpdateIds", failed)
     return map
   }
 
@@ -178,6 +277,17 @@ class UbriotUpdatesModule(
   companion object {
     private const val DIR_NAME = "ubriot-updates"
     private const val STATE_FILE = "state.json"
+    private const val BUNDLE_FILE = "index.jsbundle"
+    private const val ASSET_INDEX_FILE = "assets.json"
+    private const val MAX_FAILED_IDS = 20
+
+    private val downloadExecutor = Executors.newSingleThreadExecutor()
+
+    @Volatile
+    private var runningEntry: UbriotUpdateEntry? = null
+
+    @Volatile
+    private var bootedActive: UbriotUpdateEntry? = null
 
     private fun updatesDir(filesDir: File): File = File(filesDir, DIR_NAME)
 
@@ -188,6 +298,111 @@ class UbriotUpdatesModule(
       return if (cleaned.isEmpty()) "update" else cleaned
     }
 
+    private fun optString(map: ReadableMap, key: String): String? {
+      if (!map.hasKey(key) || map.getType(key) != ReadableType.String) return null
+      return map.getString(key)?.ifEmpty { null }
+    }
+
+    private fun sha256(file: File): ByteArray {
+      val digest = MessageDigest.getInstance("SHA-256")
+      file.inputStream().use { input ->
+        val buffer = ByteArray(64 * 1024)
+        while (true) {
+          val read = input.read(buffer)
+          if (read < 0) break
+          digest.update(buffer, 0, read)
+        }
+      }
+      return digest.digest()
+    }
+
+    private fun matchesHash(file: File, expected: String?): Boolean {
+      if (expected.isNullOrEmpty()) return true
+      val digest = sha256(file)
+      val base64Url = Base64.encodeToString(digest, Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)
+      val hex = digest.joinToString("") { "%02x".format(it) }
+      val normalized = expected.replace('+', '-').replace('/', '_').trimEnd('=')
+      return normalized == base64Url || expected.lowercase() == hex
+    }
+
+    private fun downloadFile(url: String, destination: File, expectedHash: String?): String? {
+      var connection: HttpURLConnection? = null
+      try {
+        var current = URL(url)
+        var redirects = 0
+        while (true) {
+          connection = (current.openConnection() as HttpURLConnection).apply {
+            instanceFollowRedirects = false
+            connectTimeout = 30000
+            readTimeout = 60000
+            requestMethod = "GET"
+            useCaches = false
+          }
+          val status = connection.responseCode
+          if (status in 300..399) {
+            val location = connection.getHeaderField("Location")
+            connection.disconnect()
+            connection = null
+            if (location.isNullOrEmpty() || redirects >= 5) return "$url: bad redirect"
+            current = URL(current, location)
+            redirects += 1
+            continue
+          }
+          if (status < 200 || status >= 300) return "$url: HTTP $status"
+          destination.parentFile?.mkdirs()
+          connection.inputStream.use { input ->
+            destination.outputStream().use { output -> input.copyTo(output) }
+          }
+          break
+        }
+        if (!destination.exists() || destination.length() == 0L) return "$url: empty file"
+        if (!matchesHash(destination, expectedHash)) return "$url: hash mismatch"
+        return null
+      } catch (error: Throwable) {
+        return "$url: ${error.message ?: error.javaClass.simpleName}"
+      } finally {
+        connection?.disconnect()
+      }
+    }
+
+    private fun stageUpdate(staging: File, launchUrl: String, launchHash: String?, assets: List<UbriotDownloadAsset>): String? {
+      val assetsDirectory = File(staging, "assets")
+      if (!assetsDirectory.mkdirs() && !assetsDirectory.isDirectory) return "Could not create update directory"
+      downloadFile(launchUrl, File(staging, BUNDLE_FILE), launchHash)?.let { return it }
+      val index = JSONObject()
+      for (asset in assets) {
+        if (index.has(asset.key)) continue
+        val extension = if (asset.fileExtension.isEmpty()) "" else sanitize(asset.fileExtension)
+        val relative = "assets/${sanitize(asset.key)}$extension"
+        downloadFile(asset.url, File(staging, relative), asset.hash)?.let { return it }
+        index.put(asset.key, relative)
+      }
+      return try {
+        File(staging, ASSET_INDEX_FILE).writeText(index.toString())
+        null
+      } catch (_: Throwable) {
+        "Could not write asset index"
+      }
+    }
+
+    private fun assetFileUrls(bundlePath: String, filesDir: File): HashMap<String, Any?> {
+      val urls = HashMap<String, Any?>()
+      val directory = File(bundlePath).parentFile ?: return urls
+      if (directory.absolutePath == updatesDir(filesDir).absolutePath) return urls
+      val indexFile = File(directory, ASSET_INDEX_FILE)
+      if (!indexFile.exists()) return urls
+      val index = JSONObject(indexFile.readText())
+      val keys = index.keys()
+      while (keys.hasNext()) {
+        val key = keys.next()
+        val relative = index.optString(key, "")
+        if (relative.isEmpty()) continue
+        val file = File(directory, relative)
+        if (file.exists()) urls[key] = "file://${file.absolutePath}"
+      }
+      return urls
+    }
+
     private fun entryFromJson(obj: JSONObject?): UbriotUpdateEntry? {
       if (obj == null) return null
       val id = obj.optString("id", "")
@@ -201,6 +416,22 @@ class UbriotUpdatesModule(
       return JSONObject().put("id", entry.id).put("bundlePath", entry.bundlePath)
     }
 
+    private fun failedIdsFromJson(array: JSONArray?): MutableList<String> {
+      val ids = mutableListOf<String>()
+      if (array == null) return ids
+      for (index in 0 until array.length()) {
+        val value = array.optString(index, "")
+        if (value.isNotEmpty()) ids.add(value)
+      }
+      return ids
+    }
+
+    private fun recordFailedId(state: UbriotUpdateState, id: String) {
+      state.failedUpdateIds.remove(id)
+      state.failedUpdateIds.add(id)
+      while (state.failedUpdateIds.size > MAX_FAILED_IDS) state.failedUpdateIds.removeAt(0)
+    }
+
     @Synchronized
     fun readState(filesDir: File): UbriotUpdateState {
       return try {
@@ -215,6 +446,7 @@ class UbriotUpdatesModule(
           lastKnownGood = entryFromJson(json.optJSONObject("lastKnownGood")),
           launchCount = json.optInt("launchCount", 0),
           revertedFromId = json.optString("revertedFromId", "").ifEmpty { null },
+          failedUpdateIds = failedIdsFromJson(json.optJSONArray("failedUpdateIds")),
         )
       } catch (_: Throwable) {
         UbriotUpdateState()
@@ -234,7 +466,14 @@ class UbriotUpdatesModule(
           .put("lastKnownGood", entryToJson(state.lastKnownGood))
           .put("launchCount", state.launchCount)
           .put("revertedFromId", state.revertedFromId ?: JSONObject.NULL)
-        stateFile(filesDir).writeText(json.toString())
+          .put("failedUpdateIds", JSONArray(state.failedUpdateIds))
+        val target = stateFile(filesDir)
+        val temp = File(directory, "$STATE_FILE.tmp")
+        temp.writeText(json.toString())
+        if (!temp.renameTo(target)) {
+          target.writeText(json.toString())
+          temp.delete()
+        }
       } catch (_: Throwable) {
       }
     }
@@ -246,18 +485,28 @@ class UbriotUpdatesModule(
         val state = readState(filesDir)
         val active = state.active
         if (active != null && File(active.bundlePath).exists()) {
+          val booted = bootedActive
+          if (booted != null && booted.id == active.id) {
+            runningEntry = active
+            return booted.bundlePath
+          }
           if (state.verified) {
             state.runningId = active.id
             writeState(filesDir, state)
+            runningEntry = active
             return active.bundlePath
           }
           if (state.launchCount < 1) {
             state.launchCount = 1
             state.runningId = active.id
             writeState(filesDir, state)
+            bootedActive = active
+            runningEntry = active
             return active.bundlePath
           }
           state.revertedFromId = active.id
+          recordFailedId(state, active.id)
+          if (state.lastKnownGood?.id == active.id) state.lastKnownGood = null
           state.active = null
           state.verified = false
           state.launchCount = 0
@@ -271,13 +520,16 @@ class UbriotUpdatesModule(
         if (lastKnownGood != null && File(lastKnownGood.bundlePath).exists()) {
           state.runningId = lastKnownGood.id
           writeState(filesDir, state)
+          runningEntry = lastKnownGood
           return lastKnownGood.bundlePath
         }
 
         state.runningId = null
         writeState(filesDir, state)
+        runningEntry = null
         null
       } catch (_: Throwable) {
+        runningEntry = null
         null
       }
     }

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/withUbriotUpdates");

package/dist/asset-source.d.ts

@@ -0,0 +1,28 @@
+export type RunningUpdate = {
+    id: string;
+    assets: Record<string, string>;
+};
+export type PackagerAssetLike = {
+    scales: number[];
+    hash: string;
+    fileHashes?: string[];
+    name: string;
+    type: string;
+    width?: number | null;
+    height?: number | null;
+};
+export type ResolvedSource = {
+    uri: string;
+    [key: string]: unknown;
+};
+export type AssetResolverLike = {
+    asset: PackagerAssetLike;
+    isLoadedFromServer(): boolean;
+    defaultAsset(): ResolvedSource;
+};
+export type OtaAssetTransformerOptions = {
+    getRunning(): RunningUpdate | null;
+    embeddedBundleUrl: string | null;
+    pixelRatio(): number;
+};
+export declare function createOtaAssetTransformer(options: OtaAssetTransformerOptions): (resolver: AssetResolverLike) => ResolvedSource | null;

package/dist/asset-source.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOtaAssetTransformer = createOtaAssetTransformer;
+function pickScale(scales, deviceScale) {
+    for (const scale of scales) {
+        if (scale >= deviceScale)
+            return scale;
+    }
+    return scales[scales.length - 1] || 1;
+}
+function candidateIndexes(scales, preferred) {
+    const preferredIndex = scales.indexOf(preferred);
+    const rest = scales.map((_, index) => index).filter((index) => index !== preferredIndex);
+    return preferredIndex >= 0 ? [preferredIndex, ...rest] : rest;
+}
+function hashAt(asset, index) {
+    if (asset.fileHashes && asset.fileHashes.length > 0)
+        return asset.fileHashes[index];
+    return index === 0 ? asset.hash : undefined;
+}
+function downloadedSource(asset, running, deviceScale) {
+    const scales = asset.scales && asset.scales.length > 0 ? asset.scales : [1];
+    const preferred = pickScale(scales, deviceScale);
+    for (const index of candidateIndexes(scales, preferred)) {
+        const hash = hashAt(asset, index);
+        const uri = hash ? running.assets[hash] : undefined;
+        if (uri) {
+            return {
+                __packager_asset: true,
+                width: asset.width,
+                height: asset.height,
+                uri,
+                scale: scales[index],
+            };
+        }
+    }
+    return null;
+}
+function embeddedSource(resolver, embeddedBundleUrl) {
+    const Resolver = resolver.constructor;
+    return new Resolver(null, embeddedBundleUrl, resolver.asset).defaultAsset();
+}
+function createOtaAssetTransformer(options) {
+    return (resolver) => {
+        var _a;
+        try {
+            const running = options.getRunning();
+            if (!running)
+                return null;
+            if (resolver.isLoadedFromServer())
+                return null;
+            return (_a = downloadedSource(resolver.asset, running, options.pixelRatio())) !== null && _a !== void 0 ? _a : embeddedSource(resolver, options.embeddedBundleUrl);
+        }
+        catch {
+            return null;
+        }
+    };
+}

package/dist/client.d.ts

@@ -0,0 +1,76 @@
+import type { UbriotUpdatesConfig } from "./manifest-headers";
+export type UpdateCheckResult = {
+    available: boolean;
+    manifestId?: string;
+};
+export type DownloadResult = {
+    ready: boolean;
+};
+export type ApplyOptions = {
+    restart?: boolean;
+};
+export type SyncResult = "up-to-date" | "updated";
+export type LaunchOutcome = "launched" | "crashed";
+export type NativeEntry = {
+    id: string;
+    bundlePath: string;
+} | null;
+export type NativeState = {
+    runningId: string | null;
+    active: NativeEntry;
+    verified: boolean;
+    pending: NativeEntry;
+    lastKnownGood: NativeEntry;
+    launchCount: number;
+    revertedFromId?: string | null;
+    failedUpdateId?: string | null;
+    lastRevertedId?: string | null;
+    failedUpdateIds?: string[] | null;
+};
+export type NativeDownloadRequest = {
+    id: string;
+    launchAsset: {
+        url: string;
+        hash: string | null;
+    };
+    assets: {
+        key: string;
+        url: string;
+        hash: string | null;
+        fileExtension: string;
+    }[];
+};
+export type NativeUbriotUpdates = {
+    getState(): Promise<NativeState>;
+    downloadUpdate?(request: NativeDownloadRequest): Promise<{
+        ready: boolean;
+        bundlePath?: string;
+    }>;
+    downloadBundle?(url: string, manifestId: string): Promise<{
+        ready: boolean;
+        bundlePath: string;
+    }>;
+    applyPending(): Promise<void>;
+    markLaunchSuccessful(): Promise<void>;
+    reload(): Promise<void>;
+    clearRevertedFrom?(): Promise<void>;
+};
+type TimerHandle = unknown;
+export type UpdatesClientDeps = {
+    getNative(): NativeUbriotUpdates | undefined;
+    fetch: typeof fetch;
+    platform: "ios" | "android";
+    setTimeout(callback: () => void, ms: number): TimerHandle;
+    clearTimeout(handle: TimerHandle): void;
+};
+export declare const DEFAULT_LAUNCH_FALLBACK_MS = 4000;
+export declare function createUpdatesClient(deps: UpdatesClientDeps): {
+    configure: (next: UbriotUpdatesConfig) => void;
+    checkForUpdate: () => Promise<UpdateCheckResult>;
+    downloadUpdate: () => Promise<DownloadResult>;
+    applyUpdate: (options?: ApplyOptions) => Promise<void>;
+    sync: () => Promise<SyncResult>;
+    markLaunchSuccessful: () => void;
+    markLaunchSuccessfulAfter: (ms?: number) => () => void;
+};
+export {};