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

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

@@ -0,0 +1,136 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import { inspectAbsoluteMobileRelease } from './releaseDoctor';
+import { type MobileBundleInspection } from './mobileBundleInspection';
+export declare const ABSOLUTE_MOBILE_INSPECTION_FORMAT: 1;
+type MobilePackageInspection = {
+    declared: string;
+    installed?: string;
+    name: string;
+};
+export type AbsoluteMobileProjectInspection = {
+    bundle: MobileBundleInspection;
+    capabilities: {
+        current: string[];
+        embeddedMatchesCurrent?: boolean;
+        issue?: string;
+        plugins: string[];
+    };
+    config: {
+        appId: string;
+        appName: string;
+        bundleDirectory: string;
+        deepLinkHosts: string[];
+        deepLinkScheme?: string;
+        engine: 'capacitor' | 'expo';
+        entry: string;
+        iosVersion?: string;
+        nativeProjectDirectory: string;
+        platforms: string[];
+        productionOrigin: string;
+    };
+    format: typeof ABSOLUTE_MOBILE_INSPECTION_FORMAT;
+    nativeProjects: Array<{
+        initialized: boolean;
+        path: string;
+        platform: string;
+    }>;
+    packages: MobilePackageInspection[];
+    release: {
+        checks: Array<{
+            id: string;
+            status: 'fail' | 'pass' | 'warn';
+        }>;
+        ready: boolean;
+    };
+    runtime: {
+        absolutejs: string;
+    };
+};
+export type InspectAbsoluteMobileProjectOptions = {
+    absolutejsVersion?: string;
+    inspectRelease?: typeof inspectAbsoluteMobileRelease;
+};
+export declare const inspectAbsoluteMobileProject: (config: NormalizedAbsoluteMobileConfig, projectRoot: string, options?: InspectAbsoluteMobileProjectOptions) => Promise<{
+    bundle: {
+        manifest: string;
+        status: "missing";
+        appBuild?: undefined;
+        auth?: undefined;
+        capabilities?: undefined;
+        entryResolved?: undefined;
+        frameworks?: undefined;
+        pageCount?: undefined;
+        routeCount?: undefined;
+        runtime?: undefined;
+        sync?: undefined;
+        issue?: undefined;
+    } | {
+        appBuild: string;
+        auth: boolean;
+        capabilities: string[];
+        entryResolved: true;
+        frameworks: string[];
+        manifest: string;
+        pageCount: number;
+        routeCount: number;
+        runtime: string;
+        status: "valid";
+        sync: boolean;
+        issue?: undefined;
+    } | {
+        issue: string;
+        manifest: string;
+        status: "invalid";
+        appBuild?: undefined;
+        auth?: undefined;
+        capabilities?: undefined;
+        entryResolved?: undefined;
+        frameworks?: undefined;
+        pageCount?: undefined;
+        routeCount?: undefined;
+        runtime?: undefined;
+        sync?: undefined;
+    };
+    capabilities: {
+        plugins: string[];
+        issue?: string | undefined;
+        embeddedMatchesCurrent?: boolean | undefined;
+        current: string[];
+    };
+    config: {
+        appId: string;
+        appName: string;
+        bundleDirectory: string;
+        deepLinkHosts: string[];
+        deepLinkScheme: string | undefined;
+        engine: "capacitor" | "expo";
+        entry: string;
+        iosVersion: string | undefined;
+        nativeProjectDirectory: string;
+        platforms: import("..").MobilePlatform[];
+        productionOrigin: string;
+    };
+    format: 1;
+    nativeProjects: {
+        initialized: boolean;
+        path: string;
+        platform: import("..").MobilePlatform;
+    }[];
+    packages: {
+        name: string;
+        installed?: string | undefined;
+        declared: string;
+    }[];
+    release: {
+        checks: {
+            id: string;
+            status: "pass" | "warn" | "fail";
+        }[];
+        ready: boolean;
+    };
+    runtime: {
+        absolutejs: string;
+    };
+}>;
+export declare const renderAbsoluteMobileProjectInspection: (report: AbsoluteMobileProjectInspection) => string;
+export {};

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

@@ -0,0 +1,174 @@
+import { Elysia } from 'elysia';
+import type { MobileConfig } from '../../types/build';
+export declare const ABSOLUTE_MOBILE_PREVIEW_PATH: "/__absolute/mobile-preview";
+export declare const absoluteMobilePreviewDocument: (mobile: MobileConfig) => string;
+export declare const createAbsoluteMobilePreviewPlugin: (mobile: MobileConfig | undefined) => Elysia<"", "local", import("elysia/types").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral> | import("elysia/types").AddRoute<"", "local", import("elysia/types").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia/types").DefaultMetadata, {
+    __absolute: {
+        "mobile-preview": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+                error: never;
+            };
+        };
+    };
+}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral, "post", "/__absolute/mobile-preview-telemetry", import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, "/__absolute/mobile-preview-telemetry">, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, ({ body, status }: {
+    body: unknown;
+    query: Record<string, string | undefined>;
+    params: {};
+    headers: Record<string, string | undefined>;
+    cookie: Record<string, import("elysia").Cookie<unknown>>;
+    server: import("elysia").Server | null;
+    redirect: import("elysia").redirect;
+    set: {
+        headers: import("elysia").HTTPHeaders;
+        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 | 204 | 101 | 102 | 103 | 201 | 202 | 203 | 205 | 206 | 207 | 208 | 301 | 302 | 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";
+        readonly 103: "Early Hints";
+        readonly 200: "OK";
+        readonly 201: "Created";
+        readonly 202: "Accepted";
+        readonly 203: "Non-Authoritative Information";
+        readonly 204: "No Content";
+        readonly 205: "Reset Content";
+        readonly 206: "Partial Content";
+        readonly 207: "Multi-Status";
+        readonly 208: "Already Reported";
+        readonly 300: "Multiple Choices";
+        readonly 301: "Moved Permanently";
+        readonly 302: "Found";
+        readonly 303: "See Other";
+        readonly 304: "Not Modified";
+        readonly 307: "Temporary Redirect";
+        readonly 308: "Permanent Redirect";
+        readonly 400: "Bad Request";
+        readonly 401: "Unauthorized";
+        readonly 402: "Payment Required";
+        readonly 403: "Forbidden";
+        readonly 404: "Not Found";
+        readonly 405: "Method Not Allowed";
+        readonly 406: "Not Acceptable";
+        readonly 407: "Proxy Authentication Required";
+        readonly 408: "Request Timeout";
+        readonly 409: "Conflict";
+        readonly 410: "Gone";
+        readonly 411: "Length Required";
+        readonly 412: "Precondition Failed";
+        readonly 413: "Payload Too Large";
+        readonly 414: "URI Too Long";
+        readonly 415: "Unsupported Media Type";
+        readonly 416: "Range Not Satisfiable";
+        readonly 417: "Expectation Failed";
+        readonly 418: "I'm a teapot";
+        readonly 420: "Enhance Your Calm";
+        readonly 421: "Misdirected Request";
+        readonly 422: "Unprocessable Content";
+        readonly 423: "Locked";
+        readonly 424: "Failed Dependency";
+        readonly 425: "Too Early";
+        readonly 426: "Upgrade Required";
+        readonly 428: "Precondition Required";
+        readonly 429: "Too Many Requests";
+        readonly 431: "Request Header Fields Too Large";
+        readonly 451: "Unavailable For Legal Reasons";
+        readonly 500: "Internal Server Error";
+        readonly 501: "Not Implemented";
+        readonly 502: "Bad Gateway";
+        readonly 503: "Service Unavailable";
+        readonly 504: "Gateway Timeout";
+        readonly 505: "HTTP Version Not Supported";
+        readonly 506: "Variant Also Negotiates";
+        readonly 507: "Insufficient Storage";
+        readonly 508: "Loop Detected";
+        readonly 510: "Not Extended";
+        readonly 511: "Network Authentication Required";
+    }[Code] : Code>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, Code extends "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required" ? {
+        readonly Continue: 100;
+        readonly "Switching Protocols": 101;
+        readonly Processing: 102;
+        readonly "Early Hints": 103;
+        readonly OK: 200;
+        readonly Created: 201;
+        readonly Accepted: 202;
+        readonly "Non-Authoritative Information": 203;
+        readonly "No Content": 204;
+        readonly "Reset Content": 205;
+        readonly "Partial Content": 206;
+        readonly "Multi-Status": 207;
+        readonly "Already Reported": 208;
+        readonly "Multiple Choices": 300;
+        readonly "Moved Permanently": 301;
+        readonly Found: 302;
+        readonly "See Other": 303;
+        readonly "Not Modified": 304;
+        readonly "Temporary Redirect": 307;
+        readonly "Permanent Redirect": 308;
+        readonly "Bad Request": 400;
+        readonly Unauthorized: 401;
+        readonly "Payment Required": 402;
+        readonly Forbidden: 403;
+        readonly "Not Found": 404;
+        readonly "Method Not Allowed": 405;
+        readonly "Not Acceptable": 406;
+        readonly "Proxy Authentication Required": 407;
+        readonly "Request Timeout": 408;
+        readonly Conflict: 409;
+        readonly Gone: 410;
+        readonly "Length Required": 411;
+        readonly "Precondition Failed": 412;
+        readonly "Payload Too Large": 413;
+        readonly "URI Too Long": 414;
+        readonly "Unsupported Media Type": 415;
+        readonly "Range Not Satisfiable": 416;
+        readonly "Expectation Failed": 417;
+        readonly "I'm a teapot": 418;
+        readonly "Enhance Your Calm": 420;
+        readonly "Misdirected Request": 421;
+        readonly "Unprocessable Content": 422;
+        readonly Locked: 423;
+        readonly "Failed Dependency": 424;
+        readonly "Too Early": 425;
+        readonly "Upgrade Required": 426;
+        readonly "Precondition Required": 428;
+        readonly "Too Many Requests": 429;
+        readonly "Request Header Fields Too Large": 431;
+        readonly "Unavailable For Legal Reasons": 451;
+        readonly "Internal Server Error": 500;
+        readonly "Not Implemented": 501;
+        readonly "Bad Gateway": 502;
+        readonly "Service Unavailable": 503;
+        readonly "Gateway Timeout": 504;
+        readonly "HTTP Version Not Supported": 505;
+        readonly "Variant Also Negotiates": 506;
+        readonly "Insufficient Storage": 507;
+        readonly "Loop Detected": 508;
+        readonly "Not Extended": 510;
+        readonly "Network Authentication Required": 511;
+    }[Code] : Code>;
+    defer: (fn: import("elysia/types").AfterResponseHandler<NoInfer<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, "/__absolute/mobile-preview-telemetry">, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>>, NoInfer<import("elysia/types").DefaultSingleton & {
+        derive: {};
+    }>>) => import("elysia/types").MaybePromise<void>;
+    readonly path: string;
+    route?: string | undefined;
+    rid?: string | undefined;
+    request: Request;
+    store: {};
+}) => import("elysia").ElysiaStatus<400, {
+    readonly error: "invalid-preview-telemetry";
+}, 400> | import("elysia").ElysiaStatus<204, "No Content", 204>>;

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

@@ -0,0 +1 @@
+export declare const installAbsoluteMobilePreview: () => void;

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

@@ -1,5 +1,11 @@
 import type { NormalizedAbsoluteMobileConfig } from './config';
 export declare const ABSOLUTE_AUTH_PACKAGE: "@absolutejs/auth";
+export declare const ABSOLUTE_EXPO_AUTH_CORE_VERSION: "0.75.6";
+export declare const ABSOLUTE_EXPO_AUTH_PACKAGE: "@absolutejs/auth-expo";
+export declare const ABSOLUTE_EXPO_AUTH_VERSION: "0.0.2";
+export declare const ABSOLUTE_EXPO_SYNC_CORE_VERSION: "2.31.0";
+export declare const ABSOLUTE_EXPO_SYNC_PACKAGE: "@absolutejs/sync-expo";
+export declare const ABSOLUTE_EXPO_SYNC_VERSION: "0.0.2";
 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";

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[];
+}>;

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

@@ -0,0 +1,13 @@
+/**
+ * Props supplied automatically to an application-owned Expo native route.
+ * Import the existing AbsoluteJS page-props type as `PageProps` so server and
+ * native rendering stay on the same compile-time contract.
+ */
+export type AbsoluteNativeRouteProps<PageProps extends object, Params extends object = Record<string, string | string[] | undefined>> = {
+    /** Live props produced by the ordinary server route for the current URL. */
+    pageProps: Readonly<PageProps>;
+    /** Expo Router path and query parameters for the current native route. */
+    params: Readonly<Params>;
+    /** Re-run the trusted server route without remounting the native screen. */
+    reload: () => void;
+};

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

@@ -0,0 +1,91 @@
+import type { AbsoluteAndroidUpgradeConformanceResult } from './androidUpgradeConformance';
+export type AbsoluteNativeReportResult = 'FAIL' | 'NOT_RUN' | 'PASS' | 'SKIPPED';
+export type AbsoluteNativeReportCheck = {
+    details: string;
+    evidence?: string;
+    id: string;
+    result: AbsoluteNativeReportResult;
+};
+export type AbsoluteNativeHmrResult = {
+    clientMs?: number;
+    durationMs: number;
+    outcome: 'applied' | 'failed' | 'reloaded';
+    serverMs?: number;
+};
+export type AbsoluteNativeSyncMigrationResult = {
+    durationMs: number;
+    failedAttempt: {
+        code: 'INVALID_PLAN' | 'MIGRATION_MISSING' | 'SCHEMA_TOO_NEW' | 'SCHEMA_TOO_OLD' | 'UNKNOWN';
+        storedVersion?: number;
+        targetVersion?: number;
+    };
+    outcome: 'fail' | 'pass';
+    recovery: {
+        storedVersion: number;
+        targetVersion: number;
+    };
+    state: {
+        authCredential: boolean;
+        pendingOperations: boolean;
+        rollbackPreserved: boolean;
+        schemaAdvanced: boolean;
+    };
+};
+export type AbsoluteNativeAutomatedRun = {
+    appId: string;
+    deviceAcceptance?: {
+        https: boolean;
+        relaunchMs: number;
+        remote: boolean;
+    };
+    durationMs: number;
+    error?: string;
+    hmr?: AbsoluteNativeHmrResult;
+    hmrConnected: boolean;
+    platform: 'android' | 'ios';
+    port: number;
+    routes?: string[];
+    screenshot?: string;
+    status: 'fail' | 'pass';
+    syncMigration?: AbsoluteNativeSyncMigrationResult;
+    targetId: string;
+    targetKind: 'device' | 'emulator' | 'simulator';
+    upgrade?: AbsoluteAndroidUpgradeConformanceResult;
+};
+export type AbsoluteNativeTestReport = {
+    automatedChecks: AbsoluteNativeReportCheck[];
+    generatedAt: string;
+    manualChecks: AbsoluteNativeReportCheck[];
+    metadata: Record<string, string> & {
+        absolutejsVersion: string;
+        bunVersion: string;
+        provider: 'capacitor';
+    };
+    overallResult: 'FAIL' | 'INCOMPLETE';
+    platform: 'android' | 'ios';
+    reportVersion: 1;
+    run: AbsoluteNativeAutomatedRun;
+};
+export type AbsoluteNativeManualCheckDefinition = readonly [
+    id: string,
+    details: string
+];
+type CreateAbsoluteNativeTestReportOptions = {
+    automatedChecks?: AbsoluteNativeReportCheck[];
+    generatedAt?: string;
+    manualChecks: readonly AbsoluteNativeManualCheckDefinition[];
+    manualCheckResults?: Record<string, AbsoluteNativeReportCheck>;
+    metadata: AbsoluteNativeTestReport['metadata'];
+    run: AbsoluteNativeAutomatedRun;
+};
+export declare const sanitizeNativeReportText: (value: string) => string;
+export declare const createAbsoluteNativeAutomatedChecks: (run: AbsoluteNativeAutomatedRun) => AbsoluteNativeReportCheck[];
+export declare const createAbsoluteNativeTestReport: (options: CreateAbsoluteNativeTestReportOptions) => AbsoluteNativeTestReport;
+export declare const readPackageVersionForNativeReport: (packageJsonPath: string) => Promise<string>;
+export declare const renderAbsoluteNativeTestReport: (report: AbsoluteNativeTestReport) => string;
+export declare const writeAbsoluteNativeTestReport: (directory: string, report: AbsoluteNativeTestReport) => Promise<{
+    directory: string;
+    jsonPath: string;
+    markdownPath: string;
+}>;
+export {};

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

@@ -1,5 +1,6 @@
 export declare const ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
 export declare const ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION: 1;
+export declare const ABSOLUTE_NATIVE_ROUTE_DATA_MEDIA_TYPE = "application/vnd.absolute.native-route+json";
 declare const SERVER_ERROR_STATUS = 500;
 export declare const MOBILE_PAGE_REQUEST_HEADERS: {
     readonly appBuild: "x-absolute-mobile-app-build";
@@ -81,6 +82,7 @@ type FinalizeAbsoluteMobilePageInput<Props> = {
     status?: number;
 };
 export declare const acceptsAbsoluteMobilePage: (request: Request | undefined) => boolean;
+export declare const acceptsAbsoluteNativeRouteData: (request: Request | undefined) => boolean;
 export declare const parseAbsoluteMobilePageRequest: (request: Request | undefined) => ParsedMobilePageRequest;
 export declare const createAbsoluteMobileInvalidRequestResponse: (message: string) => Response;
 export declare const createAbsoluteMobilePageErrorResponse: (pageId: string) => Response;

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

@@ -4,10 +4,32 @@ export type AbsoluteMobileReleaseCheck = {
     id: string;
     path?: string;
     remediation?: string;
-    status: 'fail' | 'pass';
+    status: 'fail' | 'pass' | 'warn';
 };
 export type AbsoluteMobileReleaseDoctorResult = {
     checks: AbsoluteMobileReleaseCheck[];
     ready: boolean;
 };
+export declare const ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT: 1;
+export type AbsoluteMobileComplianceReport = {
+    app: {
+        appId: string;
+        engine: 'capacitor' | 'expo';
+        platforms: string[];
+        productionOrigin: string;
+    };
+    checks: Array<{
+        id: string;
+        status: AbsoluteMobileReleaseCheck['status'];
+    }>;
+    format: typeof ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT;
+    manualReview: string[];
+    ready: boolean;
+    summary: {
+        failed: number;
+        passed: number;
+        warnings: number;
+    };
+};
+export declare const createAbsoluteMobileComplianceReport: (config: NormalizedAbsoluteMobileConfig, result: AbsoluteMobileReleaseDoctorResult) => AbsoluteMobileComplianceReport;
 export declare const inspectAbsoluteMobileRelease: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<AbsoluteMobileReleaseDoctorResult>;

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

@@ -1,6 +1,8 @@
 import type { FileSink } from 'bun';
 import type { NormalizedAbsoluteMobileConfig } from './config';
+import { installAbsoluteIosRelease, type AbsoluteIosReleaseMetadata } from './iosRelease';
 import type { AbsoluteIosDevPhaseTiming, AbsoluteIosDevSession, AbsoluteIosDevState, AbsoluteIosNativeLogEntry } from './iosSimulatorController';
+import type { AbsoluteExpoDevPhaseTiming, AbsoluteExpoDevSession, AbsoluteExpoDevState } from './expoDevController';
 export { ABSOLUTE_REMOTE_MAC_EVENT_PREFIX, ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION } from './remoteMacWire';
 export type AbsoluteRemoteMacProfile = {
     bunPath: string;
@@ -28,6 +30,11 @@ export type AbsoluteRemoteIosDevProject = {
     xcodebuild: string;
     xcrun: string;
 };
+export type AbsoluteRemoteExpoIosDevProject = AbsoluteRemoteIosDevProject & {
+    config: NormalizedAbsoluteMobileConfig & {
+        engine: 'expo';
+    };
+};
 export type AbsoluteIosDevelopmentProject = AbsoluteRemoteIosDevProject | (import('./iosSimulatorController').AbsoluteIosDevProject & {
     remote?: false;
 });
@@ -49,7 +56,9 @@ export type AbsoluteRemoteMacTransport = {
     };
 };
 export type AbsoluteRemoteIosOptions = {
+    certificateAuthorityPath?: string;
     https?: boolean;
+    deviceIdentifier?: string;
     log?: (message: string) => void;
     nativeLog?: (entry: AbsoluteIosNativeLogEntry) => void;
     onPhaseTiming?: (timing: AbsoluteIosDevPhaseTiming) => void;
@@ -57,6 +66,26 @@ export type AbsoluteRemoteIosOptions = {
     port: number;
     project: AbsoluteRemoteIosDevProject;
     signal?: AbortSignal;
+    serverHost?: string;
+    installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
+        remotePath: string;
+        uploaded?: boolean;
+    }>;
+    syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+    transport?: AbsoluteRemoteMacTransport;
+};
+export type AbsoluteRemoteExpoIosOptions = {
+    certificateAuthorityPath?: string;
+    deviceIdentifier?: string;
+    https?: boolean;
+    log?: (message: string) => void;
+    metroPort: number;
+    onPhaseTiming?: (timing: AbsoluteExpoDevPhaseTiming) => void;
+    onStateChange?: (state: AbsoluteExpoDevState) => void;
+    port: number;
+    project: AbsoluteRemoteExpoIosDevProject;
+    serverHost?: string;
+    signal?: AbortSignal;
     installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
         remotePath: string;
         uploaded?: boolean;
@@ -64,11 +93,38 @@ export type AbsoluteRemoteIosOptions = {
     syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
     transport?: AbsoluteRemoteMacTransport;
 };
+export type BuildAbsoluteRemoteIosReleaseOptions = {
+    allowUnsigned?: boolean;
+    developmentTeam?: string;
+    installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
+        remotePath: string;
+        uploaded?: boolean;
+    }>;
+    log?: (message: string) => void;
+    onPhaseTiming?: (timing: {
+        durationMs: number;
+        phase: string;
+    }) => void;
+    outputDirectory?: string;
+    prepareBuildNumber?: (buildIdentity: string) => Promise<number>;
+    project: AbsoluteRemoteIosDevProject;
+    retrieveRelease?: (project: AbsoluteRemoteIosDevProject, metadata: AbsoluteIosReleaseMetadata, outputDirectory?: string) => Promise<Awaited<ReturnType<typeof installAbsoluteIosRelease>>>;
+    syncReleaseInputs?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+    syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+    transport?: Pick<AbsoluteRemoteMacTransport, 'spawn'>;
+};
 export declare const validateAbsoluteRemoteMacProfileName: (name: string) => string;
 export declare const validateAbsoluteSshDestination: (destination: string) => string;
 export declare const absoluteRemoteMacSshBase: (profile: Pick<AbsoluteRemoteMacProfile, "destination" | "port">, options?: {
     acceptNew?: boolean;
 }) => string[];
+/** Run a non-interactive command on an already paired Mac.
+ *
+ * Arguments are quoted independently before crossing SSH. This is intended for
+ * small, read-only inspections and lifecycle commands that do not need the
+ * long-running remote development agent.
+ */
+export declare const captureAbsoluteRemoteMacCommand: (profile: AbsoluteRemoteMacProfile, command: string[], transport?: Pick<AbsoluteRemoteMacTransport, "capture">) => Promise<AbsoluteRemoteMacCommandResult>;
 export declare const getAbsoluteRemoteMacProfile: (name?: string, profilePath?: string) => Promise<AbsoluteRemoteMacProfile | undefined>;
 export declare const inspectAbsoluteRemoteMac: (destination: string, options?: {
     acceptNew?: boolean;
@@ -80,6 +136,7 @@ export declare const inspectAbsoluteRemoteMac: (destination: string, options?: {
     os: string;
     xcodeVersion: string;
 }>;
+export declare const inspectAbsoluteRemoteMacLanHost: (profile: AbsoluteRemoteMacProfile, transport?: Pick<AbsoluteRemoteMacTransport, "capture">) => Promise<string>;
 export declare const listAbsoluteRemoteMacProfiles: (profilePath?: string) => Promise<{
     defaultProfile: string | undefined;
     profiles: AbsoluteRemoteMacProfile[];
@@ -93,6 +150,7 @@ export declare const pairAbsoluteRemoteMac: (options: {
     workspaceRoot?: string;
 }) => Promise<AbsoluteRemoteMacProfile>;
 export declare const removeAbsoluteRemoteMacProfile: (name: string, profilePath?: string) => Promise<boolean>;
+export declare const createAbsoluteRemoteExpoIosDevProject: (config: NormalizedAbsoluteMobileConfig, projectRoot: string, profile: AbsoluteRemoteMacProfile) => AbsoluteRemoteExpoIosDevProject;
 export declare const createAbsoluteRemoteIosDevProject: (config: NormalizedAbsoluteMobileConfig, projectRoot: string, profile: AbsoluteRemoteMacProfile) => AbsoluteRemoteIosDevProject;
 export declare const installAbsoluteRemoteMacAgent: (project: AbsoluteRemoteIosDevProject) => Promise<{
     remotePath: string;
@@ -111,4 +169,36 @@ export declare const absoluteRemoteProjectSyncCommands: (project: AbsoluteRemote
     tar: string[];
 };
 export declare const syncAbsoluteRemoteMacProject: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+export declare const absoluteRemoteReleaseInputSyncCommands: (project: AbsoluteRemoteIosDevProject) => {
+    remote: string[];
+    tar: string[];
+};
+export declare const syncAbsoluteRemoteMacReleaseInputs: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+export declare const buildAbsoluteRemoteIosRelease: (options: BuildAbsoluteRemoteIosReleaseOptions) => Promise<{
+    timings: {
+        'remote-agent': number;
+        'remote-release-download': number;
+        'remote-release-sync': number;
+        total: number;
+    };
+    artifactPath: string;
+    metadata: {
+        artifact: "App.ipa";
+        sha256: string;
+        type: "ipa";
+        format: typeof import("./iosRelease").ABSOLUTE_IOS_RELEASE_FORMAT;
+        bytes: number;
+        runtime: string;
+        releaseId: string;
+        appBuild: string;
+        appId: string;
+        platform: "ios";
+        buildNumber?: number | undefined;
+        engine: "capacitor" | "expo";
+        marketingVersion: string;
+        signed: boolean;
+    };
+    releaseRoot: string;
+}>;
+export declare const startAbsoluteRemoteExpoIosDevSession: (options: AbsoluteRemoteExpoIosOptions) => Promise<AbsoluteExpoDevSession>;
 export declare const startAbsoluteRemoteIosDevSession: (options: AbsoluteRemoteIosOptions) => Promise<AbsoluteIosDevSession>;

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

@@ -1,2 +1,2 @@
 export declare const ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t";
-export declare const ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
+export declare const ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 3;

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

@@ -1,8 +1,15 @@
+import { type MobileAuthPrincipal } from '@absolutejs/auth/client/mobile';
 import type { AbsoluteMobileAuthManifest } from './nativeAuth';
 import type { AbsoluteMobileFetch } from './transport';
 export type AbsoluteMobileShellAuth = {
+    clientId: string;
     fetch: AbsoluteMobileFetch;
+    onPrincipalChange: (listener: (principal: MobileAuthPrincipal | null) => void) => () => void;
+    principal: MobileAuthPrincipal | null;
     redirectUri: string;
+    issuer: string;
     socketTicket: (audience?: string) => Promise<string>;
 };
-export declare const createAbsoluteMobileShellAuth: (config: AbsoluteMobileAuthManifest) => Promise<AbsoluteMobileShellAuth>;
+export declare const createAbsoluteMobileShellAuth: (config: AbsoluteMobileAuthManifest, options?: {
+    beforeSignOut?: () => Promise<void> | void;
+}) => Promise<AbsoluteMobileShellAuth>;