@absolutejs/absolute 0.20.0-beta.3 → 0.20.0-beta.31

package/dist/mobile/shellSync.js

@@ -0,0 +1,173 @@
+// src/mobile/shellSync.ts
+import { lifecycle, network } from "@absolutejs/devices";
+import {
+  createCapacitorSyncLocalStore,
+  createCapacitorSyncProtection,
+  AbsoluteBackgroundSync,
+  configureCapacitorBackgroundSync,
+  installCapacitorSyncLifecycle
+} from "@absolutejs/sync-capacitor";
+import { installSyncClientRuntimeTransport } from "@absolutejs/sync/client/runtime";
+
+// src/mobile/syncRemediation.ts
+import {
+  discardSyncRuntimeDeadLetter,
+  inspectSyncRuntime,
+  rebaseSyncRuntimeDeadLetter,
+  retrySyncRuntimeDeadLetter
+} from "@absolutejs/sync/client/runtime";
+var REMEDIATION_REGISTRY = Symbol.for("@absolutejs/mobile-sync-remediation");
+var isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var resolveRegistry = () => {
+  const existing = Reflect.get(globalThis, REMEDIATION_REGISTRY);
+  if (isRegistry(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(globalThis, REMEDIATION_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+};
+var registry = resolveRegistry();
+var installAbsoluteMobileSyncRemediation = (bridge = {
+  discard: discardSyncRuntimeDeadLetter,
+  inspect: inspectSyncRuntime,
+  rebase: rebaseSyncRuntimeDeadLetter,
+  retry: retrySyncRuntimeDeadLetter
+}) => {
+  const installation = { bridge };
+  registry.installations.push(installation);
+  return () => {
+    const index = registry.installations.indexOf(installation);
+    if (index >= 0)
+      registry.installations.splice(index, 1);
+  };
+};
+
+// src/mobile/shellSync.ts
+var reloadShell = () => globalThis.location.reload();
+var ABSOLUTE_MOBILE_SYNC_SCHEMA_EVENT = "absolute:sync-schema";
+var ABSOLUTE_MOBILE_SYNC_SCHEMA_STATE_KEY = "absolutejs.mobile.sync.schema-state";
+var ABSOLUTE_MOBILE_SYNC_STATUS_EVENT = "absolute:sync-status";
+var schemaStateSymbol = () => Symbol.for(ABSOLUTE_MOBILE_SYNC_SCHEMA_STATE_KEY);
+var readAbsoluteMobileSyncSchemaState = () => {
+  const value = Reflect.get(globalThis, schemaStateSymbol());
+  if (typeof value !== "object" || value === null)
+    return;
+  const state = Reflect.get(value, "state");
+  if (state === "preparing")
+    return { state };
+  if (state === "failed")
+    return schemaFailureState(value);
+  const minimumCompatibleVersion = Reflect.get(value, "minimumCompatibleVersion");
+  const storedVersion = Reflect.get(value, "storedVersion");
+  const targetVersion = Reflect.get(value, "targetVersion");
+  if (state !== "ready" || typeof minimumCompatibleVersion !== "number" || typeof storedVersion !== "number" || typeof targetVersion !== "number")
+    return;
+  return {
+    minimumCompatibleVersion,
+    state,
+    storedVersion,
+    targetVersion
+  };
+};
+var reportShellSchemaState = (state) => {
+  Reflect.set(globalThis, schemaStateSymbol(), state);
+  globalThis.dispatchEvent(new CustomEvent(ABSOLUTE_MOBILE_SYNC_SCHEMA_EVENT, { detail: state }));
+};
+var schemaFailureState = (error) => {
+  if (typeof error !== "object" || error === null)
+    return { code: "UNKNOWN", state: "failed" };
+  const rawCode = Reflect.get(error, "code");
+  const code = rawCode === "INVALID_PLAN" || rawCode === "MIGRATION_MISSING" || rawCode === "SCHEMA_TOO_NEW" || rawCode === "SCHEMA_TOO_OLD" ? rawCode : "UNKNOWN";
+  const storedVersion = Reflect.get(error, "storedVersion");
+  const targetVersion = Reflect.get(error, "targetVersion");
+  return {
+    code,
+    state: "failed",
+    ...typeof storedVersion === "number" ? { storedVersion } : {},
+    ...typeof targetVersion === "number" ? { targetVersion } : {}
+  };
+};
+var reportShellStatus = (status) => globalThis.dispatchEvent(new CustomEvent(ABSOLUTE_MOBILE_SYNC_STATUS_EVENT, { detail: status }));
+var installAbsoluteMobileShellSync = (auth, config, options = {}) => {
+  const namespace = auth.principal?.namespace;
+  const store = namespace ? options.createStore?.({
+    protection: createCapacitorSyncProtection(),
+    storageSchema: config?.storageSchema
+  }) ?? createCapacitorSyncLocalStore({
+    protection: createCapacitorSyncProtection(),
+    storageSchema: config?.storageSchema
+  }) : undefined;
+  const installLifecycle = options.installLifecycle ?? installCapacitorSyncLifecycle;
+  const reportStatus = options.reportStatus ?? reportShellStatus;
+  const reportSchemaState = options.reportSchemaState ?? reportShellSchemaState;
+  const configureBackground = options.configureBackground ?? configureCapacitorBackgroundSync;
+  const clearBackground = options.clearBackground ?? (() => AbsoluteBackgroundSync.clear());
+  if (store?.getSchemaStatus) {
+    reportSchemaState({ state: "preparing" });
+    store.getSchemaStatus().then(reportSchemaState).catch((error) => reportSchemaState(schemaFailureState(error)));
+  }
+  if (namespace && config) {
+    configureBackground({
+      clientId: auth.clientId,
+      endpoint: config.background.endpoint,
+      intervalMinutes: config.background.intervalMinutes,
+      issuer: auth.issuer,
+      namespace
+    }).catch((error) => console.error("[Absolute Mobile] Background Sync configuration failed:", error));
+  } else {
+    clearBackground().catch(() => {
+      return;
+    });
+  }
+  const removeTransport = installSyncClientRuntimeTransport({
+    ...namespace && store ? { durable: { namespace, store } } : {},
+    socketTicket: auth.socketTicket,
+    registerClient: (client) => {
+      let active2 = true;
+      const removeStatus = client.subscribeStatus(reportStatus);
+      const reportLifecycleFailure = (error) => console.error("[Absolute Mobile] Sync lifecycle installation failed:", error);
+      const removal = installLifecycle({
+        client,
+        lifecycle,
+        network
+      }).catch((error) => {
+        reportLifecycleFailure(error);
+        return;
+      });
+      return () => {
+        if (!active2)
+          return;
+        active2 = false;
+        removeStatus();
+        removal.then((remove) => remove?.());
+      };
+    }
+  });
+  const removeRemediation = installAbsoluteMobileSyncRemediation();
+  const reload = options.reload ?? reloadShell;
+  const removePrincipalListener = auth.onPrincipalChange((principal) => {
+    if (principal?.namespace !== namespace)
+      reload();
+  });
+  let active = true;
+  return () => {
+    if (!active)
+      return;
+    active = false;
+    removePrincipalListener();
+    removeRemediation();
+    removeTransport();
+  };
+};
+export {
+  readAbsoluteMobileSyncSchemaState,
+  installAbsoluteMobileShellSync,
+  ABSOLUTE_MOBILE_SYNC_STATUS_EVENT,
+  ABSOLUTE_MOBILE_SYNC_SCHEMA_STATE_KEY,
+  ABSOLUTE_MOBILE_SYNC_SCHEMA_EVENT
+};

package/dist/src/angular/pageHandler.d.ts

@@ -1,4 +1,5 @@
 import type { EnvironmentProviders, Provider } from '@angular/core';
+import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
@@ -9,6 +10,8 @@ type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
  *  passes no generic at all) can omit `requestContext`. */
 type HasNoRequiredContextKeys<Ctx> = keyof Ctx extends never ? true : Partial<Ctx> extends Ctx ? true : false;
 export type AngularPageRequestInput<Ctx = unknown> = AngularPageRenderOptions & {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
     headTag?: `<head>${string}</head>`;
     indexPath: string;
     pagePath: string;

package/dist/src/build/pwa.d.ts

@@ -0,0 +1,16 @@
+import type { PwaConfig } from '../../types/build';
+export declare const injectPwaBootstrapHtml: (html: string) => string;
+export type AbsolutePwaBuildArtifacts = {
+    bootstrapBanner: string;
+    bootstrapPublicPath: string;
+    manifestPath?: string;
+    serviceWorkerPath: string;
+};
+export declare const materializeAbsolutePwa: ({ buildPath, config, generatedRoot, projectRoot, write }: {
+    buildPath: string;
+    config: PwaConfig;
+    generatedRoot: string;
+    projectRoot: string;
+    /** Incremental HMR builds reuse the stable artifacts from the full build. */
+    write?: boolean;
+}) => Promise<AbsolutePwaBuildArtifacts>;

package/dist/src/cli/config/server.d.ts

@@ -391,7 +391,7 @@ export declare const launchConfig: (args: string[], cwd?: string) => Promise<imp
         status?: number | keyof import("elysia").StatusMap;
         cookie?: Record<string, import("elysia").BaseCookie>;
     };
-    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 426 | 302 | 101 | 102 | 103 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 301 | 303 | 307 | 308 | 401 | 402 | 403 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 428 | 429 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 426 | 204 | 302 | 101 | 102 | 103 | 201 | 202 | 203 | 205 | 206 | 207 | 208 | 301 | 303 | 307 | 308 | 401 | 402 | 403 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 428 | 429 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

package/dist/src/core/devBuild.d.ts

@@ -1,5 +1,6 @@
 import type { BuildConfig } from '../../types/build';
 declare const FRAMEWORK_DIR_KEYS: readonly ["reactDirectory", "svelteDirectory", "vueDirectory", "htmlDirectory", "htmxDirectory", "angularDirectory"];
+export declare const collectDepVendorSourceDirs: (config: BuildConfig) => string[];
 /** Result of `detectConfigChanges`: which framework dir keys were
  *  added and which were removed in the new config. The additive case
  *  is handled in-place by this function (vendor paths set, watchers

package/dist/src/core/pageHandlers.d.ts

@@ -1,5 +1,14 @@
 import { type StreamingSlotEnhancerOptions } from './responseEnhancers';
+import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 export type StaticPageRequestOptions = StreamingSlotEnhancerOptions;
-export type HTMLPageRequestOptions = StaticPageRequestOptions;
+export type HTMLPageRequestOptions = StaticPageRequestOptions & {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
+};
+type HTMXPageRequestOptions = {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
+};
 export declare const handleHTMLPageRequest: (pagePath: string, options?: HTMLPageRequestOptions) => Promise<Response>;
-export declare const handleHTMXPageRequest: (pagePath: string) => Promise<Response>;
+export declare const handleHTMXPageRequest: (pagePath: string, options?: HTMXPageRequestOptions) => Promise<Response>;
+export {};

package/dist/src/core/prepare.d.ts

@@ -37,6 +37,18 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                     error: never;
                 };
             };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {
@@ -173,6 +185,18 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                     error: never;
                 };
             };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {

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

@@ -56,6 +56,9 @@ export type StartAbsoluteAndroidDevOptions = {
     onPhaseTiming?: (timing: AbsoluteAndroidDevPhaseTiming) => void;
     onStateChange?: (state: AbsoluteAndroidDevState) => void;
     https?: boolean;
+    /** Launch the locally embedded production web bundle while forwarding
+     * `port` only for its configured backend. No dev-server URL is written. */
+    embeddedBundle?: boolean;
     port: number;
     project: AbsoluteAndroidDevProject;
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
@@ -67,7 +70,9 @@ export type StartAbsoluteAndroidDevOptions = {
 export declare const redactAbsoluteAndroidLog: (value: string) => string;
 export declare const isIgnorableAbsoluteAndroidLog: (entry: AbsoluteAndroidNativeLogEntry) => boolean;
 export declare const parseAbsoluteAndroidLogLine: (line: string) => AbsoluteAndroidNativeLogEntry | null;
-export declare const fingerprintAbsoluteAndroidNativeProject: (project: Pick<AbsoluteAndroidDevProject, "nativeDirectory">) => Promise<string>;
+export declare const fingerprintAbsoluteAndroidNativeProject: (project: Pick<AbsoluteAndroidDevProject, "nativeDirectory">, options?: {
+    includePublicBundle?: boolean;
+}) => Promise<string>;
 export declare const repairAbsoluteAndroidDevSession: (projectRoot: string) => Promise<boolean>;
 export declare const parseAdbDevices: (output: string) => string[];
 export type AbsoluteAndroidGradleTask = 'assembleDebug' | 'assembleRelease' | 'bundleRelease';

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

@@ -0,0 +1,14 @@
+import { type AbsoluteNativeAutomatedRun } from './nativeTestReport';
+export type AbsoluteAndroidAutomatedResult = Omit<AbsoluteNativeAutomatedRun, 'platform' | 'targetId' | 'targetKind'> & {
+    serial: string;
+};
+type CreateAbsoluteAndroidTestReportOptions = {
+    absolutejsVersion: string;
+    adbVersion: string;
+    bunVersion: string;
+    generatedAt?: string;
+    host: string;
+    run: AbsoluteAndroidAutomatedResult;
+};
+export declare const createAbsoluteAndroidTestReport: (options: CreateAbsoluteAndroidTestReportOptions) => import("./nativeTestReport").AbsoluteNativeTestReport;
+export {};

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

@@ -0,0 +1,47 @@
+export type AbsoluteAndroidInstalledApp = {
+    appId: string;
+    dataDirectory?: string;
+    firstInstallTime?: string;
+    lastUpdateTime?: string;
+    uid?: string;
+    versionCode?: number;
+    versionName?: string;
+};
+export type AbsoluteAndroidUpgradeState = {
+    authCredential: boolean;
+    pendingOperations: boolean;
+    syncDatabase: boolean;
+};
+export type AbsoluteAndroidCompatibilityMatrix = {
+    nPlusOne: 'compatible' | 'upgrade-required';
+    nPlusTwo: 'compatible' | 'upgrade-required';
+    nPlusThree: 'compatible' | 'upgrade-required';
+    rollback: 'compatible' | 'failed';
+};
+export type AbsoluteAndroidUpgradeConformanceResult = {
+    after: AbsoluteAndroidInstalledApp;
+    before: AbsoluteAndroidInstalledApp;
+    compatibility?: AbsoluteAndroidCompatibilityMatrix;
+    durationMs: number;
+    installMs: number;
+    outcome: 'fail' | 'pass';
+    state: AbsoluteAndroidUpgradeState;
+};
+export type AbsoluteAndroidUpgradeCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type RunAbsoluteAndroidUpgradeConformanceOptions = {
+    adb: string;
+    afterInstall?: (installed: AbsoluteAndroidInstalledApp) => Promise<void>;
+    apkPath: string;
+    appId: string;
+    compatibility?: AbsoluteAndroidCompatibilityMatrix;
+    run?: (command: string[]) => Promise<AbsoluteAndroidUpgradeCommandResult>;
+    serial: string;
+    verifyState: () => Promise<AbsoluteAndroidUpgradeState>;
+};
+export declare const inspectAbsoluteAndroidInstalledApp: (adb: string, serial: string, appId: string, run?: (command: string[]) => Promise<AbsoluteAndroidUpgradeCommandResult>) => Promise<AbsoluteAndroidInstalledApp>;
+export declare const parseAbsoluteAndroidInstalledApp: (appId: string, output: string) => AbsoluteAndroidInstalledApp | null;
+export declare const runAbsoluteAndroidUpgradeConformance: (options: RunAbsoluteAndroidUpgradeConformanceOptions) => Promise<AbsoluteAndroidUpgradeConformanceResult>;

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

@@ -25,6 +25,7 @@ export type AbsoluteAndroidWebViewSession = {
     screenshot: (path: string) => Promise<string>;
     serial: string;
     socket: string;
+    tap: (x: number, y: number) => Promise<void>;
     target: CdpTarget;
     waitFor: <T>(expression: string, options?: {
         timeoutMs?: number;

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

@@ -1,2 +1,3 @@
 export * from './client';
 export * from './pageProtocol';
+export * from './syncRemediation';

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

@@ -1,6 +1,7 @@
 import type { MobileConfig } from '../../types/build';
 export type FinalizeAbsoluteMobileBuildOptions = {
     buildDirectory: string;
+    configPath?: string;
     mobile: MobileConfig;
     producerPath: string;
     projectRoot: string;

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

@@ -1,19 +1,36 @@
 import type { NormalizedAbsoluteMobileConfig } from './config';
 import type { AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+import type { AbsoluteMobileAuthManifest } from './nativeAuth';
+import type { SyncLocalStoreSchemaBundle } from '@absolutejs/sync/client';
+import type { AbsoluteDeviceCapabilityPlan } from './deviceCapabilities';
 export type AbsoluteCapacitorBundleOptions = {
     artifact: AbsoluteMobileCompatibilityArtifact;
+    auth?: AbsoluteMobileAuthManifest;
     buildDirectory: string;
     config: NormalizedAbsoluteMobileConfig;
+    deviceCapabilities: AbsoluteDeviceCapabilityPlan;
+    projectRoot: string;
+    sync?: boolean;
+    syncSchema?: SyncLocalStoreSchemaBundle;
 };
 export declare const materializeAbsoluteCapacitorWebBundle: (options: AbsoluteCapacitorBundleOptions) => Promise<{
-    appBuild: string;
+    sync?: {
+        background: {
+            endpoint: string;
+            intervalMinutes: number;
+        };
+        socketTickets: true;
+        storageSchema: SyncLocalStoreSchemaBundle;
+    } | undefined;
     appId: string;
     appName: string;
     deepLinkHosts: string[];
     deepLinkScheme: string | undefined;
+    deviceCapabilities: string[];
     entry: string;
     format: 1;
     pages: {
+        localStylePath?: string | undefined;
         localBundlePath: string;
         bundleHash: string;
         bundlePath: string;
@@ -21,8 +38,12 @@ export declare const materializeAbsoluteCapacitorWebBundle: (options: AbsoluteCa
         framework: import("./pageProtocol").AbsoluteMobilePageFramework;
         pageId: string;
         propsSchemaHash: string;
+        styleBundleHash?: string;
+        styleBundlePath?: string;
     }[];
     productionOrigin: string;
     routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
     runtime: string;
+    auth?: AbsoluteMobileAuthManifest | undefined;
+    appBuild: string;
 }>;

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

@@ -1,6 +1,9 @@
 import { type AbsoluteMobilePageResult, type AbsoluteMobileUpgradeRequiredResult } from './pageProtocol';
 type AbsoluteMobileClientTarget = {
+    __ABSOLUTE_PAGE_DISPOSE__?: () => Promise<void> | void;
+    __ABSOLUTE_PAGE_READY__?: Promise<unknown>;
     __ABSOLUTE_PAGE_RENDER_MODE__?: 'client' | 'hydrate';
+    __ABS_ANGULAR_REQUEST_CONTEXT__?: Record<string, unknown>;
     __INITIAL_PROPS__?: Record<string, unknown>;
 };
 export type AbsoluteMobilePageLoader = (input: {
@@ -20,6 +23,7 @@ export declare class AbsoluteMobilePageProtocolError extends Error {
     readonly code: 'invalid-envelope' | 'invalid-props' | 'server-error' | 'server-rejected-request';
     constructor(code: AbsoluteMobilePageProtocolError['code'], message: string);
 }
+export declare const disposeAbsoluteMobilePage: (target?: AbsoluteMobileClientTarget) => Promise<void>;
 export declare const activateAbsoluteMobilePage: (value: unknown, options: AbsoluteMobilePageActivationOptions) => Promise<AbsoluteMobileUpgradeRequiredResult | {
     contract: string;
     kind: "rendered";

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

@@ -13,5 +13,6 @@ export type NormalizedAbsoluteMobileConfig = {
     nativeProjectDirectory: string;
     platforms: MobilePlatform[];
     productionOrigin: string;
+    pushAndroidGoogleServicesFile: string;
 };
 export declare const normalizeAbsoluteMobileConfig: (config: MobileConfig, projectRoot: string) => NormalizedAbsoluteMobileConfig;

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

@@ -0,0 +1,3 @@
+import type { MobileConfig } from '../../types/build';
+export declare const absoluteNativeDevAdapterSource: (projectRoot: string, mobile: MobileConfig, resolveModule?: (specifier: string) => string) => string;
+export declare const buildAbsoluteNativeDevAdapter: (projectRoot: string, mobile: MobileConfig) => Promise<string>;

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

@@ -0,0 +1,46 @@
+export type AbsoluteDeviceCapabilityProvider = {
+    factory: string;
+    module: string;
+    native?: {
+        android?: {
+            permissions: string[];
+        };
+        ios?: {
+            privacyAccessedApis?: Partial<Record<AbsoluteIosPrivacyAccessedApi, string[]>>;
+            pushNotifications?: true;
+            systemBars?: true;
+            usageDescriptions?: AbsoluteIosUsageDescription[];
+        };
+    };
+    packages: string[];
+};
+export type AbsoluteIosUsageDescription = 'camera' | 'location-always' | 'location-when-in-use' | 'photo-library' | 'photo-library-add';
+export type AbsoluteIosPrivacyAccessedApi = 'NSPrivacyAccessedAPICategoryFileTimestamp';
+export type AbsoluteDeviceCapabilityPlan = {
+    capabilities: string[];
+    providers: Record<string, AbsoluteDeviceCapabilityProvider>;
+    requiredPackages: string[];
+};
+export declare const absoluteDeviceNativeRequirements: (plan: AbsoluteDeviceCapabilityPlan) => {
+    androidPermissions: string[];
+    iosPrivacyAccessedApis: {
+        api: "NSPrivacyAccessedAPICategoryFileTimestamp";
+        reasons: string[];
+    }[];
+    iosPushNotifications: boolean;
+    iosSystemBars: boolean;
+    iosUsageDescriptions: AbsoluteIosUsageDescription[];
+};
+export declare const loadAbsoluteDeviceCapabilityProviders: (projectRoot: string) => {
+    [k: string]: AbsoluteDeviceCapabilityProvider;
+};
+export declare const assertAbsoluteDeviceCapabilityPackages: (projectRoot: string, plan: AbsoluteDeviceCapabilityPlan) => void;
+export declare const directAbsoluteProjectPackages: (projectRoot: string) => Set<string>;
+export declare const discoverAbsoluteDeviceCapabilities: (projectRoot: string, providers?: {
+    [k: string]: AbsoluteDeviceCapabilityProvider;
+}) => string[];
+export declare const missingAbsoluteDeviceCapabilityPackages: (plan: AbsoluteDeviceCapabilityPlan, directPackages: ReadonlySet<string>) => string[];
+/** Framework-agnostic capability discovery used by web/PWA builds. This does
+ * not load a native provider manifest, so Web Push never requires Capacitor. */
+export declare const projectImportsAbsoluteDeviceCapability: (projectRoot: string, capability: string) => boolean;
+export declare const resolveAbsoluteDeviceCapabilityPlan: (projectRoot: string) => AbsoluteDeviceCapabilityPlan;

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

@@ -1,24 +1,32 @@
 export * from './artifactStore';
 export * from './androidRelease';
+export * from './androidUpgradeConformance';
 export * from './iosRelease';
 export * from './iosConformance';
 export * from './iosSimulatorController';
 export * from './iosNativeWatcher';
+export * from './remoteMacProtocol';
 export * from './associationFiles';
 export * from './buildMetadata';
 export * from './buildPipeline';
 export * from './buildRelease';
 export * from './capacitorBundle';
+export * from './syncSchema';
+export * from './syncRemediation';
+export * from './deviceCapabilities';
 export * from './capacitorProject';
 export * from './config';
 export * from './client';
 export * from './compatibilityDispatcher';
 export * from './materializedBundle';
 export * from './nativeDeepLinks';
+export * from './nativeDeviceCapabilities';
+export * from './nativeAuth';
 export * from './pageProtocol';
 export * from './producerContext';
 export * from './releaseArtifact';
 export * from './releasePublisher';
 export * from './routeMetadataTransform';
 export * from './routeMatcher';
+export * from './shellHttp';
 export * from './transport';

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

@@ -0,0 +1,23 @@
+import { type AbsoluteNativeAutomatedRun, type AbsoluteNativeTestReport } from './nativeTestReport';
+export type AbsoluteIosAutomatedResult = Omit<AbsoluteNativeAutomatedRun, 'platform' | 'targetId' | 'targetKind'> & {
+    udid: string;
+};
+export type AbsoluteIosPartnerReport = AbsoluteNativeTestReport;
+type CreateAbsoluteIosPartnerReportOptions = {
+    absolutejsVersion: string;
+    bunVersion: string;
+    generatedAt?: string;
+    macosVersion: string;
+    run: AbsoluteIosAutomatedResult;
+    xcodeVersion: string;
+};
+export declare const readPackageVersionForIosReport: (packageJsonPath: string) => Promise<string>;
+export declare const renderAbsoluteIosPartnerReport: (report: AbsoluteNativeTestReport) => string;
+export declare const sanitizeIosReportText: (value: string) => string;
+export declare const writeAbsoluteIosPartnerReport: (directory: string, report: AbsoluteNativeTestReport) => Promise<{
+    directory: string;
+    jsonPath: string;
+    markdownPath: string;
+}>;
+export declare const createAbsoluteIosPartnerReport: (options: CreateAbsoluteIosPartnerReportOptions) => AbsoluteNativeTestReport;
+export {};

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

@@ -0,0 +1,17 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const ABSOLUTE_AUTH_PACKAGE: "@absolutejs/auth";
+export declare const ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV: "ABSOLUTE_AUTH_NATIVE_CLIENTS";
+export declare const ABSOLUTE_NATIVE_AUTH_SCOPES: readonly ["openid", "profile"];
+export declare const ABSOLUTE_SYNC_PACKAGE: "@absolutejs/sync";
+export type AbsoluteMobileAuthManifest = {
+    clientId: string;
+    issuer: string;
+    redirectUri: string;
+    scopes: string[];
+};
+export declare const createAbsoluteMobileAuthManifest: (config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest;
+export declare const installAbsoluteMobileAuthEnvironment: (projectRoot: string, config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest | undefined;
+export declare const projectUsesAbsoluteAuth: (projectRoot: string) => boolean;
+export declare const projectUsesAbsoluteSync: (projectRoot: string) => boolean;
+export declare const resolveAbsoluteMobileAuthManifest: (projectRoot: string, config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest | undefined;
+export declare const serializeAbsoluteMobileAuthEnvironment: (config: NormalizedAbsoluteMobileConfig, auth: AbsoluteMobileAuthManifest | undefined) => string | undefined;

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

@@ -0,0 +1,4 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const applyAbsoluteNativeBackgroundSync: (projectRoot: string, config: NormalizedAbsoluteMobileConfig, platforms?: import("..").MobilePlatform[]) => Promise<{
+    changed: boolean;
+}>;

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

@@ -0,0 +1,6 @@
+import type { MobilePlatform } from '../../types/build';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import { type AbsoluteDeviceCapabilityPlan } from './deviceCapabilities';
+export declare const applyAbsoluteNativeDeviceCapabilities: (projectRoot: string, config: NormalizedAbsoluteMobileConfig, platforms?: readonly MobilePlatform[], plan?: AbsoluteDeviceCapabilityPlan) => Promise<{
+    changed: MobilePlatform[];
+}>;