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

package/dist/mobile/index.js

@@ -19970,7 +19970,7 @@ import {
 } from "crypto";
 import { readFile as readFile23, stat as stat5 } from "fs/promises";
 import path from "path";
-var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updates", MAX_FILE_BYTES, MAX_TOTAL_BYTES, HASH, RELEASE, APP_ID, NAME, EXPO_DESCRIPTOR = "_absolute/expo-update.json", EXPO_CODE_SIGNING_ALGORITHM = "rsa-v1_5-sha256", MobileUpdateRegistryError, object6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), text2 = (value, field2) => {
+var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updates", MAX_FILE_BYTES, MAX_TOTAL_BYTES, DAY_MS, DEFAULT_MIN_AGE_MS, DEFAULT_GRACE_PERIOD_MS, DEFAULT_RETAIN_RECENT = 5, HASH, RELEASE, APP_ID, NAME, EXPO_DESCRIPTOR = "_absolute/expo-update.json", EXPO_CODE_SIGNING_ALGORITHM = "rsa-v1_5-sha256", MobileUpdateRegistryError, object6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), text2 = (value, field2) => {
   if (typeof value !== "string" || value.length === 0)
     throw new MobileUpdateRegistryError(`Mobile update ${field2} is invalid`);
   return value;
@@ -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 tombstoneKey = (appId, releaseId) => `${root(appId)}/gc/${releaseId}.json`;
   const channelKey = (appId, channel) => {
     if (!APP_ID.test(appId) || !NAME.test(channel))
       throw new MobileUpdateRegistryError("Mobile update channel identity is invalid");
@@ -20165,6 +20166,12 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       throw new MobileUpdateRegistryError("Stored mobile update channel identity changed");
     return value;
   };
+  const assertNotMarked = async (appId, releaseId) => {
+    if (!APP_ID.test(appId) || !RELEASE.test(releaseId))
+      throw new MobileUpdateRegistryError("Mobile update release identity is invalid");
+    if (await options.store.head(tombstoneKey(appId, releaseId)))
+      throw new MobileUpdateRegistryError("Mobile update release is marked for collection. Increase retention and apply garbage collection to restore it before promotion");
+  };
   const writeChannel = async (input, signal) => {
     const value = {
       ...input,
@@ -20189,6 +20196,7 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
     input.signal?.throwIfAborted();
     if (input.rollout <= 0 || input.rollout > 1)
       throw new MobileUpdateRegistryError("Mobile update rollout is invalid");
+    await assertNotMarked(input.appId, input.releaseId);
     const release = await readManifest(input.appId, input.releaseId);
     if (!release || release.manifest.channel !== input.channel)
       throw new MobileUpdateRegistryError("Mobile update was not published to this channel");
@@ -20234,11 +20242,221 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       status: "selected"
     };
   };
+  const retentionValues = (input) => {
+    if (!APP_ID.test(input.appId))
+      throw new MobileUpdateRegistryError("Mobile update appId is invalid");
+    const retainRecent = input.retainRecent ?? DEFAULT_RETAIN_RECENT;
+    const minAgeMs = input.minAgeMs ?? DEFAULT_MIN_AGE_MS;
+    if (!Number.isSafeInteger(retainRecent) || retainRecent < 0)
+      throw new MobileUpdateRegistryError("Mobile update retained release count is invalid");
+    if (!Number.isSafeInteger(minAgeMs) || minAgeMs < 0)
+      throw new MobileUpdateRegistryError("Mobile update minimum release age is invalid");
+    return { minAgeMs, retainRecent };
+  };
+  const listObjects = async (appId, signal) => {
+    const list = options.store.list;
+    if (!list)
+      throw new MobileUpdateRegistryError("Mobile update storage does not support lifecycle listing");
+    const objects = [];
+    const cursors = new Set;
+    let cursor;
+    do {
+      signal?.throwIfAborted();
+      const page = await list({
+        ...cursor ? { cursor } : {},
+        prefix: `${root(appId)}/`
+      });
+      objects.push(...page.objects);
+      if (!page.truncated)
+        break;
+      if (!page.cursor || cursors.has(page.cursor))
+        throw new MobileUpdateRegistryError("Mobile update storage returned an invalid lifecycle cursor");
+      cursors.add(page.cursor);
+      cursor = page.cursor;
+    } while (true);
+    return objects;
+  };
+  const inventory = async (input) => {
+    const { minAgeMs, retainRecent } = retentionValues(input);
+    const objects = await listObjects(input.appId, input.signal);
+    const appRoot = `${root(input.appId)}/`;
+    const releasePrefix = `${appRoot}releases/`;
+    const channelPrefix = `${appRoot}channels/`;
+    const markerPrefix = `${appRoot}gc/`;
+    const objectKeysByRelease = new Map;
+    const objectBytesByRelease = new Map;
+    for (const blobObject of objects) {
+      if (!blobObject.key.startsWith(releasePrefix))
+        continue;
+      const suffix = blobObject.key.slice(releasePrefix.length);
+      const releaseId = suffix.slice(0, suffix.indexOf("/"));
+      if (!RELEASE.test(releaseId))
+        continue;
+      objectKeysByRelease.set(releaseId, [
+        ...objectKeysByRelease.get(releaseId) ?? [],
+        blobObject.key
+      ]);
+      objectBytesByRelease.set(releaseId, (objectBytesByRelease.get(releaseId) ?? 0) + blobObject.size);
+    }
+    const channels = [];
+    for (const blobObject of objects) {
+      if (!blobObject.key.startsWith(channelPrefix) || !blobObject.key.endsWith(".json"))
+        continue;
+      const bytes = await options.store.get(blobObject.key);
+      if (!bytes)
+        throw new MobileUpdateRegistryError("Mobile update channel disappeared during lifecycle inspection");
+      const channel = parseChannel(decode2(bytes));
+      if (channel.appId !== input.appId)
+        throw new MobileUpdateRegistryError("Stored mobile update channel identity changed");
+      channels.push(channel);
+    }
+    const markedAt = new Map;
+    for (const blobObject of objects) {
+      if (!blobObject.key.startsWith(markerPrefix) || !blobObject.key.endsWith(".json"))
+        continue;
+      const releaseId = blobObject.key.slice(markerPrefix.length, -".json".length);
+      if (!RELEASE.test(releaseId))
+        continue;
+      const bytes = await options.store.get(blobObject.key);
+      if (!bytes)
+        continue;
+      const marker = decode2(bytes);
+      if (!object6(marker) || marker.format !== 1 || marker.appId !== input.appId || marker.releaseId !== releaseId || !iso(marker.markedAt))
+        throw new MobileUpdateRegistryError("Mobile update collection marker is invalid");
+      markedAt.set(releaseId, marker.markedAt);
+    }
+    const active = new Set(channels.flatMap((channel) => channel.releaseId ? [channel.releaseId] : []));
+    const fallback = new Set(channels.flatMap((channel) => channel.fallbackReleaseId ? [channel.fallbackReleaseId] : []));
+    const manifests = [];
+    for (const releaseId of objectKeysByRelease.keys()) {
+      const release = await readManifest(input.appId, releaseId);
+      if (release)
+        manifests.push(release.manifest);
+    }
+    const recent = new Set;
+    const manifestsByChannel = new Map;
+    for (const manifest of manifests)
+      manifestsByChannel.set(manifest.channel, [
+        ...manifestsByChannel.get(manifest.channel) ?? [],
+        manifest
+      ]);
+    for (const releases2 of manifestsByChannel.values())
+      for (const manifest of releases2.toSorted((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, retainRecent))
+        recent.add(manifest.releaseId);
+    const now = clock().getTime();
+    const releases = manifests.map((manifest) => {
+      const protectedBy = [];
+      if (active.has(manifest.releaseId))
+        protectedBy.push("active");
+      if (fallback.has(manifest.releaseId))
+        protectedBy.push("fallback");
+      if (recent.has(manifest.releaseId))
+        protectedBy.push("recent");
+      if (now - Date.parse(manifest.createdAt) < minAgeMs)
+        protectedBy.push("age");
+      return {
+        bytes: objectBytesByRelease.get(manifest.releaseId) ?? 0,
+        channel: manifest.channel,
+        createdAt: manifest.createdAt,
+        ...markedAt.has(manifest.releaseId) ? { markedAt: markedAt.get(manifest.releaseId) } : {},
+        objectCount: objectKeysByRelease.get(manifest.releaseId)?.length ?? 0,
+        protectedBy,
+        releaseId: manifest.releaseId
+      };
+    }).toSorted((left, right) => right.createdAt.localeCompare(left.createdAt));
+    const releaseBytes = releases.reduce((total, release) => total + release.bytes, 0);
+    const totalBytes = objects.reduce((total, object22) => total + object22.size, 0);
+    return {
+      objectKeysByRelease,
+      report: {
+        appId: input.appId,
+        channelCount: channels.length,
+        reclaimableBytes: releases.filter((release) => release.protectedBy.length === 0).reduce((total, release) => total + release.bytes, 0),
+        releaseBytes,
+        releaseCount: releases.length,
+        releases,
+        totalBytes,
+        totalObjectCount: objects.length,
+        untrackedBytes: totalBytes - releaseBytes
+      }
+    };
+  };
+  const pruneUpdates = async (input) => {
+    const initial = await inventory(input);
+    const result = {
+      ...initial.report,
+      dryRun: input.apply !== true,
+      marked: [],
+      reclaimedBytes: 0,
+      restored: [],
+      swept: []
+    };
+    if (input.apply !== true)
+      return result;
+    const remove = options.store.delete;
+    if (!remove)
+      throw new MobileUpdateRegistryError("Mobile update storage does not support lifecycle deletion");
+    const gracePeriodMs = input.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
+    if (!Number.isSafeInteger(gracePeriodMs) || gracePeriodMs < 0)
+      throw new MobileUpdateRegistryError("Mobile update collection grace period is invalid");
+    const now = clock();
+    for (const release of initial.report.releases) {
+      input.signal?.throwIfAborted();
+      const marker = tombstoneKey(input.appId, release.releaseId);
+      if (release.protectedBy.length > 0) {
+        if (release.markedAt) {
+          await remove(marker);
+          result.restored.push(release.releaseId);
+        }
+        continue;
+      }
+      if (!release.markedAt) {
+        const bytes = json({
+          appId: input.appId,
+          format: 1,
+          markedAt: now.toISOString(),
+          releaseId: release.releaseId
+        });
+        await options.store.put(marker, bytes, {
+          cacheControl: "no-cache",
+          contentType: "application/json",
+          maxBytes: bytes.byteLength,
+          metadata: { releaseid: release.releaseId, sha256: digest(bytes) },
+          signal: input.signal
+        });
+        result.marked.push(release.releaseId);
+      }
+    }
+    const current = await inventory(input);
+    for (const release of current.report.releases) {
+      input.signal?.throwIfAborted();
+      if (release.protectedBy.length > 0 || !release.markedAt || now.getTime() - Date.parse(release.markedAt) < gracePeriodMs || result.marked.includes(release.releaseId))
+        continue;
+      const checked = await inventory(input);
+      const candidate = checked.report.releases.find((value) => value.releaseId === release.releaseId);
+      if (!candidate || candidate.protectedBy.length > 0 || !candidate.markedAt)
+        continue;
+      const keys = checked.objectKeysByRelease.get(release.releaseId) ?? [];
+      for (const key of keys.toSorted((left, right) => {
+        const leftManifest = left.endsWith("/update.json");
+        const rightManifest = right.endsWith("/update.json");
+        return Number(leftManifest) - Number(rightManifest);
+      }))
+        await remove(key);
+      await remove(tombstoneKey(input.appId, release.releaseId));
+      result.reclaimedBytes += candidate.bytes;
+      result.swept.push(release.releaseId);
+    }
+    return result;
+  };
   return {
+    inspectUpdateStorage: async (input) => (await inventory(input)).report,
+    pruneUpdates,
     publishUpdate: async (input) => {
       input.signal?.throwIfAborted();
       const manifest = parseMobileUpdateManifest(input.manifest);
       verifyManifestSignature(manifest, options.publicKeys);
+      await assertNotMarked(manifest.appId, manifest.releaseId);
       const localRoot = path.resolve(input.releaseDirectory);
       const localManifest = parseMobileUpdateManifest(JSON.parse(await readFile23(path.join(localRoot, "update.json"), "utf8")));
       if (JSON.stringify(localManifest) !== JSON.stringify(manifest))
@@ -20262,10 +20480,10 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
               cacheControl: "public, max-age=31536000, immutable",
               contentType: "application/octet-stream",
               maxBytes: file.bytes,
-              metadata: { releaseId: manifest.releaseId, sha256: file.sha256 },
+              metadata: { releaseid: manifest.releaseId, sha256: file.sha256 },
               signal: input.signal
             });
-          } else if (stored.size !== file.bytes || stored.metadata?.sha256 !== file.sha256 || stored.metadata?.releaseId !== manifest.releaseId)
+          } 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");
         }
         const bytes = json(manifest);
@@ -20273,7 +20491,7 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
           cacheControl: "public, max-age=31536000, immutable",
           contentType: "application/json",
           maxBytes: bytes.byteLength,
-          metadata: { releaseId: manifest.releaseId, sha256: digest(bytes) },
+          metadata: { releaseid: manifest.releaseId, sha256: digest(bytes) },
           signal: input.signal
         });
         if (!await readManifest(manifest.appId, manifest.releaseId))
@@ -20303,6 +20521,7 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       if (!existing)
         throw new MobileUpdateRegistryError("Mobile update channel does not exist");
       if (input.releaseId) {
+        await assertNotMarked(input.appId, input.releaseId);
         const release = await readManifest(input.appId, input.releaseId);
         if (!release || release.manifest.channel !== input.channel)
           throw new MobileUpdateRegistryError("Mobile rollback release was not published");
@@ -20346,7 +20565,7 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       ]);
       if (!bytes || !head)
         return null;
-      if (bytes.byteLength !== file.bytes || head.size !== file.bytes || head.metadata?.sha256 !== file.sha256 || head.metadata?.releaseId !== release.manifest.releaseId || digest(bytes) !== file.sha256)
+      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)
         throw new MobileUpdateRegistryError("Stored mobile update file integrity failed");
       return { bytes, file };
     }
@@ -20635,6 +20854,9 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
 var init_mobileUpdate = __esm(() => {
   MAX_FILE_BYTES = 32 * 1024 * 1024;
   MAX_TOTAL_BYTES = 128 * 1024 * 1024;
+  DAY_MS = 24 * 60 * 60 * 1000;
+  DEFAULT_MIN_AGE_MS = 30 * DAY_MS;
+  DEFAULT_GRACE_PERIOD_MS = 7 * DAY_MS;
   HASH = /^[a-f0-9]{64}$/;
   RELEASE = /^amu_[a-f0-9]{64}$/;
   APP_ID = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
@@ -20705,10 +20927,27 @@ var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1, DEFAULT_MOBILE_UPDATE_REGISTRY_MOD
   const registry4 = loaded.default ?? loaded.registry;
   if (!isRegistry4(registry4))
     throw new TypeError("Mobile update registry must implement publication, promotion, rollback, resolution, and file reads.");
+  const metadata = serverMetadata(loaded.absoluteMobileUpdateServer);
+  const verifier = loaded.verifyAbsoluteMobileUpdateServer;
+  if (metadata.storage === "durable" && typeof verifier !== "function")
+    throw new TypeError("Mobile update registries marked durable must export verifyAbsoluteMobileUpdateServer(). Re-run `absolute mobile update provision --storage s3 --force` or provide an active durability check.");
   return {
-    metadata: serverMetadata(loaded.absoluteMobileUpdateServer),
-    registry: registry4
+    metadata,
+    registry: registry4,
+    ...typeof verifier === "function" ? {
+      verifyDurability: async () => {
+        await verifier();
+      }
+    } : {}
   };
+}, verifyDurableModule = async (module) => {
+  if (module.metadata.storage !== "durable")
+    throw new TypeError("Mobile production updates require durable object storage. Re-run `absolute mobile update provision --storage s3 --force` or configure a durable adapter.");
+  try {
+    await module.verifyDurability?.();
+  } catch (error) {
+    throw new TypeError(`Durable mobile update storage verification failed for ${module.metadata.provider}. Check the bucket, endpoint, credentials, and read/write/delete permissions.`, { cause: error });
+  }
 }, expoSigningOptions = (config) => {
   if (!config.updates?.expoCodeSigning)
     return;
@@ -20740,8 +20979,8 @@ var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1, DEFAULT_MOBILE_UPDATE_REGISTRY_MOD
   if (!updates || !server?.autoMount)
     return new Elysia4({ name: "absolutejs-mobile-updates-disabled" });
   const module = await loadAbsoluteMobileUpdateServerModule(projectRoot, server.registryModule);
-  if (options.production && module.metadata.storage !== "durable")
-    throw new TypeError("Mobile production updates require durable object storage. Re-run `absolute mobile update provision --storage s3 --force` or configure a durable adapter.");
+  if (options.production)
+    await verifyDurableModule(module);
   const manifest = new URL(updates.manifestUrl);
   if (!manifest.pathname.endsWith("/update.json"))
     throw new TypeError("Auto-mounted mobile update manifests must end in /update.json.");
@@ -20759,8 +20998,7 @@ var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1, DEFAULT_MOBILE_UPDATE_REGISTRY_MOD
   if (!config.updates)
     return;
   const module = await loadAbsoluteMobileUpdateServerModule(projectRoot, config.updateServer?.registryModule);
-  if (module.metadata.storage !== "durable")
-    throw new TypeError("Mobile production updates require durable object storage; the configured registry is local-only.");
+  await verifyDurableModule(module);
   if (config.engine === "expo")
     expoSigningOptions(config);
   return module.metadata;
@@ -20787,7 +21025,8 @@ export default createMobileUpdateRegistry({
 	store
 });
 `;
-  return `import { S3Client } from '@aws-sdk/client-s3';
+  return `import { randomUUID } from 'node:crypto';
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { awsS3BlobStore } from '@absolutejs/blob/aws-s3';
 import { createMobileUpdateRegistry } from '@absolutejs/deploy/mobile-update';
 
@@ -20799,6 +21038,7 @@ const required = (name: string) => {
 	return value;
 };
 
+const bucket = required('ABSOLUTE_MOBILE_UPDATE_S3_BUCKET');
 const client = new S3Client({
 	region: process.env.ABSOLUTE_MOBILE_UPDATE_S3_REGION ?? 'auto',
 	forcePathStyle: process.env.ABSOLUTE_MOBILE_UPDATE_S3_FORCE_PATH_STYLE === '1',
@@ -20806,10 +21046,22 @@ const client = new S3Client({
 		? { endpoint: process.env.ABSOLUTE_MOBILE_UPDATE_S3_ENDPOINT }
 		: {})
 });
-const store = awsS3BlobStore({
-	bucket: required('ABSOLUTE_MOBILE_UPDATE_S3_BUCKET'),
-	client
-});
+const store = awsS3BlobStore({ bucket, client });
+
+export const verifyAbsoluteMobileUpdateServer = async () => {
+	const key = \`absolutejs/mobile-updates/_health/\${randomUUID()}\`;
+	const expected = randomUUID();
+	let stored = false;
+	try {
+		await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: expected }));
+		stored = true;
+		const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+		if ((await response.Body?.transformToString()) !== expected)
+			throw new Error('Durability probe read did not match its write.');
+	} finally {
+		if (stored) await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+	}
+};
 
 export default createMobileUpdateRegistry({
 	publicKeys: ${publicKeysSource(options.publicKeys)},
@@ -38630,6 +38882,45 @@ var verifyAbsoluteMobileUpdateSignature = (manifestValue, publicKey) => {
 };
 
 // src/mobile/updatePublisher.ts
+var lifecycleMethod = (publisher, name) => {
+  const method = publisher[name];
+  if (typeof method !== "function")
+    throw new TypeError(`Mobile update registry does not support ${name}. Re-run \`absolute mobile update provision --force\` after upgrading @absolutejs/deploy.`);
+  return method;
+};
+var validateStorageIdentity = (result, appId) => {
+  if (!object5(result) || result.appId !== appId || !Array.isArray(result.releases) || ![
+    result.channelCount,
+    result.reclaimableBytes,
+    result.releaseBytes,
+    result.releaseCount,
+    result.totalBytes,
+    result.totalObjectCount,
+    result.untrackedBytes
+  ].every((value) => Number.isSafeInteger(value) && value >= 0))
+    throw new TypeError("Mobile update registry returned an invalid storage report.");
+  return result;
+};
+var inspectAbsoluteMobileUpdateStorage = async (options) => validateStorageIdentity(await lifecycleMethod(options.publisher, "inspectUpdateStorage")({
+  appId: options.appId,
+  ...options.minAgeMs === undefined ? {} : { minAgeMs: options.minAgeMs },
+  ...options.retainRecent === undefined ? {} : { retainRecent: options.retainRecent },
+  ...options.signal ? { signal: options.signal } : {}
+}), options.appId);
+var pruneAbsoluteMobileUpdates = async (options) => {
+  const result = await lifecycleMethod(options.publisher, "pruneUpdates")({
+    appId: options.appId,
+    ...options.apply === undefined ? {} : { apply: options.apply },
+    ...options.gracePeriodMs === undefined ? {} : { gracePeriodMs: options.gracePeriodMs },
+    ...options.minAgeMs === undefined ? {} : { minAgeMs: options.minAgeMs },
+    ...options.retainRecent === undefined ? {} : { retainRecent: options.retainRecent },
+    ...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)
+    throw new TypeError("Mobile update registry returned an invalid collection report.");
+  return result;
+};
 var object5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPublisher2 = (value) => object5(value) && typeof value.publishUpdate === "function" && typeof value.promoteUpdate === "function" && typeof value.rollbackUpdate === "function";
 var projectPath2 = (projectRoot, requested, label) => {
@@ -38849,6 +39140,7 @@ export {
   inspectAbsoluteAndroidInstalledApp,
   inspectAbsoluteMobileRouteMetadata,
   inspectAbsoluteMobileUpdateServer,
+  inspectAbsoluteMobileUpdateStorage,
   inspectAbsoluteRemoteMac,
   inspectAbsoluteRemoteMacLanHost,
   inspectAbsoluteRemoteMacWorkspace,
@@ -38906,6 +39198,7 @@ export {
   projectUsesAbsoluteAuth,
   projectUsesAbsoluteSync,
   promoteAbsoluteMobileUpdate,
+  pruneAbsoluteMobileUpdates,
   publishAbsoluteAndroidRelease,
   publishAbsoluteIosRelease,
   publishAbsoluteMobileUpdate,
@@ -38954,5 +39247,5 @@ export {
   writeAbsoluteMobileUpdateRegistry
 };
 
-//# debugId=E2398F592E2828EE64756E2164756E21
+//# debugId=FB53026A710DD13464756E2164756E21
 //# sourceMappingURL=index.js.map