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

package/dist/mobile/shellUpdate.js

@@ -200,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.");
@@ -395,15 +419,24 @@ 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 {
@@ -414,14 +447,28 @@ var createAbsoluteMobileUpdateClient = (options) => {
         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)
   };
 };
 
@@ -478,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 {
@@ -569,6 +619,7 @@ var createStore = () => {
       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
@@ -581,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,
@@ -596,6 +649,7 @@ var createStore = () => {
         });
         await removeRelease(releaseId);
         await writeState({
+          activeHealthToken: state.activeHealthToken,
           activeRelease: state.activeRelease,
           quarantinedReleases: state.quarantinedReleases
         });
@@ -653,14 +707,15 @@ var createStore = () => {
     commit: async (manifest) => {
       if (staging?.releaseId !== manifest.releaseId)
         throw new TypeError("Mobile update staging transaction changed identity.");
-      await removeStaging(manifest.releaseId);
-      await Preferences.remove({ key: STAGING_KEY });
       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) => {
@@ -738,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",
@@ -771,28 +853,53 @@ 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,
@@ -813,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

package/dist/src/mobile/config.d.ts

@@ -36,6 +36,20 @@ export type NormalizedAbsoluteMobileConfig = {
     };
     updateServer?: {
         autoMount: boolean;
+        health?: {
+            failureRate: number;
+            minimumReports: number;
+            secretEnv: string;
+        };
+        rollout?: {
+            automatic: boolean;
+            stages: {
+                maximumFailureRate: number;
+                minimumReports: number;
+                observationMs: number;
+                rollout: number;
+            }[];
+        };
         expoCodeSigningKeys: Record<string, {
             certificatePem: string;
             privateKeyEnv: string;

package/dist/src/mobile/updateClient.d.ts

@@ -41,16 +41,27 @@ export type AbsoluteMobileUpdateClientOptions = {
 export type AbsoluteMobileUpdateCheckResult = {
     kind: 'current';
 } | {
+    healthToken?: string;
     kind: 'downloaded';
     manifest: AbsoluteMobileUpdateManifest;
     transfer: AbsoluteMobileUpdateTransfer;
 } | {
+    healthToken?: string;
     kind: 'quarantined';
     releaseId: string;
 } | {
+    healthToken?: string;
     kind: 'update-available';
     manifest: AbsoluteMobileUpdateManifest;
 };
+export type AbsoluteMobileUpdateHealthKind = 'activated' | 'downloaded' | 'download-failed' | 'quarantined' | 'rolled-back';
+export type AbsoluteMobileUpdateHealthEvidence = {
+    healthToken: string;
+    kind: AbsoluteMobileUpdateHealthKind;
+    reason?: 'boot-interrupted' | 'boot-timeout';
+    releaseId: string;
+    transfer?: Pick<AbsoluteMobileUpdateTransfer, 'avoidedBytes' | 'downloadedBytes' | 'durationMs' | 'resumedBytes' | 'reusedBytes' | 'throughputBytesPerSecond'>;
+};
 export type AbsoluteMobileUpdateTransfer = {
     avoidedBytes: number;
     completedFiles: number;
@@ -68,8 +79,10 @@ export type AbsoluteMobileUpdateTransfer = {
 export type AbsoluteMobileUpdateProgress = AbsoluteMobileUpdateTransfer & {
     kind: 'download-progress';
 };
+export declare const reportAbsoluteMobileUpdateHealth: (config: AbsoluteMobileUpdateClientConfig, input: AbsoluteMobileUpdateHealthEvidence, request?: typeof globalThis.fetch) => Promise<void>;
 export declare const createAbsoluteMobileUpdateClient: (options: AbsoluteMobileUpdateClientOptions) => {
     check: (download?: boolean) => Promise<AbsoluteMobileUpdateCheckResult>;
     activate: (releaseId: string) => Promise<void>;
     download: () => Promise<AbsoluteMobileUpdateCheckResult>;
+    report: (input: AbsoluteMobileUpdateHealthEvidence) => Promise<void>;
 };

package/dist/src/mobile/updatePublisher.d.ts

@@ -1,4 +1,4 @@
-import type { MobileUpdatePruneOptions, MobileUpdatePruneResult, MobileUpdateRetentionOptions, MobileUpdateStorageReport } from '@absolutejs/deploy/mobile-update';
+import type { MobileUpdateHealthReport, MobileUpdatePruneOptions, MobileUpdatePruneResult, MobileUpdateRetentionOptions, MobileUpdateRolloutReport, MobileUpdateStorageReport } from '@absolutejs/deploy/mobile-update';
 import { readAbsoluteMobileUpdate } from './updateSigning';
 export type AbsoluteMobileUpdatePublication = {
     appId: string;
@@ -26,6 +26,31 @@ export type AbsoluteMobileUpdateRollback = {
     stage: 'rolled-back';
 };
 export type AbsoluteMobileUpdatePublisher = {
+    advanceUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+        rollout?: number;
+        signal?: AbortSignal;
+    }) => Promise<MobileUpdateRolloutReport>;
+    cancelUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+        signal?: AbortSignal;
+    }) => Promise<MobileUpdateRolloutReport>;
+    inspectUpdateHealth?: (options: {
+        appId: string;
+        channel: string;
+        releaseId?: string;
+    }) => Promise<MobileUpdateHealthReport | null>;
+    inspectUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+    }) => Promise<MobileUpdateRolloutReport | null>;
+    pauseUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+        signal?: AbortSignal;
+    }) => Promise<MobileUpdateRolloutReport>;
     inspectUpdateStorage?: (options: MobileUpdateRetentionOptions) => Promise<MobileUpdateStorageReport>;
     pruneUpdates?: (options: MobileUpdatePruneOptions) => Promise<MobileUpdatePruneResult>;
     publishUpdate(options: {
@@ -47,7 +72,59 @@ export type AbsoluteMobileUpdatePublisher = {
         releaseId?: string;
         signal?: AbortSignal;
     }): Promise<AbsoluteMobileUpdateRollback>;
+    reconcileUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+        signal?: AbortSignal;
+    }) => Promise<MobileUpdateRolloutReport | null>;
+    resumeUpdateRollout?: (options: {
+        appId: string;
+        channel: string;
+        signal?: AbortSignal;
+    }) => Promise<MobileUpdateRolloutReport>;
 };
+export declare const inspectAbsoluteMobileUpdateHealth: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    releaseId?: string;
+}) => Promise<MobileUpdateHealthReport | null>;
+export declare const inspectAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+}) => Promise<MobileUpdateRolloutReport | null>;
+export declare const advanceAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    rollout?: number;
+    signal?: AbortSignal;
+}) => Promise<MobileUpdateRolloutReport>;
+export declare const cancelAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    signal?: AbortSignal;
+}) => Promise<MobileUpdateRolloutReport>;
+export declare const pauseAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    signal?: AbortSignal;
+}) => Promise<MobileUpdateRolloutReport>;
+export declare const reconcileAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    signal?: AbortSignal;
+}) => Promise<MobileUpdateRolloutReport | null>;
+export declare const resumeAbsoluteMobileUpdateRollout: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    signal?: AbortSignal;
+}) => Promise<MobileUpdateRolloutReport>;
 export declare const inspectAbsoluteMobileUpdateStorage: (options: {
     appId: string;
     minAgeMs?: number;

package/dist/src/mobile/updateServer.d.ts

@@ -22,11 +22,39 @@ export declare const createAbsoluteMobileUpdateServerPlugin: (config: Normalized
 }, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>>;
 export declare const inspectAbsoluteMobileUpdateServer: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<AbsoluteMobileUpdateServerMetadata | undefined>;
 export declare const renderAbsoluteMobileUpdateRegistry: (options: {
+    health?: {
+        failureRate: number;
+        minimumReports: number;
+        secretEnv: string;
+    };
+    rollout?: {
+        automatic: boolean;
+        stages: {
+            maximumFailureRate: number;
+            minimumReports: number;
+            observationMs: number;
+            rollout: number;
+        }[];
+    };
     publicKeys: Readonly<Record<string, string>>;
     storage: "local" | "s3";
 }) => string;
 export declare const writeAbsoluteMobileUpdateRegistry: (options: {
     force?: boolean;
+    health?: {
+        failureRate: number;
+        minimumReports: number;
+        secretEnv: string;
+    };
+    rollout?: {
+        automatic: boolean;
+        stages: {
+            maximumFailureRate: number;
+            minimumReports: number;
+            observationMs: number;
+            rollout: number;
+        }[];
+    };
     modulePath?: string;
     projectRoot: string;
     publicKeys: Readonly<Record<string, string>>;

package/dist/types/build.d.ts

@@ -111,6 +111,31 @@ type MobileSharedConfig = {
         server?: {
             /** Mount the update endpoint in the AbsoluteJS runtime. Defaults to true. */
             autoMount?: boolean;
+            /** Anonymous fleet-health receipts and automatic rollout protection. Enabled by default. */
+            health?: false | {
+                /** Failure fraction that pauses a promotion. Defaults to 0.2. */
+                failureRate?: number;
+                /** Terminal activation/rollback sample required before pausing. Defaults to 20. */
+                minimumReports?: number;
+                /** Trusted-server secret environment variable. */
+                secretEnv?: string;
+            };
+            /** Health-gated staged rollout orchestration. Disabled unless configured. */
+            rollout?: false | {
+                /** Advance qualifying stages from health reports. Defaults to false. */
+                automatic?: boolean;
+                /** Defaults to recommended 5%, 25%, and 100% stages. */
+                stages?: readonly {
+                    /** Failure ceiling for advancement. Defaults to 0.05. */
+                    maximumFailureRate?: number;
+                    /** Cumulative terminal reports required. Defaults to 20. */
+                    minimumReports?: number;
+                    /** Time at this stage before advancement. Defaults to 60 minutes. */
+                    observationMinutes?: number;
+                    /** Installation cohort fraction, greater than 0 and at most 1. */
+                    rollout: number;
+                }[];
+            };
             /** Project-relative registry module. Defaults to `mobile.update.ts`. */
             registry?: string;
             /** Environment variable containing the Expo RSA private key PEM. */

package/package.json

@@ -9,7 +9,7 @@
 	"dependencies": {
 		"@absolutejs/auth": ">=0.75.0 <0.77.0",
 		"@absolutejs/beacon": ">=0.7.0-beta.4 <0.8.0",
-		"@absolutejs/deploy": "0.25.9",
+		"@absolutejs/deploy": "0.25.13",
 		"@absolutejs/devices": "0.7.0",
 		"@absolutejs/devices-capacitor": "0.8.0",
 		"@absolutejs/devices-expo": "0.0.2",
@@ -523,7 +523,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.85",
+	"version": "0.20.0-beta.87",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"