@absolutejs/absolute 0.20.0-beta.83 → 0.20.0-beta.85

package/dist/mobile/index.js

@@ -20137,6 +20137,7 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
   const releaseRoot = (manifest) => `${root(manifest.appId)}/releases/${manifest.releaseId}`;
   const manifestKey = (manifest) => `${releaseRoot(manifest)}/update.json`;
   const fileKey = (manifest, file) => `${releaseRoot(manifest)}/files/${file.path}`;
+  const contentBlobKey = (appId, sha2563) => `${root(appId)}/blobs/${sha2563}`;
   const tombstoneKey = (appId, releaseId) => `${root(appId)}/gc/${releaseId}.json`;
   const channelKey = (appId, channel) => {
     if (!APP_ID.test(appId) || !NAME.test(channel))
@@ -20283,9 +20284,19 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
     const releasePrefix = `${appRoot}releases/`;
     const channelPrefix = `${appRoot}channels/`;
     const markerPrefix = `${appRoot}gc/`;
+    const blobPrefix = `${appRoot}blobs/`;
     const objectKeysByRelease = new Map;
     const objectBytesByRelease = new Map;
+    const objectKeysByDigest = new Map;
+    const objectBytesByDigest = new Map;
     for (const blobObject of objects) {
+      if (blobObject.key.startsWith(blobPrefix)) {
+        const sha2563 = blobObject.key.slice(blobPrefix.length);
+        if (HASH.test(sha2563)) {
+          objectKeysByDigest.set(sha2563, blobObject.key);
+          objectBytesByDigest.set(sha2563, blobObject.size);
+        }
+      }
       if (!blobObject.key.startsWith(releasePrefix))
         continue;
       const suffix = blobObject.key.slice(releasePrefix.length);
@@ -20364,20 +20375,28 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
         releaseId: manifest.releaseId
       };
     }).toSorted((left, right) => right.createdAt.localeCompare(left.createdAt));
+    const protectedReleaseIds = new Set(releases.filter((release) => release.protectedBy.length > 0).map((release) => release.releaseId));
+    const protectedDigests = new Set(manifests.filter((manifest) => protectedReleaseIds.has(manifest.releaseId)).flatMap((manifest) => manifest.files.map((file) => file.sha256)));
+    const reclaimableContentBytes = [...objectBytesByDigest].filter(([sha2563]) => !protectedDigests.has(sha2563)).reduce((total, [, bytes]) => total + bytes, 0);
+    const contentBlobBytes = [...objectBytesByDigest.values()].reduce((total, bytes) => total + bytes, 0);
     const releaseBytes = releases.reduce((total, release) => total + release.bytes, 0);
     const totalBytes = objects.reduce((total, object22) => total + object22.size, 0);
     return {
       objectKeysByRelease,
+      objectKeysByDigest,
       report: {
         appId: input.appId,
         channelCount: channels.length,
-        reclaimableBytes: releases.filter((release) => release.protectedBy.length === 0).reduce((total, release) => total + release.bytes, 0),
+        contentBlobBytes,
+        contentBlobCount: objectKeysByDigest.size,
+        reclaimableBytes: releases.filter((release) => release.protectedBy.length === 0).reduce((total, release) => total + release.bytes, 0) + reclaimableContentBytes,
+        reclaimableContentBytes,
         releaseBytes,
         releaseCount: releases.length,
         releases,
         totalBytes,
         totalObjectCount: objects.length,
-        untrackedBytes: totalBytes - releaseBytes
+        untrackedBytes: totalBytes - releaseBytes - contentBlobBytes
       }
     };
   };
@@ -20389,7 +20408,8 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       marked: [],
       reclaimedBytes: 0,
       restored: [],
-      swept: []
+      swept: [],
+      sweptContentBlobs: []
     };
     if (input.apply !== true)
       return result;
@@ -20447,6 +20467,21 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       result.reclaimedBytes += candidate.bytes;
       result.swept.push(release.releaseId);
     }
+    const afterReleaseSweep = await inventory(input);
+    const referencedDigests = new Set;
+    for (const release of afterReleaseSweep.report.releases) {
+      const manifest = await readManifest(input.appId, release.releaseId);
+      for (const file of manifest?.manifest.files ?? [])
+        referencedDigests.add(file.sha256);
+    }
+    for (const [sha2563, key] of afterReleaseSweep.objectKeysByDigest) {
+      if (referencedDigests.has(sha2563))
+        continue;
+      const head = await options.store.head(key);
+      await remove(key);
+      result.reclaimedBytes += head?.size ?? 0;
+      result.sweptContentBlobs.push(sha2563);
+    }
     return result;
   };
   return {
@@ -20463,8 +20498,16 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
         throw new MobileUpdateRegistryError("Local mobile update manifest changed");
       const existing = await readManifest(manifest.appId, manifest.releaseId);
       let reused = existing !== null;
+      let storedBytes = 0;
+      let storedFiles = 0;
+      let reusedBytes = 0;
+      let reusedFiles = 0;
       if (existing && JSON.stringify(existing.manifest) !== JSON.stringify(manifest))
         throw new MobileUpdateRegistryError("Published mobile update is immutable");
+      if (existing) {
+        reusedBytes = manifest.files.reduce((total, file) => total + file.bytes, 0);
+        reusedFiles = manifest.files.length;
+      }
       if (!existing) {
         for (const file of manifest.files) {
           const local = path.join(localRoot, "files", file.path);
@@ -20473,18 +20516,24 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
             throw new MobileUpdateRegistryError(`Mobile update file ${file.path} size changed`);
           if (await fileDigest(Bun.file(local)) !== file.sha256)
             throw new MobileUpdateRegistryError(`Mobile update file ${file.path} integrity failed`);
-          const key = fileKey(manifest, file);
+          const key = contentBlobKey(manifest.appId, file.sha256);
           const stored = await options.store.head(key);
           if (!stored) {
             await options.store.put(key, Bun.file(local).stream(), {
               cacheControl: "public, max-age=31536000, immutable",
               contentType: "application/octet-stream",
               maxBytes: file.bytes,
-              metadata: { releaseid: manifest.releaseId, sha256: file.sha256 },
+              metadata: { sha256: file.sha256 },
               signal: input.signal
             });
-          } else if (stored.size !== file.bytes || stored.metadata?.sha256 !== file.sha256 || (stored.metadata?.releaseid ?? stored.metadata?.releaseId) !== manifest.releaseId)
-            throw new MobileUpdateRegistryError("Stored mobile update file identity changed");
+            storedBytes += file.bytes;
+            storedFiles += 1;
+          } else if (stored.size !== file.bytes || stored.metadata?.sha256 !== file.sha256)
+            throw new MobileUpdateRegistryError("Stored mobile update content identity changed");
+          else {
+            reusedBytes += file.bytes;
+            reusedFiles += 1;
+          }
         }
         const bytes = json(manifest);
         await options.store.put(manifestKey(manifest), bytes, {
@@ -20508,8 +20557,12 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       return {
         appId: manifest.appId,
         channel: manifest.channel,
+        storedBytes,
+        storedFiles,
         releaseId: manifest.releaseId,
         reused,
+        reusedBytes,
+        reusedFiles,
         rollout: input.rollout,
         stage: "published"
       };
@@ -20558,14 +20611,16 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       const file = release.manifest.files.find((candidate) => candidate.path === requested);
       if (!file)
         return null;
-      const key = fileKey(release.manifest, file);
+      const legacyKey = fileKey(release.manifest, file);
+      const legacyHead = await options.store.head(legacyKey);
+      const key = legacyHead ? legacyKey : contentBlobKey(release.manifest.appId, file.sha256);
       const [bytes, head] = await Promise.all([
         options.store.get(key),
-        options.store.head(key)
+        legacyHead ? Promise.resolve(legacyHead) : options.store.head(key)
       ]);
       if (!bytes || !head)
         return null;
-      if (bytes.byteLength !== file.bytes || head.size !== file.bytes || head.metadata?.sha256 !== file.sha256 || (head.metadata?.releaseid ?? head.metadata?.releaseId) !== release.manifest.releaseId || digest(bytes) !== file.sha256)
+      if (bytes.byteLength !== file.bytes || head.size !== file.bytes || head.metadata?.sha256 !== file.sha256 || legacyHead && (head.metadata?.releaseid ?? head.metadata?.releaseId) !== release.manifest.releaseId || digest(bytes) !== file.sha256)
         throw new MobileUpdateRegistryError("Stored mobile update file integrity failed");
       return { bytes, file };
     }
@@ -20705,14 +20760,18 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
   const expoCodeSigning = resolveExpoCodeSigning(options.expoCodeSigning);
   return async (request) => {
     const origin = request.headers.get("origin");
-    const cors = origin && allowedOrigins.has(origin) ? { "access-control-allow-origin": origin, vary: "Origin" } : {};
+    const cors = origin && allowedOrigins.has(origin) ? {
+      "access-control-allow-origin": origin,
+      "access-control-expose-headers": "content-range,etag",
+      vary: "Origin"
+    } : {};
     if (request.method === "OPTIONS") {
       if (!origin || !allowedOrigins.has(origin))
         return new Response(null, { status: 403 });
       return new Response(null, {
         headers: {
           ...cors,
-          "access-control-allow-headers": "x-absolute-mobile-app,x-absolute-mobile-channel,x-absolute-mobile-installation,x-absolute-mobile-release,x-absolute-mobile-runtime",
+          "access-control-allow-headers": "if-range,range,x-absolute-mobile-app,x-absolute-mobile-channel,x-absolute-mobile-installation,x-absolute-mobile-release,x-absolute-mobile-runtime",
           "access-control-allow-methods": "GET,OPTIONS",
           "access-control-max-age": "600"
         },
@@ -20840,14 +20899,42 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
     });
     if (!file)
       return new Response(null, { status: 404 });
-    return new Response(new Blob([new Uint8Array(file.bytes).buffer]), {
+    const etag = `"${file.file.sha256}"`;
+    const range = request.headers.get("range");
+    const useRange = range !== null && (!request.headers.has("if-range") || request.headers.get("if-range") === etag);
+    let contents = file.bytes;
+    let status = 200;
+    let contentRange;
+    if (useRange) {
+      const parsed = /^bytes=(\d+)-(\d*)$/.exec(range);
+      const start = parsed?.[1] === undefined ? NaN : Number(parsed[1]);
+      const requestedEnd = parsed?.[2] === undefined || parsed[2] === "" ? file.bytes.byteLength - 1 : Number(parsed[2]);
+      if (!Number.isSafeInteger(start) || !Number.isSafeInteger(requestedEnd) || start < 0 || start >= file.bytes.byteLength || requestedEnd < start)
+        return new Response(null, {
+          headers: {
+            ...cors,
+            "accept-ranges": "bytes",
+            "content-range": `bytes */${file.bytes.byteLength}`,
+            etag
+          },
+          status: 416
+        });
+      const end = Math.min(requestedEnd, file.bytes.byteLength - 1);
+      contents = file.bytes.slice(start, end + 1);
+      status = 206;
+      contentRange = `bytes ${start}-${end}/${file.bytes.byteLength}`;
+    }
+    return new Response(new Blob([new Uint8Array(contents).buffer]), {
       headers: {
         ...cors,
+        "accept-ranges": "bytes",
         "cache-control": "public, max-age=31536000, immutable",
-        "content-length": String(file.file.bytes),
+        "content-length": String(contents.byteLength),
+        ...contentRange ? { "content-range": contentRange } : {},
         "content-type": expoContentType(file.file.path.includes(".") ? file.file.path.slice(file.file.path.lastIndexOf(".") + 1) : undefined, false),
-        etag: `"${file.file.sha256}"`
-      }
+        etag
+      },
+      status
     });
   };
 };
@@ -38650,17 +38737,18 @@ var fileUrl = (manifestUrl, releaseId, path) => {
     throw new TypeError("Mobile update asset escaped its signed release origin.");
   return result;
 };
-var readChunks = async (reader, maximum2, chunks = [], received = 0) => {
+var readChunks = async (reader, maximum2, onChunk, chunks = [], received = 0) => {
   const result = await reader.read();
   if (result.done)
     return { chunks, received };
   const total = received + result.value.byteLength;
   if (total > maximum2)
     throw new TypeError("Mobile update response exceeds its signed size.");
+  await onChunk?.(result.value, received);
   chunks.push(result.value);
-  return readChunks(reader, maximum2, chunks, total);
+  return readChunks(reader, maximum2, onChunk, chunks, total);
 };
-var readBounded = async (response, maximum2) => {
+var readBounded = async (response, maximum2, onChunk) => {
   const declared = Number(response.headers.get("content-length"));
   if (Number.isFinite(declared) && declared > maximum2)
     throw new TypeError("Mobile update response exceeds its signed size.");
@@ -38668,8 +38756,9 @@ var readBounded = async (response, maximum2) => {
     return new Uint8Array;
   const reader = response.body.getReader();
   let result;
+  const chunks = [];
   try {
-    result = await readChunks(reader, maximum2);
+    result = await readChunks(reader, maximum2, onChunk, chunks);
   } catch (error) {
     await reader.cancel().catch(() => {
       return;
@@ -38678,7 +38767,7 @@ var readBounded = async (response, maximum2) => {
   }
   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;
   }
@@ -38699,29 +38788,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, received = 0) => {
-    const file = manifest.files[index];
-    if (!file)
-      return received;
-    const asset2 = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
-      cache: "no-store",
-      credentials: "omit",
-      redirect: "error",
-      signal: AbortSignal.timeout(30000)
-    });
-    if (!asset2.ok)
-      throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset2.status}.`);
-    const contents = await readBounded(asset2, file.bytes);
-    const total = received + contents.byteLength;
-    if (contents.byteLength !== file.bytes || total > 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, total);
+  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 asset2 = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
+        cache: "no-store",
+        credentials: "omit",
+        headers,
+        redirect: "error",
+        signal: combineSignals([
+          controller.signal,
+          AbortSignal.timeout(30000)
+        ])
+      });
+      if (!asset2.ok)
+        throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset2.status}.`);
+      const ranged = asset2.status === 206;
+      if (ranged && (partial.byteLength === 0 || !validContentRange(asset2.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(asset2, 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, {
@@ -38753,14 +38985,18 @@ var createAbsoluteMobileUpdateClient = (options) => {
     if (!download)
       return { kind: "update-available", manifest };
     await options.store.begin(manifest);
+    let transfer;
     try {
-      await downloadFiles(manifest);
+      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);
       throw error;
     }
-    return { kind: "downloaded", manifest };
+    return { kind: "downloaded", manifest, transfer };
   };
   return {
     check,
@@ -38888,6 +39124,7 @@ var lifecycleMethod = (publisher, name) => {
     throw new TypeError(`Mobile update registry does not support ${name}. Re-run \`absolute mobile update provision --force\` after upgrading @absolutejs/deploy.`);
   return method;
 };
+var validOptionalCounters = (values) => values.every((value) => value === undefined) || values.every((value) => Number.isSafeInteger(value) && (value ?? -1) >= 0);
 var validateStorageIdentity = (result, appId) => {
   if (!object5(result) || result.appId !== appId || !Array.isArray(result.releases) || ![
     result.channelCount,
@@ -38897,7 +39134,11 @@ var validateStorageIdentity = (result, appId) => {
     result.totalBytes,
     result.totalObjectCount,
     result.untrackedBytes
-  ].every((value) => Number.isSafeInteger(value) && value >= 0))
+  ].every((value) => Number.isSafeInteger(value) && value >= 0) || !validOptionalCounters([
+    result.contentBlobBytes,
+    result.contentBlobCount,
+    result.reclaimableContentBytes
+  ]))
     throw new TypeError("Mobile update registry returned an invalid storage report.");
   return result;
 };
@@ -38917,7 +39158,7 @@ var pruneAbsoluteMobileUpdates = async (options) => {
     ...options.signal ? { signal: options.signal } : {}
   });
   validateStorageIdentity(result, options.appId);
-  if (!Array.isArray(result.marked) || !Array.isArray(result.restored) || !Array.isArray(result.swept) || typeof result.dryRun !== "boolean" || !Number.isSafeInteger(result.reclaimedBytes) || result.reclaimedBytes < 0)
+  if (!Array.isArray(result.marked) || !Array.isArray(result.restored) || !Array.isArray(result.swept) || result.sweptContentBlobs !== undefined && !Array.isArray(result.sweptContentBlobs) || typeof result.dryRun !== "boolean" || !Number.isSafeInteger(result.reclaimedBytes) || result.reclaimedBytes < 0)
     throw new TypeError("Mobile update registry returned an invalid collection report.");
   return result;
 };
@@ -38963,7 +39204,12 @@ var publishAbsoluteMobileUpdate = async (options) => {
     rollout: options.rollout,
     signal: options.signal
   });
-  if (result.appId !== manifest.appId || result.channel !== manifest.channel || result.releaseId !== manifest.releaseId || result.rollout !== options.rollout || result.stage !== "published" || typeof result.reused !== "boolean")
+  if (result.appId !== manifest.appId || result.channel !== manifest.channel || result.releaseId !== manifest.releaseId || result.rollout !== options.rollout || result.stage !== "published" || typeof result.reused !== "boolean" || !validOptionalCounters([
+    result.storedBytes,
+    result.storedFiles,
+    result.reusedBytes,
+    result.reusedFiles
+  ]))
     throw new TypeError("Mobile update registry returned a different publication identity.");
   return result;
 };
@@ -39247,5 +39493,5 @@ export {
   writeAbsoluteMobileUpdateRegistry
 };
 
-//# debugId=FB53026A710DD13464756E2164756E21
+//# debugId=B713A6D1CA49D10364756E2164756E21
 //# sourceMappingURL=index.js.map