@absolutejs/absolute 0.20.0-beta.5 → 0.20.0-beta.50

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

@@ -37,6 +37,337 @@ 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: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                        error: never;
+                    };
+                };
+            };
+        };
+        "@src": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@stub": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@hmr": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@ng": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        hmr: {
+            subscribe: {
+                body: unknown;
+                headers: unknown;
+                query: unknown;
+                params: {};
+                response: {};
+            };
+        };
+        "hmr-status": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        connectedClients: number;
+                        connectedTargets: {
+                            [k: string]: number;
+                        };
+                        entryWatcherReady: boolean;
+                        isRebuilding: boolean;
+                        manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
+                        rebuildCount: number;
+                        rebuildQueue: string[];
+                        rebuildScheduled: boolean;
+                        timestamp: number;
+                    };
+                };
+                error: never;
+            };
+        };
+    } | {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {};
+                error: never;
+            };
+        };
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        ".well-known": {
+            appspecific: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                        error: never;
+                    };
+                };
+            };
+        };
+        "@src": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@stub": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@hmr": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@ng": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        hmr: {
+            subscribe: {
+                body: unknown;
+                headers: unknown;
+                query: unknown;
+                params: {};
+                response: {};
+            };
+        };
+        "hmr-status": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        connectedClients: number;
+                        connectedTargets: {
+                            [k: string]: number;
+                        };
+                        entryWatcherReady: boolean;
+                        isRebuilding: boolean;
+                        manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
+                        rebuildCount: number;
+                        rebuildQueue: string[];
+                        rebuildScheduled: boolean;
+                        timestamp: number;
+                    };
+                };
+                error: never;
+            };
+        };
+    } | {
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview-telemetry": {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: {
+                            readonly error: "invalid-preview-telemetry";
+                        };
+                        204: "No Content";
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {
@@ -141,8 +472,11 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                         entryWatcherReady: boolean;
                         isRebuilding: boolean;
                         manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
                         rebuildCount: number;
                         rebuildQueue: string[];
+                        rebuildScheduled: boolean;
                         timestamp: number;
                     };
                 };
@@ -173,6 +507,45 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                     error: never;
                 };
             };
+            "mobile-preview": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview-telemetry": {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: {
+                            readonly error: "invalid-preview-telemetry";
+                        };
+                        204: "No Content";
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {
@@ -277,8 +650,11 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                         entryWatcherReady: boolean;
                         isRebuilding: boolean;
                         manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
                         rebuildCount: number;
                         rebuildQueue: string[];
+                        rebuildScheduled: boolean;
                         timestamp: number;
                     };
                 };

package/dist/src/dev/clientManager.d.ts

@@ -17,6 +17,7 @@ export type HMRState = {
     isRebuilding: boolean;
     rebuildQueue: Set<string>;
     rebuildTimeout: NodeJS.Timeout | null;
+    pendingBundleRebuilds: Set<'angular' | 'svelte' | 'vue'>;
     fileChangeQueue: Map<string, string[]>;
     debounceTimeout: NodeJS.Timeout | null;
     fileHashes: Map<string, number>;

package/dist/src/dev/devCert.d.ts

@@ -1,11 +1,13 @@
+export declare const normalizeDevCertificateHosts: (hosts?: readonly string[]) => string[];
 export declare const hasMkcert: () => boolean;
-export declare const ensureDevCert: () => {
+export declare const ensureDevCert: (hosts?: readonly string[]) => {
     cert: string;
     key: string;
 } | null;
-export declare const hasCert: () => boolean;
-export declare const loadDevCert: () => {
+export declare const hasCert: (hosts?: readonly string[]) => boolean;
+export declare const loadDevCert: (hosts?: readonly string[]) => {
     cert: string;
     key: string;
 } | null;
-export declare const setupMkcert: () => boolean;
+export declare const getDevCertificateAuthorityPath: () => string | null;
+export declare const setupMkcert: (hosts?: readonly string[]) => boolean;

package/dist/src/dev/serverEntryCopies.d.ts

@@ -0,0 +1,3 @@
+export declare const absoluteServerEntryCopyOwnerPid: (name: string) => number | null;
+export declare const isProcessAlive: (pid: number) => boolean;
+export declare const isStaleAbsoluteServerEntryCopy: (name: string, currentPid?: number, ownerIsAlive?: (pid: number) => boolean) => boolean;

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

@@ -24,7 +24,7 @@ export type AbsoluteAndroidDevProject = {
     androidRoot: string;
     cap: string;
     config: NormalizedAbsoluteMobileConfig;
-    emulator: string;
+    emulator?: string;
     host: AbsoluteMobileHost;
     nativeDirectory: string;
     projectRoot: string;
@@ -47,6 +47,7 @@ export type AbsoluteAndroidDevPhaseTiming = {
 export type PrepareAbsoluteAndroidDevOptions = {
     createNativeProject: boolean;
     projectRoot: string;
+    target?: 'device' | 'emulator';
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
 };
 export type StartAbsoluteAndroidDevOptions = {
@@ -59,8 +60,14 @@ export type StartAbsoluteAndroidDevOptions = {
     /** Launch the locally embedded production web bundle while forwarding
      * `port` only for its configured backend. No dev-server URL is written. */
     embeddedBundle?: boolean;
+    /** A connected physical device selected explicitly by ADB serial. */
+    deviceSerial?: string;
+    /** CA certificate temporarily trusted only by this development app. */
+    certificateAuthorityPath?: string;
     port: number;
     project: AbsoluteAndroidDevProject;
+    /** Hostname or LAN address loaded by the physical device. */
+    serverHost?: string;
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
     signal?: AbortSignal;
     sleep?: (milliseconds: number) => Promise<void>;

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

@@ -7,7 +7,7 @@ export type AbsoluteAndroidReleaseMetadata = {
     appId: string;
     artifact: string;
     bytes: number;
-    engine: 'capacitor';
+    engine: 'capacitor' | 'expo';
     format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
     platform: 'android';
     releaseId: string;
@@ -22,12 +22,19 @@ export type BuildAbsoluteAndroidReleaseOptions = {
     androidRoot?: string;
     capture?: (command: string[], options?: AbsoluteAndroidCommandOptions) => AbsoluteAndroidCommandResult;
     config: NormalizedAbsoluteMobileConfig;
+    env?: Record<string, string | undefined>;
     host?: AbsoluteMobileHost;
     jarsigner?: string | null;
     outputDirectory?: string;
     projectRoot: string;
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
     prepareVersionCode?: (buildIdentity: string) => Promise<number>;
+    signing?: {
+        keyAlias: string;
+        keyPasswordEnvironment: string;
+        keystorePath: string;
+        storePasswordEnvironment: string;
+    };
     versionCode?: number;
 };
 export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroidReleaseOptions) => Promise<{
@@ -43,7 +50,7 @@ export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroid
         appBuild: string;
         appId: string;
         platform: "android";
-        engine: "capacitor";
+        engine: "capacitor" | "expo";
         signed: boolean;
         versionCode?: number | undefined;
     };

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/capacitorBundle.d.ts

@@ -1,21 +1,32 @@
 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<{
     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: {

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

@@ -0,0 +1,26 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT: 1;
+export type AbsoluteMobileGithubWorkflowOptions = {
+    config: NormalizedAbsoluteMobileConfig;
+    configPath?: string;
+    force?: boolean;
+    includePublishing?: boolean;
+    outputPath?: string;
+    projectRoot: string;
+    registryModule?: string;
+    secretEnvironment?: readonly string[];
+    serverEntry?: string;
+};
+export type AbsoluteMobileGithubWorkflowResult = {
+    changed: boolean;
+    format: typeof ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT;
+    path: string;
+    platforms: ('android' | 'ios')[];
+    publishing: boolean;
+    requiredSecrets: string[];
+};
+export declare const createAbsoluteMobileGithubWorkflow: (options: AbsoluteMobileGithubWorkflowOptions) => {
+    requiredSecrets: string[];
+    workflow: string;
+};
+export declare const writeAbsoluteMobileGithubWorkflow: (options: AbsoluteMobileGithubWorkflowOptions) => Promise<AbsoluteMobileGithubWorkflowResult>;

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

@@ -7,11 +7,14 @@ export type NormalizedAbsoluteMobileConfig = {
     bundleDirectory: string;
     deepLinkHosts: string[];
     deepLinkScheme?: string;
-    engine: 'capacitor';
+    engine: 'capacitor' | 'expo';
     entry: string;
+    expoNativeRoutes: Record<string, string>;
+    expoSdkVersion?: 57;
     iosVersion?: string;
     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, expoAdapterModule?: string, expoAuthModule?: string, expoSyncModule?: string) => string;
+export declare const buildAbsoluteNativeDevAdapter: (projectRoot: string, mobile: MobileConfig) => Promise<string>;