@absolutejs/absolute 0.20.0-beta.7 → 0.20.0-beta.70

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

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

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

@@ -0,0 +1,36 @@
+export type AbsoluteMobileNavigationHistoryMode = 'none' | 'push' | 'replace';
+export type AbsoluteMobileNavigationRequest = {
+    direction: 'back' | 'forward' | 'replace';
+    from: string;
+    historyMode: AbsoluteMobileNavigationHistoryMode;
+    path: string;
+};
+export type AbsoluteMobileNavigationFailurePhase = 'commit' | 'load';
+export type AbsoluteMobileNavigationResult = {
+    kind: 'cancelled';
+} | {
+    kind: 'committed';
+} | {
+    kind: 'failed';
+    error: unknown;
+    phase: AbsoluteMobileNavigationFailurePhase;
+};
+export type AbsoluteMobileNavigationCoordinatorOptions<Payload> = {
+    commit: (payload: Payload, request: AbsoluteMobileNavigationRequest) => Promise<void>;
+    load: (request: AbsoluteMobileNavigationRequest, signal: AbortSignal) => Promise<Payload>;
+    onCommit?: (request: AbsoluteMobileNavigationRequest) => void;
+    onFailure?: (error: unknown, phase: AbsoluteMobileNavigationFailurePhase, request: AbsoluteMobileNavigationRequest) => void;
+    onStart?: (request: AbsoluteMobileNavigationRequest) => void;
+    onSuccess?: (request: AbsoluteMobileNavigationRequest) => void;
+};
+export type AbsoluteMobileNavigationCoordinator = {
+    cancelPending(): boolean;
+    dispose(): void;
+    navigate(request: AbsoluteMobileNavigationRequest): Promise<AbsoluteMobileNavigationResult>;
+    phase(): 'committing' | 'idle' | 'loading' | 'queued';
+};
+/**
+ * Coordinates native-shell route loads. Loads may overlap, but only the latest
+ * completed load may enter the serialized document commit boundary.
+ */
+export declare const createAbsoluteMobileNavigationCoordinator: <Payload>(options: AbsoluteMobileNavigationCoordinatorOptions<Payload>) => AbsoluteMobileNavigationCoordinator;

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

@@ -0,0 +1,53 @@
+export type AbsoluteMobileHistoryEntry = {
+    absoluteMobile: true;
+    entryId: string;
+    index: number;
+    path: string;
+};
+type ElementLocator = {
+    kind: 'id';
+    value: string;
+} | {
+    kind: 'index';
+    index: number;
+} | {
+    kind: 'name';
+    index: number;
+    value: string;
+};
+type ControlSnapshot = {
+    checked?: boolean;
+    locator: ElementLocator;
+    open?: boolean;
+    selectionEnd?: number;
+    selectionStart?: number;
+    tag: string;
+    value?: string;
+    values?: string[];
+};
+type ScrollSnapshot = {
+    left: number;
+    locator: ElementLocator;
+    top: number;
+};
+export type AbsoluteMobileDocumentSnapshot = {
+    controls: ControlSnapshot[];
+    focus?: ElementLocator;
+    scroll: ScrollSnapshot[];
+    window: {
+        x: number;
+        y: number;
+    };
+};
+export declare const createAbsoluteMobileHistoryEntry: (path: string, index: number, entryId?: string) => {
+    absoluteMobile: true;
+    entryId: string;
+    index: number;
+    path: string;
+};
+export declare const readAbsoluteMobileHistoryEntry: (value: unknown) => AbsoluteMobileHistoryEntry | undefined;
+/** Captures route-local state in memory. Sensitive credential fields are omitted. */
+export declare const captureAbsoluteMobileDocumentState: () => AbsoluteMobileDocumentSnapshot;
+export declare const restoreAbsoluteMobileDocumentState: (snapshot: AbsoluteMobileDocumentSnapshot) => void;
+export declare const resetAbsoluteMobileDocumentState: () => void;
+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,55 @@ export type AbsoluteRemoteIosOptions = {
     syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
     transport?: AbsoluteRemoteMacTransport;
 };
+export type BuildAbsoluteRemoteIosReleaseOptions = {
+    acquireLease?: (project: AbsoluteRemoteIosDevProject, signal?: AbortSignal) => Promise<AbsoluteRemoteMacLease>;
+    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>;
+    signal?: AbortSignal;
+    transport?: Pick<AbsoluteRemoteMacTransport, 'capture' | 'spawn'>;
+};
+export type AbsoluteRemoteMacLease = {
+    heartbeat: () => Promise<void>;
+    path: string;
+    recovered: boolean;
+    release: () => Promise<void>;
+    token: string;
+};
+export type AbsoluteRemoteMacWorkspaceInspection = {
+    agentCount: number;
+    bytes: number;
+    leaseCount: number;
+    profile: string;
+    projectCount: number;
+    workspaceRoot: string;
+};
 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 +153,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,7 +167,29 @@ 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;
+/** Acquire the project-scoped release lease before changing shared remote state.
+ *
+ * `mkdir` and the stale-directory rename are atomic on the Remote Mac. The
+ * random token prevents an expired owner from touching or releasing a newer
+ * owner's lease after a delayed SSH command completes.
+ */
+export declare const acquireAbsoluteRemoteMacReleaseLease: (project: AbsoluteRemoteIosDevProject, options?: {
+    signal?: AbortSignal;
+    staleSeconds?: number;
+    transport?: Pick<AbsoluteRemoteMacTransport, "capture">;
+}) => Promise<AbsoluteRemoteMacLease>;
+declare const inspectAbsoluteRemoteMacWorkspace: (profile: AbsoluteRemoteMacProfile, transport?: Pick<AbsoluteRemoteMacTransport, "capture">) => Promise<AbsoluteRemoteMacWorkspaceInspection>;
+/** Remove only abandoned staging directories. Project dependency/native caches,
+ * immutable releases, and active leases are deliberately retained.
+ */
+declare const cleanAbsoluteRemoteMacWorkspace: (profile: AbsoluteRemoteMacProfile, transport?: Pick<AbsoluteRemoteMacTransport, "capture">) => Promise<{
+    profile: string;
+    removed: number;
+    workspaceRoot: string;
+}>;
+export { cleanAbsoluteRemoteMacWorkspace, inspectAbsoluteRemoteMacWorkspace };
 export declare const installAbsoluteRemoteMacAgent: (project: AbsoluteRemoteIosDevProject) => Promise<{
     remotePath: string;
     uploaded: boolean;
@@ -110,5 +206,42 @@ export declare const absoluteRemoteProjectSyncCommands: (project: AbsoluteRemote
     remote: string[];
     tar: string[];
 };
-export declare const syncAbsoluteRemoteMacProject: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+export declare const syncAbsoluteRemoteMacProject: (project: AbsoluteRemoteIosDevProject, options?: {
+    signal?: AbortSignal;
+}) => Promise<void>;
+export declare const absoluteRemoteReleaseInputSyncCommands: (project: AbsoluteRemoteIosDevProject) => {
+    remote: string[];
+    tar: string[];
+};
+export declare const syncAbsoluteRemoteMacReleaseInputs: (project: AbsoluteRemoteIosDevProject, options?: {
+    signal?: AbortSignal;
+}) => Promise<void>;
+export declare const buildAbsoluteRemoteIosRelease: (options: BuildAbsoluteRemoteIosReleaseOptions) => Promise<{
+    timings: {
+        'remote-agent': number;
+        'remote-release-download': number;
+        'remote-release-lease': 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

@@ -2,10 +2,14 @@ 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>;

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

@@ -1,16 +1,26 @@
 import { type AbsoluteMobileFetch, type AbsoluteMobileClientManifest } from './transport';
+import { type AbsoluteMobileObservabilityEngine } from './shellObservability';
 export type AbsoluteMobileShellAuthRuntime = {
+    clientId: string;
     fetch: AbsoluteMobileFetch;
     onPrincipalChange: (listener: (principal: AbsoluteMobileShellPrincipal | null) => void) => () => void;
     principal: AbsoluteMobileShellPrincipal | null;
     redirectUri: string;
+    issuer: string;
     socketTicket: (audience?: string) => Promise<string>;
 };
 export type AbsoluteMobileShellPrincipal = {
     namespace: string;
 };
 export type AbsoluteMobileShellOptions = {
-    createAuth?: (config: NonNullable<AbsoluteMobileClientManifest['auth']>) => Promise<AbsoluteMobileShellAuthRuntime>;
-    installSync?: (auth: AbsoluteMobileShellAuthRuntime) => void | (() => void);
+    engine?: AbsoluteMobileObservabilityEngine;
+    createFetch?: (manifest: AbsoluteMobileClientManifest) => AbsoluteMobileFetch;
+    createAuth?: (config: NonNullable<AbsoluteMobileClientManifest['auth']>, options?: {
+        beforeSignOut?: () => Promise<void> | void;
+    }) => Promise<AbsoluteMobileShellAuthRuntime>;
+    beforeSignOut?: () => Promise<void> | void;
+    connectPush?: (auth: AbsoluteMobileShellAuthRuntime) => void;
+    installSync?: (auth: AbsoluteMobileShellAuthRuntime, config: NonNullable<AbsoluteMobileClientManifest['sync']>) => void | (() => void);
+    installUpdates?: (manifest: AbsoluteMobileClientManifest) => Promise<void>;
 };
 export declare const startAbsoluteMobileShell: (options?: AbsoluteMobileShellOptions) => Promise<void>;

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

@@ -0,0 +1,12 @@
+import { type MobileAuthPrincipal } from '@absolutejs/auth/client/mobile';
+import type { AbsoluteMobileAuthManifest } from './nativeAuth';
+import type { AbsoluteMobileFetch } from './transport';
+export declare const createAbsoluteExpoShellAuth: (config: AbsoluteMobileAuthManifest) => Promise<{
+    clientId: string;
+    fetch: AbsoluteMobileFetch;
+    issuer: string;
+    principal: Pick<MobileAuthPrincipal, "namespace"> | null;
+    redirectUri: string;
+    onPrincipalChange: (listener: (principal: Pick<MobileAuthPrincipal, "namespace"> | null) => void) => () => boolean;
+    socketTicket: () => Promise<never>;
+}>;

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

@@ -0,0 +1,3 @@
+export declare const createAbsoluteExpoBridgeFetch: () => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/** Installs the provider-neutral adapter backed by the generated native host. */
+export declare const installAbsoluteExpoWebDeviceAdapter: (capabilities?: readonly string[]) => () => void;

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

@@ -0,0 +1,18 @@
+import { type AbsoluteExpoSyncBridgeProvider } from '@absolutejs/sync-expo/client';
+import type { SyncClientStatus } from '@absolutejs/sync/client';
+import type { AbsoluteMobileShellAuthRuntime } from './shellBootstrap';
+import type { AbsoluteMobileClientManifest } from './transport';
+type ExpoBridge = AbsoluteExpoSyncBridgeProvider & {
+    on(event: 'sync.socket' | 'sync.wake', listener: (payload: Record<string, unknown>) => void): () => void;
+};
+export type AbsoluteExpoShellSyncOptions = {
+    provider?: ExpoBridge;
+    reload?: () => void;
+    reportStatus?: (status: SyncClientStatus) => void;
+};
+/**
+ * Gives unchanged WebView page clients native-owned SQLite and sockets. Auth
+ * namespaces and socket tickets never cross into page-controlled JavaScript.
+ */
+export declare const installAbsoluteExpoShellSync: (auth: AbsoluteMobileShellAuthRuntime, config?: NonNullable<AbsoluteMobileClientManifest["sync"]>, options?: AbsoluteExpoShellSyncOptions) => () => void;
+export {};

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

@@ -0,0 +1,2 @@
+import { type AbsoluteHttpFetch } from '@absolutejs/http';
+export declare const installAbsoluteMobileShellHttp: (origin: string, fetch?: AbsoluteHttpFetch) => () => void;

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

@@ -0,0 +1,21 @@
+import type { AbsoluteMobileClientManifest, AbsoluteMobileFetch } from './transport';
+export type AbsoluteMobileNativeDiagnostic = {
+    details: Record<string, unknown>;
+    id: string;
+    kind: string;
+    occurredAt: number;
+    platform: 'android' | 'ios';
+};
+export type AbsoluteMobileNativeObservabilityPlugin = {
+    acknowledge(options: {
+        ids: string[];
+    }): Promise<void>;
+    pending(): Promise<{
+        reports: unknown[];
+    }>;
+};
+export type AbsoluteMobileNativeObservabilityDrainOptions = {
+    native?: boolean;
+    plugin?: AbsoluteMobileNativeObservabilityPlugin;
+};
+export declare const drainAbsoluteMobileNativeObservability: (manifest: AbsoluteMobileClientManifest, fetch: AbsoluteMobileFetch, options?: AbsoluteMobileNativeObservabilityDrainOptions) => Promise<number>;

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

@@ -0,0 +1,11 @@
+import { type Beacon } from '@absolutejs/beacon';
+import type { AbsoluteMobileClientManifest, AbsoluteMobileFetch } from './transport';
+export type AbsoluteMobileObservabilityEngine = 'capacitor' | 'expo';
+export type AbsoluteMobileShellObservability = {
+    beacon: Beacon;
+    captureException: (error: unknown, context?: {
+        phase?: string;
+        path?: string;
+    }) => void;
+};
+export declare const installAbsoluteMobileShellObservability: (manifest: AbsoluteMobileClientManifest, engine: AbsoluteMobileObservabilityEngine, fetch?: AbsoluteMobileFetch) => AbsoluteMobileShellObservability | undefined;

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

@@ -0,0 +1,11 @@
+import { secureStorage, type DevicePushNotificationsCapability } from '@absolutejs/devices';
+import type { CapacitorPushNotificationsOptions } from '@absolutejs/devices-capacitor/push-notifications';
+import type { AbsoluteMobileShellAuthRuntime } from './shellBootstrap';
+export declare const ABSOLUTE_PUSH_ROUTE: "/auth/push";
+export declare const createAbsoluteMobileShellPush: ({ storage }?: {
+    storage?: Pick<typeof secureStorage, "get" | "remove" | "set">;
+}) => {
+    capabilityOptions: CapacitorPushNotificationsOptions;
+    beforeSignOut: () => Promise<void>;
+    connect: (nextAuth: AbsoluteMobileShellAuthRuntime, nextCapability: DevicePushNotificationsCapability) => void;
+};

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

@@ -1,14 +1,47 @@
-import { type CapacitorSyncLifecycleOptions } from '@absolutejs/sync-capacitor';
-import type { SyncLocalStore } from '@absolutejs/sync/client';
+import { configureCapacitorBackgroundSync, type CapacitorSyncLifecycleOptions, type CapacitorSyncLocalStoreOptions } from '@absolutejs/sync-capacitor';
+import type { SyncClientStatus, SyncLocalStore, SyncLocalStoreSchemaStatus } from '@absolutejs/sync/client';
 import type { AbsoluteMobileShellAuthRuntime } from './shellBootstrap';
+import type { AbsoluteMobileClientManifest } from './transport';
 export type AbsoluteMobileShellSyncOptions = {
-    createStore?: () => SyncLocalStore;
+    createStore?: (options?: CapacitorSyncLocalStoreOptions) => SyncLocalStore;
     installLifecycle?: (options: CapacitorSyncLifecycleOptions) => Promise<() => void>;
     reload?: () => void;
+    reportStatus?: (status: SyncClientStatus) => void;
+    reportSchemaState?: (state: AbsoluteMobileSyncSchemaState) => void;
+    configureBackground?: typeof configureCapacitorBackgroundSync;
+    clearBackground?: () => Promise<void>;
 };
+export declare const ABSOLUTE_MOBILE_SYNC_SCHEMA_EVENT = "absolute:sync-schema";
+export declare const ABSOLUTE_MOBILE_SYNC_SCHEMA_STATE_KEY = "absolutejs.mobile.sync.schema-state";
+export declare const ABSOLUTE_MOBILE_SYNC_STATUS_EVENT = "absolute:sync-status";
+export type AbsoluteMobileSyncSchemaFailureCode = 'INVALID_PLAN' | 'MIGRATION_MISSING' | 'SCHEMA_TOO_NEW' | 'SCHEMA_TOO_OLD' | 'UNKNOWN';
+export type AbsoluteMobileSyncSchemaState = {
+    state: 'preparing';
+} | SyncLocalStoreSchemaStatus | {
+    code: AbsoluteMobileSyncSchemaFailureCode;
+    state: 'failed';
+    storedVersion?: number;
+    targetVersion?: number;
+};
+export declare const readAbsoluteMobileSyncSchemaState: () => SyncLocalStoreSchemaStatus | {
+    code: AbsoluteMobileSyncSchemaFailureCode;
+    state: "failed";
+    storedVersion?: number;
+    targetVersion?: number;
+} | {
+    state: any;
+    minimumCompatibleVersion?: undefined;
+    storedVersion?: undefined;
+    targetVersion?: undefined;
+} | {
+    minimumCompatibleVersion: number;
+    state: any;
+    storedVersion: number;
+    targetVersion: number;
+} | undefined;
 /**
  * Provisions unchanged Sync clients with native durability, Auth isolation, and
  * foreground/connectivity reconnects. An identity change reloads the shell so
  * no page-held client can retain the previous account's in-memory rows.
  */
-export declare const installAbsoluteMobileShellSync: (auth: AbsoluteMobileShellAuthRuntime, options?: AbsoluteMobileShellSyncOptions) => () => void;
+export declare const installAbsoluteMobileShellSync: (auth: AbsoluteMobileShellAuthRuntime, config?: NonNullable<AbsoluteMobileClientManifest["sync"]>, options?: AbsoluteMobileShellSyncOptions) => () => void;

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

@@ -0,0 +1,2 @@
+import type { AbsoluteMobileClientManifest } from './transport';
+export declare const installAbsoluteMobileShellUpdates: (manifest: AbsoluteMobileClientManifest) => Promise<void>;

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

@@ -0,0 +1,10 @@
+import { type SyncRuntimeInspection } from '@absolutejs/sync/client/runtime';
+export type AbsoluteMobileSyncRemediation = {
+    discard: (operationId: string) => Promise<void>;
+    inspect: () => Promise<SyncRuntimeInspection>;
+    rebase: (operationId: string, args: unknown) => Promise<string>;
+    retry: (operationId: string) => Promise<void>;
+};
+/** Install the native shell's framework-neutral, redacted remediation bridge. */
+export declare const getAbsoluteMobileSyncRemediation: () => AbsoluteMobileSyncRemediation | undefined;
+export declare const installAbsoluteMobileSyncRemediation: (bridge?: AbsoluteMobileSyncRemediation) => () => void;