@absolutejs/absolute 0.20.0-beta.27 → 0.20.0-beta.29

package/dist/mobile/index.js

@@ -325,31 +325,31 @@ var object = (value) => typeof value === "object" && value !== null && !Array.is
       return;
     directory = parent;
   }
-}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field) => {
+}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field2) => {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
-    throw metadataError(id, `${field} must be a positive safe integer.`);
+    throw metadataError(id, `${field2} must be a positive safe integer.`);
   return value;
-}, nonEmpty = (value, id, field) => {
+}, nonEmpty = (value, id, field2) => {
   if (typeof value !== "string" || value.trim() !== value || value.length === 0)
-    throw metadataError(id, `${field} must be a non-empty trimmed string.`);
+    throw metadataError(id, `${field2} must be a non-empty trimmed string.`);
   return value;
 }, requireObject = (value, id, detail) => {
   if (!object(value))
     throw metadataError(id, detail);
   return value;
-}, unknownField = (record, key) => record[key], normalizeJsonValue2 = (value, id, field) => {
+}, unknownField = (record, key) => record[key], normalizeJsonValue2 = (value, id, field2) => {
   if (value === null || typeof value === "string" || typeof value === "boolean")
     return value;
   if (typeof value === "number" && Number.isFinite(value))
     return value;
   if (Array.isArray(value))
-    return value.map((entry) => normalizeJsonValue2(entry, id, field));
+    return value.map((entry) => normalizeJsonValue2(entry, id, field2));
   if (object(value))
     return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
       key,
-      normalizeJsonValue2(entry, id, field)
+      normalizeJsonValue2(entry, id, field2)
     ]));
-  throw metadataError(id, `${field} must be JSON-safe.`);
+  throw metadataError(id, `${field2} must be JSON-safe.`);
 }, operation = (value, id, index) => {
   const record = requireObject(value, id, `migration operation ${index} must be an object.`);
   const type = Reflect.get(record, "type");
@@ -363,13 +363,13 @@ var object = (value) => typeof value === "object" && value !== null && !Array.is
       to: nonEmpty(Reflect.get(record, "to"), id, `operation ${index}.to`),
       type
     };
-  const field = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
+  const field2 = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
   if (type === "remove-field")
-    return { collection, field, type };
+    return { collection, field: field2, type };
   if (type === "set-default")
     return {
       collection,
-      field,
+      field: field2,
       type,
       value: normalizeJsonValue2(Reflect.get(record, "value"), id, `operation ${index}.value`)
     };
@@ -598,24 +598,24 @@ var DEVICES_PACKAGE = "@absolutejs/devices", CAPACITOR_ADAPTER = "@absolutejs/de
   if (!object2(value))
     throw new TypeError(`${path} must contain an object.`);
   return value;
-}, text = (value, field) => {
+}, text = (value, field2) => {
   if (typeof value !== "string" || value.length === 0)
-    throw new TypeError(`${field} must be a non-empty string.`);
+    throw new TypeError(`${field2} must be a non-empty string.`);
   return value;
-}, androidPermissions = (value, field) => {
+}, androidPermissions = (value, field2) => {
   if (value === undefined)
     return;
   if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
+    throw new TypeError(`${field2} must be an object.`);
   const { permissions } = value;
   if (!Array.isArray(permissions) || !permissions.every((permission) => typeof permission === "string" && ANDROID_PERMISSION_PATTERN.test(permission)))
-    throw new TypeError(`${field}.permissions must contain Android permission names.`);
+    throw new TypeError(`${field2}.permissions must contain Android permission names.`);
   return [...permissions];
-}, iosPrivacyAccessedApis = (value, field) => {
+}, iosPrivacyAccessedApis = (value, field2) => {
   if (value === undefined)
     return;
   if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
+    throw new TypeError(`${field2} must be an object.`);
   const privacy = {};
   for (const api of IOS_PRIVACY_ACCESSED_APIS) {
     const reasons = value[api];
@@ -623,17 +623,17 @@ var DEVICES_PACKAGE = "@absolutejs/devices", CAPACITOR_ADAPTER = "@absolutejs/de
       continue;
     const supported = IOS_PRIVACY_ACCESSED_API_REASONS[api];
     if (!Array.isArray(reasons) || reasons.length === 0 || !reasons.every((reason) => typeof reason === "string" && supported.has(reason)))
-      throw new TypeError(`${field} contains an unsupported API or reason.`);
+      throw new TypeError(`${field2} contains an unsupported API or reason.`);
     privacy[api] = [...reasons];
   }
   if (Object.keys(value).some((api) => !IOS_PRIVACY_ACCESSED_APIS.some((known) => known === api)))
-    throw new TypeError(`${field} contains an unsupported API or reason.`);
+    throw new TypeError(`${field2} contains an unsupported API or reason.`);
   return privacy;
-}, iosNativeRequirements = (value, field) => {
+}, iosNativeRequirements = (value, field2) => {
   if (value === undefined)
     return;
   if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
+    throw new TypeError(`${field2} must be an object.`);
   const {
     privacyAccessedApis,
     pushNotifications,
@@ -641,12 +641,12 @@ var DEVICES_PACKAGE = "@absolutejs/devices", CAPACITOR_ADAPTER = "@absolutejs/de
     usageDescriptions
   } = value;
   if (pushNotifications !== undefined && pushNotifications !== true)
-    throw new TypeError(`${field}.pushNotifications must be true.`);
+    throw new TypeError(`${field2}.pushNotifications must be true.`);
   if (systemBars !== undefined && systemBars !== true)
-    throw new TypeError(`${field}.systemBars must be true.`);
+    throw new TypeError(`${field2}.systemBars must be true.`);
   if (usageDescriptions !== undefined && (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose))))
-    throw new TypeError(`${field}.usageDescriptions contains an unsupported purpose.`);
-  const privacy = iosPrivacyAccessedApis(privacyAccessedApis, `${field}.privacyAccessedApis`);
+    throw new TypeError(`${field2}.usageDescriptions contains an unsupported purpose.`);
+  const privacy = iosPrivacyAccessedApis(privacyAccessedApis, `${field2}.privacyAccessedApis`);
   return {
     ...privacy === undefined ? {} : { privacyAccessedApis: privacy },
     ...pushNotifications === true ? { pushNotifications: true } : {},
@@ -771,8 +771,8 @@ var DEVICES_PACKAGE = "@absolutejs/devices", CAPACITOR_ADAPTER = "@absolutejs/de
 }, directAbsoluteProjectPackages = (projectRoot) => {
   const manifest = readJson(join13(resolve11(projectRoot), "package.json"));
   const packages = new Set;
-  for (const field of ["dependencies", "devDependencies"]) {
-    const dependencies = manifest[field];
+  for (const field2 of ["dependencies", "devDependencies"]) {
+    const dependencies = manifest[field2];
     if (object2(dependencies))
       for (const name of Object.keys(dependencies))
         packages.add(name);
@@ -2069,6 +2069,92 @@ var buildAbsoluteAndroidRelease = async (options) => {
   };
   return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
 };
+// src/mobile/androidUpgradeConformance.ts
+import { performance as performance2 } from "perf_hooks";
+var captureCommand3 = async (command) => {
+  const process2 = Bun.spawn(command, { stderr: "pipe", stdout: "pipe" });
+  const [exitCode, stderr, stdout] = await Promise.all([
+    process2.exited,
+    new Response(process2.stderr).text(),
+    new Response(process2.stdout).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var field = (output, name) => new RegExp(`^\\s*${name}=([^\\r\\n]+)$`, "mu").exec(output)?.[1]?.trim();
+var inspectAbsoluteAndroidInstalledApp = async (adb, serial, appId, run = captureCommand3) => {
+  const result = await run([
+    adb,
+    "-s",
+    serial,
+    "shell",
+    "dumpsys",
+    "package",
+    appId
+  ]);
+  if (result.exitCode !== 0)
+    throw new Error(`Could not inspect installed Android app ${appId}: ${result.stderr.trim() || result.stdout.trim()}`);
+  const installed = parseAbsoluteAndroidInstalledApp(appId, result.stdout);
+  if (!installed)
+    throw new Error(`Android app ${appId} is not installed on ${serial}.`);
+  return installed;
+};
+var parseAbsoluteAndroidInstalledApp = (appId, output) => {
+  const packageName = /^\s*Package \[([^\]]+)\]/mu.exec(output)?.[1];
+  if (packageName !== appId && !output.includes(`package:${appId}`))
+    return null;
+  const versionCodeText = /^\s*versionCode=(\d+)/mu.exec(output)?.[1];
+  return {
+    appId,
+    ...field(output, "dataDir") ? { dataDirectory: field(output, "dataDir") } : {},
+    ...field(output, "firstInstallTime") ? { firstInstallTime: field(output, "firstInstallTime") } : {},
+    ...field(output, "lastUpdateTime") ? { lastUpdateTime: field(output, "lastUpdateTime") } : {},
+    ...field(output, "userId") || field(output, "appId") ? { uid: field(output, "userId") ?? field(output, "appId") } : {},
+    ...versionCodeText ? { versionCode: Number(versionCodeText) } : {},
+    ...field(output, "versionName") ? { versionName: field(output, "versionName") } : {}
+  };
+};
+var unchanged = (name, before, after) => {
+  if (!before || !after)
+    throw new Error(`Android did not report ${name} for the upgrade proof.`);
+  if (before !== after)
+    throw new Error(`Android ${name} changed during the in-place upgrade.`);
+};
+var runAbsoluteAndroidUpgradeConformance = async (options) => {
+  const run = options.run ?? captureCommand3;
+  const startedAt = performance2.now();
+  const before = await inspectAbsoluteAndroidInstalledApp(options.adb, options.serial, options.appId, run);
+  const installStartedAt = performance2.now();
+  const installed = await run([
+    options.adb,
+    "-s",
+    options.serial,
+    "install",
+    "-r",
+    options.apkPath
+  ]);
+  const installMs = Math.round(performance2.now() - installStartedAt);
+  if (installed.exitCode !== 0 || !installed.stdout.includes("Success"))
+    throw new Error(`Android in-place upgrade failed: ${installed.stderr.trim() || installed.stdout.trim()}`);
+  const after = await inspectAbsoluteAndroidInstalledApp(options.adb, options.serial, options.appId, run);
+  unchanged("application UID", before.uid, after.uid);
+  unchanged("data directory", before.dataDirectory, after.dataDirectory);
+  unchanged("first install timestamp", before.firstInstallTime, after.firstInstallTime);
+  if (before.versionCode !== undefined && after.versionCode !== undefined && after.versionCode <= before.versionCode)
+    throw new Error(`Android versionCode did not increase (${before.versionCode} -> ${after.versionCode}).`);
+  await options.afterInstall?.(after);
+  const state = await options.verifyState();
+  const compatibilityPass = !options.compatibility || options.compatibility.nPlusOne === "compatible" && options.compatibility.nPlusTwo === "compatible" && options.compatibility.nPlusThree === "upgrade-required" && options.compatibility.rollback === "compatible";
+  const outcome = Object.values(state).every(Boolean) && compatibilityPass ? "pass" : "fail";
+  return {
+    after,
+    before,
+    ...options.compatibility ? { compatibility: options.compatibility } : {},
+    durationMs: Math.round(performance2.now() - startedAt),
+    installMs,
+    outcome,
+    state
+  };
+};
 // src/mobile/iosRelease.ts
 import { createHash as createHash5 } from "crypto";
 import {
@@ -3841,18 +3927,18 @@ var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
 var APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
 var CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
 var HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
-var resolveProjectPath = (projectRoot, value, field) => {
+var resolveProjectPath = (projectRoot, value, field2) => {
   const root = resolve6(projectRoot);
   const path = resolve6(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
-    throw new TypeError(`${field} must remain inside the project root.`);
+    throw new TypeError(`${field2} must remain inside the project root.`);
   }
   return path;
 };
-var requireText = (value, field) => {
+var requireText = (value, field2) => {
   const normalized = value.trim();
   if (!normalized)
-    throw new TypeError(`${field} must not be empty.`);
+    throw new TypeError(`${field2} must not be empty.`);
   return normalized;
 };
 var normalizeEntry = (entry) => {
@@ -3961,7 +4047,7 @@ var HTTP_OK = 200;
 var VERIFY_TIMEOUT_MS = 1e4;
 var ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json";
 var APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
-var missingIdentity = (field, platform) => new TypeError(`${field} is required to publish ${platform} deep-link association files.`);
+var missingIdentity = (field2, platform) => new TypeError(`${field2} is required to publish ${platform} deep-link association files.`);
 var createAppleDocument = (config, requireAll) => {
   if (!config.platforms.includes("ios"))
     return;
@@ -4298,8 +4384,8 @@ var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   if (priorAppIds.size > 1 || priorAppIds.size === 1 && !priorAppIds.has(options.appId)) {
     throw new TypeError("Previous mobile compatibility artifacts belong to another app.");
   }
-  const unchanged = options.previousArtifacts?.find((artifact2) => artifact2.appBuild === appBuild && artifact2.runtime === options.runtime);
-  const generation = unchanged?.generation ?? Math.max(0, ...(options.previousArtifacts ?? []).map((artifact2) => artifact2.generation)) + 1;
+  const unchanged2 = options.previousArtifacts?.find((artifact2) => artifact2.appBuild === appBuild && artifact2.runtime === options.runtime);
+  const generation = unchanged2?.generation ?? Math.max(0, ...(options.previousArtifacts ?? []).map((artifact2) => artifact2.generation)) + 1;
   const artifact = createAbsoluteMobileCompatibilityArtifact({
     appBuild,
     appId: options.appId,
@@ -5605,6 +5691,10 @@ var applyMobileCorsHeaders = (response, origin) => {
   response.headers.append("vary", "Origin");
   return response;
 };
+var finalizeMobileResponse = (request, response) => {
+  const origin = mobileWebViewOrigin(request);
+  return origin ? applyMobileCorsHeaders(response, origin) : response;
+};
 var mobilePreflightResponse = (request) => {
   if (request.method !== "OPTIONS")
     return;
@@ -5662,23 +5752,24 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
       return;
     const resolved = resolveAbsoluteMobileCompatibilityRelease(parsed.client, artifacts);
     if (resolved.kind === "upgrade-required") {
-      return createAbsoluteMobileUpgradeResponse(resolved.result);
+      return finalizeMobileResponse(request, createAbsoluteMobileUpgradeResponse(resolved.result));
     }
     if (!artifactOwnsRequest(resolved.artifact, parsed.client.pageId, request)) {
-      return createAbsoluteMobileInvalidRequestResponse("The requested URL is not assigned to this mobile page.");
+      return finalizeMobileResponse(request, createAbsoluteMobileInvalidRequestResponse("The requested URL is not assigned to this mobile page."));
     }
     if (resolved.artifact.releaseId === options.currentReleaseId) {
       return;
     }
     try {
       const producer = await resolveProducer(resolved.artifact);
-      return runWithAbsoluteMobileProducer({
+      const response = await runWithAbsoluteMobileProducer({
         page: resolved.page,
         releaseId: resolved.artifact.releaseId
       }, () => producer.handle(request));
+      return finalizeMobileResponse(request, response);
     } catch (error) {
       console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
-      return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
+      return finalizeMobileResponse(request, createAbsoluteMobilePageErrorResponse(parsed.client.pageId));
     }
   }).afterHandle("global", ({ request, responseValue }) => {
     const origin = mobileWebViewOrigin(request);
@@ -6841,6 +6932,7 @@ export {
   startAbsoluteIosDevSession,
   serializeAbsoluteMobileAuthEnvironment,
   runWithAbsoluteMobileProducer,
+  runAbsoluteAndroidUpgradeConformance,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
   resolveAbsoluteMobileNavigation,
@@ -6869,6 +6961,7 @@ export {
   parseAbsoluteMobileBuildPageMetadata,
   parseAbsoluteIosLogLine,
   parseAbsoluteIosHmrLog,
+  parseAbsoluteAndroidInstalledApp,
   pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
@@ -6888,6 +6981,7 @@ export {
   installAbsoluteMobileAuthEnvironment,
   inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
+  inspectAbsoluteAndroidInstalledApp,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
   getAbsoluteRemoteMacProfile,
@@ -6951,5 +7045,5 @@ export {
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=70D55943FDDD4B5264756E2164756E21
+//# debugId=D67F614C7C9ABE9264756E2164756E21
 //# sourceMappingURL=index.js.map