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

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-hdmKLU/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-wrP0vo/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-hdmKLU/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-wrP0vo/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-hdmKLU/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-wrP0vo/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

package/dist/build.js

@@ -28480,7 +28480,7 @@ import {
 } from "crypto";
 import { readFile as readFile9, stat as stat3 } 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, object3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), text2 = (value, field) => {
+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, object3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), text2 = (value, field) => {
   if (typeof value !== "string" || value.length === 0)
     throw new MobileUpdateRegistryError(`Mobile update ${field} is invalid`);
   return value;
@@ -28647,6 +28647,8 @@ 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, file5) => `${releaseRoot(manifest)}/files/${file5.path}`;
+  const contentBlobKey = (appId, sha256) => `${root(appId)}/blobs/${sha256}`;
+  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");
@@ -28675,6 +28677,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,
@@ -28699,6 +28707,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 readManifest2(input.appId, input.releaseId);
     if (!release || release.manifest.channel !== input.channel)
       throw new MobileUpdateRegistryError("Mobile update was not published to this channel");
@@ -28744,19 +28753,271 @@ 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 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 sha256 = blobObject.key.slice(blobPrefix.length);
+        if (HASH.test(sha256)) {
+          objectKeysByDigest.set(sha256, blobObject.key);
+          objectBytesByDigest.set(sha256, blobObject.size);
+        }
+      }
+      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(decode(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 = decode(bytes);
+      if (!object3(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 readManifest2(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 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((file5) => file5.sha256)));
+    const reclaimableContentBytes = [...objectBytesByDigest].filter(([sha256]) => !protectedDigests.has(sha256)).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,
+        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 - contentBlobBytes
+      }
+    };
+  };
+  const pruneUpdates = async (input) => {
+    const initial = await inventory(input);
+    const result = {
+      ...initial.report,
+      dryRun: input.apply !== true,
+      marked: [],
+      reclaimedBytes: 0,
+      restored: [],
+      swept: [],
+      sweptContentBlobs: []
+    };
+    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);
+    }
+    const afterReleaseSweep = await inventory(input);
+    const referencedDigests = new Set;
+    for (const release of afterReleaseSweep.report.releases) {
+      const manifest = await readManifest2(input.appId, release.releaseId);
+      for (const file5 of manifest?.manifest.files ?? [])
+        referencedDigests.add(file5.sha256);
+    }
+    for (const [sha256, key] of afterReleaseSweep.objectKeysByDigest) {
+      if (referencedDigests.has(sha256))
+        continue;
+      const head = await options.store.head(key);
+      await remove(key);
+      result.reclaimedBytes += head?.size ?? 0;
+      result.sweptContentBlobs.push(sha256);
+    }
+    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 readFile9(path.join(localRoot, "update.json"), "utf8")));
       if (JSON.stringify(localManifest) !== JSON.stringify(manifest))
         throw new MobileUpdateRegistryError("Local mobile update manifest changed");
       const existing = await readManifest2(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, file5) => total + file5.bytes, 0);
+        reusedFiles = manifest.files.length;
+      }
       if (!existing) {
         for (const file5 of manifest.files) {
           const local = path.join(localRoot, "files", file5.path);
@@ -28765,18 +29026,24 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
             throw new MobileUpdateRegistryError(`Mobile update file ${file5.path} size changed`);
           if (await fileDigest(Bun.file(local)) !== file5.sha256)
             throw new MobileUpdateRegistryError(`Mobile update file ${file5.path} integrity failed`);
-          const key = fileKey(manifest, file5);
+          const key = contentBlobKey(manifest.appId, file5.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: file5.bytes,
-              metadata: { releaseid: manifest.releaseId, sha256: file5.sha256 },
+              metadata: { sha256: file5.sha256 },
               signal: input.signal
             });
-          } else if (stored.size !== file5.bytes || stored.metadata?.sha256 !== file5.sha256 || (stored.metadata?.releaseid ?? stored.metadata?.releaseId) !== manifest.releaseId)
-            throw new MobileUpdateRegistryError("Stored mobile update file identity changed");
+            storedBytes += file5.bytes;
+            storedFiles += 1;
+          } else if (stored.size !== file5.bytes || stored.metadata?.sha256 !== file5.sha256)
+            throw new MobileUpdateRegistryError("Stored mobile update content identity changed");
+          else {
+            reusedBytes += file5.bytes;
+            reusedFiles += 1;
+          }
         }
         const bytes = json(manifest);
         await options.store.put(manifestKey(manifest), bytes, {
@@ -28800,8 +29067,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"
       };
@@ -28813,6 +29084,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 readManifest2(input.appId, input.releaseId);
         if (!release || release.manifest.channel !== input.channel)
           throw new MobileUpdateRegistryError("Mobile rollback release was not published");
@@ -28849,14 +29121,16 @@ var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updat
       const file5 = release.manifest.files.find((candidate) => candidate.path === requested);
       if (!file5)
         return null;
-      const key = fileKey(release.manifest, file5);
+      const legacyKey = fileKey(release.manifest, file5);
+      const legacyHead = await options.store.head(legacyKey);
+      const key = legacyHead ? legacyKey : contentBlobKey(release.manifest.appId, file5.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 !== file5.bytes || head.size !== file5.bytes || head.metadata?.sha256 !== file5.sha256 || (head.metadata?.releaseid ?? head.metadata?.releaseId) !== release.manifest.releaseId || digest(bytes) !== file5.sha256)
+      if (bytes.byteLength !== file5.bytes || head.size !== file5.bytes || head.metadata?.sha256 !== file5.sha256 || legacyHead && (head.metadata?.releaseid ?? head.metadata?.releaseId) !== release.manifest.releaseId || digest(bytes) !== file5.sha256)
         throw new MobileUpdateRegistryError("Stored mobile update file integrity failed");
       return { bytes, file: file5 };
     }
@@ -29145,6 +29419,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]*)+$/;
@@ -36969,5 +37246,5 @@ export {
   devBuild
 };
 
-//# debugId=7849DC008DCD28AC64756E2164756E21
+//# debugId=5BE2EBFD6FC5145B64756E2164756E21
 //# sourceMappingURL=build.js.map