@absolutejs/absolute 0.20.0-beta.84 → 0.20.0-beta.86

package/dist/mobile/shellUpdate.js

@@ -157,17 +157,18 @@ var fileUrl = (manifestUrl, releaseId, path) => {
     throw new TypeError("Mobile update asset escaped its signed release origin.");
   return result;
 };
-var readChunks = async (reader, maximum, chunks = [], received = 0) => {
+var readChunks = async (reader, maximum, onChunk, chunks = [], received = 0) => {
   const result = await reader.read();
   if (result.done)
     return { chunks, received };
   const total = received + result.value.byteLength;
   if (total > maximum)
     throw new TypeError("Mobile update response exceeds its signed size.");
+  await onChunk?.(result.value, received);
   chunks.push(result.value);
-  return readChunks(reader, maximum, chunks, total);
+  return readChunks(reader, maximum, onChunk, chunks, total);
 };
-var readBounded = async (response, maximum) => {
+var readBounded = async (response, maximum, onChunk) => {
   const declared = Number(response.headers.get("content-length"));
   if (Number.isFinite(declared) && declared > maximum)
     throw new TypeError("Mobile update response exceeds its signed size.");
@@ -175,8 +176,9 @@ var readBounded = async (response, maximum) => {
     return new Uint8Array;
   const reader = response.body.getReader();
   let result;
+  const chunks = [];
   try {
-    result = await readChunks(reader, maximum);
+    result = await readChunks(reader, maximum, onChunk, chunks);
   } catch (error) {
     await reader.cancel().catch(() => {
       return;
@@ -185,7 +187,7 @@ var readBounded = async (response, maximum) => {
   }
   const contents = new Uint8Array(result.received);
   let offset = 0;
-  for (const chunk of result.chunks) {
+  for (const chunk of chunks) {
     contents.set(chunk, offset);
     offset += chunk.byteLength;
   }
@@ -198,6 +200,30 @@ var requestHeaders = (config) => ({
   "x-absolute-mobile-release": config.currentReleaseId,
   "x-absolute-mobile-runtime": config.runtimeFingerprint
 });
+var healthUrl = (manifestUrl) => new URL("./health", manifestUrl);
+var reportAbsoluteMobileUpdateHealth = async (config, input, request = globalThis.fetch) => {
+  const manifestUrl = exactManifestUrl(config.manifestUrl);
+  const headers = new Headers(requestHeaders(config));
+  headers.set("content-type", "application/json");
+  headers.set("x-absolute-mobile-health-token", input.healthToken);
+  const response = await request(healthUrl(manifestUrl), {
+    body: JSON.stringify({
+      kind: input.kind,
+      ...input.reason ? { reason: input.reason } : {},
+      releaseId: input.releaseId,
+      ...input.transfer ? { transfer: input.transfer } : {}
+    }),
+    cache: "no-store",
+    credentials: "omit",
+    headers,
+    keepalive: true,
+    method: "POST",
+    redirect: "error",
+    signal: AbortSignal.timeout(15000)
+  });
+  if (response.status !== 202)
+    throw new TypeError(`Mobile update health report failed with HTTP ${response.status}.`);
+};
 var requireCompatible = (manifest, config) => {
   if (manifest.appId !== config.appId)
     throw new TypeError("Mobile update belongs to another app.");
@@ -206,49 +232,172 @@ var requireCompatible = (manifest, config) => {
   if (manifest.runtimeFingerprint !== config.runtimeFingerprint)
     throw new TypeError("Mobile update requires a different native runtime.");
 };
+var networkConcurrency = (requested) => {
+  const bounded = Math.max(1, Math.min(6, Math.floor(requested ?? 3)));
+  const navigatorValue = Reflect.get(globalThis, "navigator");
+  const connection = typeof navigatorValue === "object" && navigatorValue !== null ? Reflect.get(navigatorValue, "connection") : undefined;
+  if (typeof connection !== "object" || connection === null)
+    return bounded;
+  if (Reflect.get(connection, "saveData") === true)
+    return 1;
+  const effectiveType = Reflect.get(connection, "effectiveType");
+  if (effectiveType === "slow-2g" || effectiveType === "2g")
+    return 1;
+  if (effectiveType === "3g")
+    return Math.min(2, bounded);
+  return bounded;
+};
+var combine = (prefix, suffix) => {
+  const result = new Uint8Array(prefix.byteLength + suffix.byteLength);
+  result.set(prefix);
+  result.set(suffix, prefix.byteLength);
+  return result;
+};
+var validContentRange = (value, start, total) => value === `bytes ${start}-${total - 1}/${total}`;
+var combineSignals = (signals) => {
+  const nativeAny = Reflect.get(AbortSignal, "any");
+  if (typeof nativeAny === "function")
+    return Reflect.apply(nativeAny, AbortSignal, [signals]);
+  const controller = new AbortController;
+  const abort = () => controller.abort();
+  if (signals.some((signal) => signal.aborted))
+    abort();
+  else
+    signals.forEach((signal) => signal.addEventListener("abort", abort, { once: true }));
+  return controller.signal;
+};
 var createAbsoluteMobileUpdateClient = (options) => {
   const manifestUrl = exactManifestUrl(options.config.manifestUrl);
   const request = options.fetch ?? globalThis.fetch;
-  const downloadFiles = async (manifest, index = 0, transfer = {
-    downloadedBytes: 0,
-    downloadedFiles: 0,
-    reusedBytes: 0,
-    reusedFiles: 0,
-    totalBytes: manifest.files.reduce((total, file) => total + file.bytes, 0),
-    totalFiles: manifest.files.length
-  }) => {
-    const file = manifest.files[index];
-    if (!file)
-      return transfer;
-    const reusable = await options.store.readReusable?.(file);
-    if (reusable && reusable.byteLength === file.bytes && await options.verifier.digest(reusable) === file.sha256) {
-      await options.store.write(file, reusable);
-      return downloadFiles(manifest, index + 1, {
-        ...transfer,
-        reusedBytes: transfer.reusedBytes + reusable.byteLength,
-        reusedFiles: transfer.reusedFiles + 1
+  const downloadFiles = async (manifest) => {
+    const startedAt = performance.now();
+    const transfer = {
+      avoidedBytes: 0,
+      completedFiles: 0,
+      downloadedBytes: 0,
+      downloadedFiles: 0,
+      durationMs: 0,
+      resumedBytes: 0,
+      resumedFiles: 0,
+      reusedBytes: 0,
+      reusedFiles: 0,
+      throughputBytesPerSecond: 0,
+      totalBytes: manifest.files.reduce((total, file) => total + file.bytes, 0),
+      totalFiles: manifest.files.length
+    };
+    const updateTiming = () => {
+      transfer.durationMs = Math.max(0, performance.now() - startedAt);
+      transfer.avoidedBytes = transfer.reusedBytes + transfer.resumedBytes;
+      transfer.throughputBytesPerSecond = transfer.durationMs > 0 ? Math.round(transfer.downloadedBytes * 1000 / transfer.durationMs) : transfer.downloadedBytes;
+    };
+    const progress = () => {
+      updateTiming();
+      try {
+        options.onProgress?.({
+          ...transfer,
+          kind: "download-progress"
+        });
+      } catch {}
+    };
+    const controller = new AbortController;
+    let next = 0;
+    let firstError;
+    const downloadFile = async (file) => {
+      const staged = await options.store.readStaged?.(file);
+      if (staged?.byteLength === file.bytes && await options.verifier.digest(staged) === file.sha256) {
+        transfer.resumedBytes += staged.byteLength;
+        transfer.resumedFiles += 1;
+        transfer.completedFiles += 1;
+        progress();
+        return;
+      }
+      const reusable = await options.store.readReusable?.(file);
+      if (reusable?.byteLength === file.bytes && await options.verifier.digest(reusable) === file.sha256) {
+        await options.store.write(file, reusable);
+        transfer.reusedBytes += reusable.byteLength;
+        transfer.reusedFiles += 1;
+        transfer.completedFiles += 1;
+        progress();
+        return;
+      }
+      const candidate = await options.store.readPartial?.(file);
+      if (candidate?.byteLength === file.bytes && await options.verifier.digest(candidate) === file.sha256) {
+        await options.store.write(file, candidate);
+        transfer.resumedBytes += candidate.byteLength;
+        transfer.resumedFiles += 1;
+        transfer.completedFiles += 1;
+        progress();
+        return;
+      }
+      const partial = candidate && candidate.byteLength > 0 && candidate.byteLength < file.bytes ? candidate : new Uint8Array;
+      const headers = new Headers;
+      if (partial.byteLength > 0) {
+        headers.set("if-range", `"${file.sha256}"`);
+        headers.set("range", `bytes=${partial.byteLength}-`);
+      }
+      const asset = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
+        cache: "no-store",
+        credentials: "omit",
+        headers,
+        redirect: "error",
+        signal: combineSignals([
+          controller.signal,
+          AbortSignal.timeout(30000)
+        ])
       });
-    }
-    const asset = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
-      cache: "no-store",
-      credentials: "omit",
-      redirect: "error",
-      signal: AbortSignal.timeout(30000)
-    });
-    if (!asset.ok)
-      throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset.status}.`);
-    const contents = await readBounded(asset, file.bytes);
-    const downloadedBytes = transfer.downloadedBytes + contents.byteLength;
-    if (contents.byteLength !== file.bytes || downloadedBytes > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
-      throw new TypeError(`Mobile update asset ${file.path} has an invalid size.`);
-    if (await options.verifier.digest(contents) !== file.sha256)
-      throw new TypeError(`Mobile update asset ${file.path} failed integrity verification.`);
-    await options.store.write(file, contents);
-    return downloadFiles(manifest, index + 1, {
-      ...transfer,
-      downloadedBytes,
-      downloadedFiles: transfer.downloadedFiles + 1
-    });
+      if (!asset.ok)
+        throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset.status}.`);
+      const ranged = asset.status === 206;
+      if (ranged && (partial.byteLength === 0 || !validContentRange(asset.headers.get("content-range"), partial.byteLength, file.bytes)))
+        throw new TypeError(`Mobile update asset ${file.path} returned an invalid byte range.`);
+      const prefix = ranged ? partial : new Uint8Array;
+      if (ranged) {
+        transfer.resumedBytes += partial.byteLength;
+        transfer.resumedFiles += 1;
+      }
+      const downloaded = await readBounded(asset, file.bytes - prefix.byteLength, options.store.appendPartial ? async (chunk, offset) => {
+        await options.store.appendPartial?.(file, chunk, prefix.byteLength + offset);
+        transfer.downloadedBytes += chunk.byteLength;
+        progress();
+      } : undefined);
+      if (!options.store.appendPartial) {
+        transfer.downloadedBytes += downloaded.byteLength;
+        progress();
+      }
+      if (transfer.downloadedBytes > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
+        throw new TypeError("Mobile update exceeds the maximum transfer size.");
+      const contents = combine(prefix, downloaded);
+      if (contents.byteLength !== file.bytes)
+        throw new TypeError(`Mobile update asset ${file.path} has an invalid size.`);
+      if (await options.verifier.digest(contents) !== file.sha256)
+        throw new TypeError(`Mobile update asset ${file.path} failed integrity verification.`);
+      await options.store.write(file, contents);
+      transfer.downloadedFiles += 1;
+      transfer.completedFiles += 1;
+      progress();
+    };
+    const worker = async () => {
+      if (firstError)
+        return;
+      const index = next++;
+      const file = manifest.files[index];
+      if (!file)
+        return;
+      try {
+        await downloadFile(file);
+      } catch (error) {
+        firstError ??= error;
+        controller.abort();
+      }
+      await worker();
+    };
+    await Promise.all(Array.from({
+      length: Math.min(networkConcurrency(options.concurrency), manifest.files.length)
+    }, () => worker()));
+    if (firstError)
+      throw firstError;
+    updateTiming();
+    return transfer;
   };
   const check = async (download = false) => {
     const response = await request(manifestUrl, {
@@ -270,39 +419,67 @@ var createAbsoluteMobileUpdateClient = (options) => {
       throw new TypeError("Mobile update manifest is not valid JSON.");
     }
     const manifest = parseAbsoluteMobileUpdateManifest(manifestValue);
+    const healthToken = response.headers.get("x-absolute-mobile-health-token");
     requireCompatible(manifest, options.config);
     if (!await options.verifier.verify(manifest))
       throw new TypeError("Mobile update signature verification failed.");
     if (manifest.releaseId === options.config.currentReleaseId)
       return { kind: "current" };
     if (options.config.blockedReleaseIds?.includes(manifest.releaseId))
-      return { kind: "quarantined", releaseId: manifest.releaseId };
+      return {
+        ...healthToken ? { healthToken } : {},
+        kind: "quarantined",
+        releaseId: manifest.releaseId
+      };
     if (!download)
-      return { kind: "update-available", manifest };
+      return {
+        ...healthToken ? { healthToken } : {},
+        kind: "update-available",
+        manifest
+      };
     await options.store.begin(manifest);
     let transfer;
     try {
       transfer = await downloadFiles(manifest);
       await options.store.commit(manifest);
     } catch (error) {
-      await options.store.abort(manifest.releaseId);
+      if (options.store.suspend)
+        await options.store.suspend(manifest.releaseId);
+      else
+        await options.store.abort(manifest.releaseId);
+      if (healthToken)
+        reportAbsoluteMobileUpdateHealth(options.config, {
+          healthToken,
+          kind: "download-failed",
+          releaseId: manifest.releaseId
+        }, request).catch(() => {
+          return;
+        });
       throw error;
     }
-    return { kind: "downloaded", manifest, transfer };
+    return {
+      ...healthToken ? { healthToken } : {},
+      kind: "downloaded",
+      manifest,
+      transfer
+    };
   };
   return {
     check,
     activate: (releaseId) => options.store.activate(releaseId),
-    download: () => check(true)
+    download: () => check(true),
+    report: (input) => reportAbsoluteMobileUpdateHealth(options.config, input, request)
   };
 };
 
 // src/mobile/shellUpdate.ts
 var STATE_KEY = "absolute.mobile.update.state.v1";
+var STAGING_KEY = "absolute.mobile.update.staging.v1";
 var INSTALLATION_KEY = "absolute.mobile.update.installation.v1";
 var RESULT_KEY = Symbol.for("absolutejs.mobile.update.result");
 var RESULTS_KEY = Symbol.for("absolutejs.mobile.update.results");
 var ROOT = "NoCloud/ionic_built_snapshots";
+var STAGING_ROOT = "NoCloud/absolute_update_staging";
 var watchdog = registerPlugin("AbsoluteMobileUpdateWatchdog");
 var base64Bytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
 var arrayBuffer = (value) => new Uint8Array(value).buffer;
@@ -348,12 +525,15 @@ var readState = async () => {
         releaseId: recovery.releaseId
       };
     return {
+      ...text("activeHealthToken") ? { activeHealthToken: text("activeHealthToken") } : {},
       ...text("activeRelease") ? { activeRelease: text("activeRelease") } : {},
       ...text("pendingRelease") ? { pendingRelease: text("pendingRelease") } : {},
+      ...text("pendingHealthToken") ? { pendingHealthToken: text("pendingHealthToken") } : {},
       ...number("pendingStartedAt") === undefined ? {} : { pendingStartedAt: number("pendingStartedAt") },
       ...text("previousPath") ? { previousPath: text("previousPath") } : {},
       ...quarantinedReleases.length > 0 ? { quarantinedReleases } : {},
       ...text("readyRelease") ? { readyRelease: text("readyRelease") } : {},
+      ...text("readyHealthToken") ? { readyHealthToken: text("readyHealthToken") } : {},
       ...validRecovery ? { recovery: validRecovery } : {}
     };
   } catch {
@@ -361,6 +541,25 @@ var readState = async () => {
   }
 };
 var writeState = (state) => Preferences.set({ key: STATE_KEY, value: JSON.stringify(state) });
+var clearStagingRoot = () => Filesystem.rmdir({
+  directory: Directory.Library,
+  path: STAGING_ROOT,
+  recursive: true
+}).catch(() => {
+  return;
+});
+var readStaging = async () => {
+  const { value } = await Preferences.get({ key: STAGING_KEY });
+  if (!value)
+    return;
+  try {
+    return parseAbsoluteMobileUpdateManifest(JSON.parse(value));
+  } catch {
+    await Preferences.remove({ key: STAGING_KEY });
+    await clearStagingRoot();
+    return;
+  }
+};
 var installationId = async () => {
   const existing = await Preferences.get({ key: INSTALLATION_KEY });
   if (existing.value && /^[a-f0-9-]{36}$/u.test(existing.value))
@@ -379,6 +578,7 @@ var webView = () => {
 };
 var currentServerBasePath = () => new Promise((resolve) => webView().getServerBasePath(resolve));
 var releasePath = (releaseId) => `${ROOT}/${releaseId}`;
+var partialPath = (releaseId, file) => `${STAGING_ROOT}/${releaseId}/${file.path}.part`;
 var releaseNativePath = async (releaseId) => {
   const { uri } = await Filesystem.getUri({
     directory: Directory.Library,
@@ -396,6 +596,15 @@ var removeRelease = async (releaseId) => {
     return;
   });
 };
+var removeStaging = async (releaseId) => {
+  await Filesystem.rmdir({
+    directory: Directory.Library,
+    path: `${STAGING_ROOT}/${releaseId}`,
+    recursive: true
+  }).catch(() => {
+    return;
+  });
+};
 var filesystemBytes = async (data) => typeof data === "string" ? base64Bytes(data) : new Uint8Array(await data.arrayBuffer());
 var createStore = () => {
   let staging;
@@ -403,9 +612,14 @@ var createStore = () => {
     abort: async (releaseId) => {
       staging = undefined;
       await removeRelease(releaseId);
+      await removeStaging(releaseId);
+      const persisted = await readStaging();
+      if (persisted?.releaseId === releaseId)
+        await Preferences.remove({ key: STAGING_KEY });
       const state = await readState();
       if (state.readyRelease === releaseId || state.pendingRelease === releaseId)
         await writeState({
+          activeHealthToken: state.activeHealthToken,
           activeRelease: state.activeRelease,
           quarantinedReleases: state.quarantinedReleases,
           recovery: state.recovery
@@ -418,7 +632,9 @@ var createStore = () => {
       const path = await releaseNativePath(releaseId);
       const previousPath = await currentServerBasePath();
       await writeState({
+        activeHealthToken: state.activeHealthToken,
         activeRelease: state.activeRelease,
+        pendingHealthToken: state.readyHealthToken,
         pendingRelease: releaseId,
         pendingStartedAt: Date.now(),
         previousPath,
@@ -433,19 +649,59 @@ var createStore = () => {
         });
         await removeRelease(releaseId);
         await writeState({
+          activeHealthToken: state.activeHealthToken,
           activeRelease: state.activeRelease,
           quarantinedReleases: state.quarantinedReleases
         });
         throw error;
       }
     },
+    appendPartial: async (file, contents, offset) => {
+      if (!staging || !staging.files.some((candidate) => candidate.path === file.path))
+        throw new TypeError("Mobile update partial write is outside its staging transaction.");
+      const path = partialPath(staging.releaseId, file);
+      if (offset === 0) {
+        await Filesystem.writeFile({
+          data: bytesBase64(contents),
+          directory: Directory.Library,
+          path,
+          recursive: true
+        });
+        return;
+      }
+      const stat = await Filesystem.stat({
+        directory: Directory.Library,
+        path
+      });
+      if (stat.size !== offset)
+        throw new TypeError("Mobile update partial checkpoint changed unexpectedly.");
+      await Filesystem.appendFile({
+        data: bytesBase64(contents),
+        directory: Directory.Library,
+        path
+      });
+    },
     begin: async (manifest) => {
-      await removeRelease(manifest.releaseId);
+      const persisted = await readStaging();
+      const resume = persisted?.releaseId === manifest.releaseId && persisted.signature.keyId === manifest.signature.keyId && persisted.signature.value === manifest.signature.value;
+      if (persisted && !resume)
+        await Promise.all([
+          removeRelease(persisted.releaseId),
+          removeStaging(persisted.releaseId)
+        ]);
+      if (!resume) {
+        await removeRelease(manifest.releaseId);
+        await removeStaging(manifest.releaseId);
+      }
       await Filesystem.mkdir({
         directory: Directory.Library,
         path: releasePath(manifest.releaseId),
         recursive: true
       });
+      await Preferences.set({
+        key: STAGING_KEY,
+        value: JSON.stringify(manifest)
+      });
       staging = manifest;
     },
     commit: async (manifest) => {
@@ -453,12 +709,24 @@ var createStore = () => {
         throw new TypeError("Mobile update staging transaction changed identity.");
       const state = await readState();
       await writeState({
+        activeHealthToken: state.activeHealthToken,
         activeRelease: state.activeRelease,
         quarantinedReleases: state.quarantinedReleases,
         readyRelease: manifest.releaseId
       });
+      await removeStaging(manifest.releaseId);
+      await Preferences.remove({ key: STAGING_KEY });
       staging = undefined;
     },
+    readPartial: async (file) => {
+      if (!staging)
+        return null;
+      const result = await Filesystem.readFile({
+        directory: Directory.Library,
+        path: partialPath(staging.releaseId, file)
+      }).catch(() => null);
+      return result ? filesystemBytes(result.data).catch(() => null) : null;
+    },
     readReusable: async (file) => {
       const state = await readState();
       if (!state.activeRelease)
@@ -469,6 +737,19 @@ var createStore = () => {
       }).catch(() => null);
       return result ? filesystemBytes(result.data).catch(() => null) : null;
     },
+    readStaged: async (file) => {
+      if (!staging)
+        return null;
+      const result = await Filesystem.readFile({
+        directory: Directory.Library,
+        path: `${releasePath(staging.releaseId)}/${file.path}`
+      }).catch(() => null);
+      return result ? filesystemBytes(result.data).catch(() => null) : null;
+    },
+    suspend: async (releaseId) => {
+      if (staging?.releaseId === releaseId)
+        staging = undefined;
+    },
     write: async (file, contents) => {
       if (!staging || !staging.files.some((candidate) => candidate.path === file.path))
         throw new TypeError("Mobile update write is outside its staging transaction.");
@@ -512,29 +793,56 @@ var removePriorRelease = async (prior, active) => {
   if (prior && prior !== active)
     await removeRelease(prior);
 };
-var reconcilePendingRelease = async (store, state) => {
+var reconcilePendingRelease = async (store, state, report) => {
   if (!state.pendingRelease)
     return state;
   const pendingPath = await releaseNativePath(state.pendingRelease);
   const currentPath = await currentServerBasePath();
   if (currentPath !== pendingPath) {
     const failed = state.pendingRelease;
+    if (state.pendingHealthToken)
+      report({
+        healthToken: state.pendingHealthToken,
+        kind: "rolled-back",
+        releaseId: failed
+      });
     await store.abort(failed);
     emitUpdateResult({ kind: "rolled-back", releaseId: failed });
     return readState();
   }
   webView().persistServerBasePath();
-  const next = { activeRelease: state.pendingRelease };
+  const next = {
+    activeHealthToken: state.pendingHealthToken,
+    activeRelease: state.pendingRelease
+  };
   await writeState(next);
   await watchdog.confirm({ releaseId: state.pendingRelease });
+  if (state.pendingHealthToken)
+    report({
+      healthToken: state.pendingHealthToken,
+      kind: "activated",
+      releaseId: state.pendingRelease
+    });
   await removePriorRelease(state.activeRelease, next.activeRelease);
   emitUpdateResult({ kind: "activated", releaseId: next.activeRelease });
   return next;
 };
-var consumeNativeRecovery = async (state) => {
+var consumeNativeRecovery = async (state, report) => {
   if (!state.recovery)
     return state;
-  const { recovery, ...next } = state;
+  const {
+    pendingHealthToken,
+    readyHealthToken: _readyHealthToken,
+    recovery,
+    ...next
+  } = state;
+  if (pendingHealthToken)
+    report({
+      healthToken: pendingHealthToken,
+      kind: "rolled-back",
+      reason: recovery.reason,
+      releaseId: recovery.releaseId
+    });
   emitUpdateResult({
     durationMs: Math.round(recovery.durationMs),
     kind: "rolled-back",
@@ -545,34 +853,66 @@ var consumeNativeRecovery = async (state) => {
   return next;
 };
 var installAbsoluteMobileShellUpdates = async (manifest) => {
-  if (!manifest.updates)
+  const { updates } = manifest;
+  if (!updates)
     return;
   const store = createStore();
-  const recovered = await consumeNativeRecovery(await readState());
-  const state = await reconcilePendingRelease(store, recovered);
+  const identity = await installationId();
+  const clientConfig = (state2) => ({
+    appId: manifest.appId,
+    blockedReleaseIds: state2.quarantinedReleases ?? [],
+    channel: updates.channel,
+    currentReleaseId: state2.activeRelease ?? `embedded:${manifest.appBuild}`,
+    installationId: identity,
+    manifestUrl: updates.manifestUrl,
+    runtimeFingerprint: manifest.nativeRuntime
+  });
+  const reportFor = (state2) => async (evidence) => {
+    await reportAbsoluteMobileUpdateHealth(clientConfig(state2), evidence).catch(() => {
+      return;
+    });
+  };
+  const initial = await readState();
+  const recovered = await consumeNativeRecovery(initial, reportFor(initial));
+  const state = await reconcilePendingRelease(store, recovered, reportFor(recovered));
   const client = createAbsoluteMobileUpdateClient({
-    config: {
-      appId: manifest.appId,
-      blockedReleaseIds: state.quarantinedReleases ?? [],
-      channel: manifest.updates.channel,
-      currentReleaseId: state.activeRelease ?? `embedded:${manifest.appBuild}`,
-      installationId: await installationId(),
-      manifestUrl: manifest.updates.manifestUrl,
-      runtimeFingerprint: manifest.nativeRuntime
-    },
+    config: clientConfig(state),
     store,
-    verifier: createVerifier(manifest.updates.publicKeys)
+    verifier: createVerifier(updates.publicKeys),
+    onProgress: (progress) => emitUpdateResult(progress)
   });
   const activateDownloaded = async (result) => {
     if (result.kind !== "downloaded")
       return;
+    if (result.healthToken) {
+      const ready = await readState();
+      if (ready.readyRelease === result.manifest.releaseId)
+        await writeState({
+          ...ready,
+          readyHealthToken: result.healthToken
+        });
+      client.report({
+        healthToken: result.healthToken,
+        kind: "downloaded",
+        releaseId: result.manifest.releaseId,
+        transfer: result.transfer
+      }).catch(() => {
+        return;
+      });
+    }
     emitUpdateResult({
+      avoidedBytes: result.transfer.avoidedBytes,
+      completedFiles: result.transfer.completedFiles,
       downloadedBytes: result.transfer.downloadedBytes,
       downloadedFiles: result.transfer.downloadedFiles,
+      durationMs: Math.round(result.transfer.durationMs),
       kind: "downloaded",
       releaseId: result.manifest.releaseId,
+      resumedBytes: result.transfer.resumedBytes,
+      resumedFiles: result.transfer.resumedFiles,
       reusedBytes: result.transfer.reusedBytes,
       reusedFiles: result.transfer.reusedFiles,
+      throughputBytesPerSecond: result.transfer.throughputBytesPerSecond,
       totalBytes: result.transfer.totalBytes,
       totalFiles: result.transfer.totalFiles
     });
@@ -580,6 +920,14 @@ var installAbsoluteMobileShellUpdates = async (manifest) => {
   };
   client.download().then((result) => {
     if (result.kind === "quarantined") {
+      if (result.healthToken)
+        client.report({
+          healthToken: result.healthToken,
+          kind: "quarantined",
+          releaseId: result.releaseId
+        }).catch(() => {
+          return;
+        });
       emitUpdateResult({
         kind: "quarantined",
         releaseId: result.releaseId