@absolutejs/absolute 0.20.0-beta.6 → 0.20.0-beta.60

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

@@ -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>;

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

@@ -1,11 +1,24 @@
 import { type AbsoluteMobileFetch, type AbsoluteMobileClientManifest } from './transport';
 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;
+    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/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,2 +1,47 @@
+import { configureCapacitorBackgroundSync, type CapacitorSyncLifecycleOptions, type CapacitorSyncLocalStoreOptions } from '@absolutejs/sync-capacitor';
+import type { SyncClientStatus, SyncLocalStore, SyncLocalStoreSchemaStatus } from '@absolutejs/sync/client';
 import type { AbsoluteMobileShellAuthRuntime } from './shellBootstrap';
-export declare const installAbsoluteMobileShellSync: (auth: AbsoluteMobileShellAuthRuntime) => void;
+import type { AbsoluteMobileClientManifest } from './transport';
+export type AbsoluteMobileShellSyncOptions = {
+    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, 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;

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

@@ -0,0 +1,9 @@
+import { type SyncLocalStoreSchemaBundle } from '@absolutejs/sync/client';
+export type AbsoluteSyncSchemaDiscovery = {
+    components: SyncLocalStoreSchemaBundle['components'];
+    sources: {
+        id: string;
+        manifestPath: string;
+    }[];
+};
+export declare const discoverAbsoluteSyncSchema: (projectRoot: string) => AbsoluteSyncSchemaDiscovery;

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

@@ -1,6 +1,7 @@
 import { type AbsoluteMobilePageActivationOptions } from './client';
 import type { AbsoluteMobileCompatibilityPage, AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
 import type { AbsoluteMobileAuthManifest } from './nativeAuth';
+import type { SyncLocalStoreSchemaBundle } from '@absolutejs/sync/client';
 export declare const ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT: 1;
 export type AbsoluteMobileFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export type AbsoluteMobileClientPage = AbsoluteMobileCompatibilityPage & {
@@ -14,19 +15,32 @@ export type AbsoluteMobileClientManifest = {
     appName: string;
     deepLinkHosts: string[];
     deepLinkScheme?: string;
+    deviceCapabilities: string[];
     entry: string;
     format: typeof ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT;
+    nativeRuntime: string;
     pages: AbsoluteMobileClientPage[];
     productionOrigin: string;
     routes: AbsoluteMobileCompatibilityRoute[];
     runtime: string;
+    updates?: {
+        channel: string;
+        manifestUrl: string;
+        publicKeys: Record<string, string>;
+    };
     sync?: {
         socketTickets: true;
+        background: {
+            endpoint: string;
+            intervalMinutes: number;
+        };
+        storageSchema: SyncLocalStoreSchemaBundle;
     };
 };
 export type AbsoluteMobileTransportOptions = {
     fetch?: AbsoluteMobileFetch;
     headers?: HeadersInit;
+    signal?: AbortSignal;
 };
 export declare const createAbsoluteMobilePageRequest: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Request;
 export declare const fetchAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Promise<unknown>;

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

@@ -0,0 +1,37 @@
+export type AbsoluteMobileNavigationDirection = 'back' | 'forward' | 'replace';
+export type AbsoluteMobileNavigationDetail = {
+    direction: AbsoluteMobileNavigationDirection;
+    from: string;
+    to: string;
+};
+export type AbsoluteMobileSheetDetail = {
+    id: string;
+    open: boolean;
+};
+export type AbsoluteMobileLinkIntent = {
+    kind: 'back';
+} | {
+    kind: 'external';
+} | {
+    kind: 'navigate';
+    replace: boolean;
+};
+declare global {
+    interface WindowEventMap {
+        'absolute:back-request': CustomEvent;
+        'absolute:navigation-change': CustomEvent<AbsoluteMobileNavigationDetail>;
+        'absolute:sheet-change': CustomEvent<AbsoluteMobileSheetDetail>;
+    }
+}
+export type AbsoluteMobileUiPrimitives = {
+    dispose(): void;
+    navigate(detail: AbsoluteMobileNavigationDetail): void;
+    refreshDocument(path?: string): void;
+    requestBack(): boolean;
+};
+export declare const closeAbsoluteMobileSheet: (target: HTMLDialogElement | string) => boolean;
+export declare const openAbsoluteMobileSheet: (target: HTMLDialogElement | string, opener?: HTMLElement) => boolean;
+export declare const readAbsoluteMobileLinkIntent: (anchor: HTMLAnchorElement) => AbsoluteMobileLinkIntent;
+export declare const requestAbsoluteMobileBack: () => boolean;
+/** Installs optional semantic-HTML mobile layout and interaction primitives. */
+export declare const installAbsoluteMobileUiPrimitives: () => AbsoluteMobileUiPrimitives;

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

@@ -0,0 +1,40 @@
+import { type AbsoluteMobileUpdateFile, type AbsoluteMobileUpdateManifest } from './updateProtocol';
+export type AbsoluteMobileUpdateClientConfig = {
+    appId: string;
+    channel: string;
+    currentReleaseId: string;
+    installationId: string;
+    manifestUrl: string;
+    runtimeFingerprint: string;
+};
+export type AbsoluteMobileUpdateStore = {
+    abort(releaseId: string): Promise<void>;
+    activate(releaseId: string): Promise<void>;
+    begin(manifest: AbsoluteMobileUpdateManifest): Promise<void>;
+    commit(manifest: AbsoluteMobileUpdateManifest): Promise<void>;
+    write(file: AbsoluteMobileUpdateFile, contents: Uint8Array): Promise<void>;
+};
+export type AbsoluteMobileUpdateVerifier = {
+    digest(contents: Uint8Array): Promise<string>;
+    verify(manifest: AbsoluteMobileUpdateManifest): Promise<boolean>;
+};
+export type AbsoluteMobileUpdateClientOptions = {
+    config: AbsoluteMobileUpdateClientConfig;
+    fetch?: typeof globalThis.fetch;
+    store: AbsoluteMobileUpdateStore;
+    verifier: AbsoluteMobileUpdateVerifier;
+};
+export type AbsoluteMobileUpdateCheckResult = {
+    kind: 'current';
+} | {
+    kind: 'downloaded';
+    manifest: AbsoluteMobileUpdateManifest;
+} | {
+    kind: 'update-available';
+    manifest: AbsoluteMobileUpdateManifest;
+};
+export declare const createAbsoluteMobileUpdateClient: (options: AbsoluteMobileUpdateClientOptions) => {
+    check: (download?: boolean) => Promise<AbsoluteMobileUpdateCheckResult>;
+    activate: (releaseId: string) => Promise<void>;
+    download: () => Promise<AbsoluteMobileUpdateCheckResult>;
+};

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

@@ -0,0 +1,51 @@
+export declare const ABSOLUTE_MOBILE_UPDATE_FORMAT: 1;
+export declare const ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES: number;
+export declare const ABSOLUTE_MOBILE_UPDATE_MAX_FILES = 10000;
+export declare const ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES: number;
+export declare const ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM: "ecdsa-p256-sha256";
+export type AbsoluteMobileUpdateClassification = 'bug-fix' | 'content' | 'security';
+export type AbsoluteMobileUpdateFile = {
+    bytes: number;
+    path: string;
+    sha256: string;
+};
+export type AbsoluteMobileUnsignedUpdateManifest = {
+    appId: string;
+    channel: string;
+    classification: AbsoluteMobileUpdateClassification;
+    createdAt: string;
+    files: AbsoluteMobileUpdateFile[];
+    format: typeof ABSOLUTE_MOBILE_UPDATE_FORMAT;
+    /** A content identity for the complete update, excluding its signature. */
+    releaseId: string;
+    /** Locks an update to the native plugins, bridge, Auth, and local-data ABI. */
+    runtimeFingerprint: string;
+    /** Store-policy attestation. Feature/primary-purpose changes require a store build. */
+    withinSubmittedPurpose: true;
+};
+export type AbsoluteMobileUpdateManifest = AbsoluteMobileUnsignedUpdateManifest & {
+    signature: {
+        algorithm: typeof ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM;
+        keyId: string;
+        value: string;
+    };
+};
+export declare const absoluteMobileUpdateSigningPayload: (manifest: AbsoluteMobileUnsignedUpdateManifest) => Uint8Array<ArrayBuffer>;
+export declare const canonicalizeAbsoluteMobileUpdate: (value: unknown) => string;
+export declare const normalizeAbsoluteMobileUpdatePath: (value: unknown) => string;
+export declare const parseAbsoluteMobileUnsignedUpdateManifest: (value: unknown) => AbsoluteMobileUnsignedUpdateManifest;
+export declare const parseAbsoluteMobileUpdateManifest: (value: unknown) => AbsoluteMobileUpdateManifest;
+export declare const unsignedAbsoluteMobileUpdate: (manifest: AbsoluteMobileUpdateManifest) => {
+    appId: string;
+    channel: string;
+    classification: AbsoluteMobileUpdateClassification;
+    createdAt: string;
+    files: AbsoluteMobileUpdateFile[];
+    format: typeof ABSOLUTE_MOBILE_UPDATE_FORMAT;
+    /** A content identity for the complete update, excluding its signature. */
+    releaseId: string;
+    /** Locks an update to the native plugins, bridge, Auth, and local-data ABI. */
+    runtimeFingerprint: string;
+    /** Store-policy attestation. Feature/primary-purpose changes require a store build. */
+    withinSubmittedPurpose: true;
+};

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

@@ -0,0 +1,66 @@
+import { readAbsoluteMobileUpdate } from './updateSigning';
+export type AbsoluteMobileUpdatePublication = {
+    appId: string;
+    channel: string;
+    releaseId: string;
+    reused: boolean;
+    rollout: number;
+    stage: 'published';
+};
+export type AbsoluteMobileUpdatePromotion = {
+    appId: string;
+    channel: string;
+    releaseId: string;
+    rollout: number;
+    stage: 'promoted';
+};
+export type AbsoluteMobileUpdateRollback = {
+    appId: string;
+    channel: string;
+    releaseId?: string;
+    stage: 'rolled-back';
+};
+export type AbsoluteMobileUpdatePublisher = {
+    publishUpdate(options: {
+        manifest: Awaited<ReturnType<typeof readAbsoluteMobileUpdate>>;
+        releaseDirectory: string;
+        rollout: number;
+        signal?: AbortSignal;
+    }): Promise<AbsoluteMobileUpdatePublication>;
+    promoteUpdate(options: {
+        appId: string;
+        channel: string;
+        releaseId: string;
+        rollout: number;
+        signal?: AbortSignal;
+    }): Promise<AbsoluteMobileUpdatePromotion>;
+    rollbackUpdate(options: {
+        appId: string;
+        channel: string;
+        releaseId?: string;
+        signal?: AbortSignal;
+    }): Promise<AbsoluteMobileUpdateRollback>;
+};
+export declare const loadAbsoluteMobileUpdatePublisher: (projectRoot: string, requestedModulePath: string) => Promise<AbsoluteMobileUpdatePublisher>;
+export declare const promoteAbsoluteMobileUpdate: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    releaseId: string;
+    rollout: number;
+    signal?: AbortSignal;
+}) => Promise<AbsoluteMobileUpdatePromotion>;
+export declare const publishAbsoluteMobileUpdate: (options: {
+    projectRoot: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    releaseDirectory: string;
+    rollout: number;
+    signal?: AbortSignal;
+}) => Promise<AbsoluteMobileUpdatePublication>;
+export declare const rollbackAbsoluteMobileUpdate: (options: {
+    appId: string;
+    channel: string;
+    publisher: AbsoluteMobileUpdatePublisher;
+    releaseId?: string;
+    signal?: AbortSignal;
+}) => Promise<AbsoluteMobileUpdateRollback>;