@absolutejs/absolute 0.20.0-beta.4 → 0.20.0-beta.41

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

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

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

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

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

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

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

@@ -8,6 +8,8 @@ export type AbsoluteMobileCompatibilityPage = {
     framework: AbsoluteMobilePageFramework;
     pageId: string;
     propsSchemaHash: string;
+    styleBundleHash?: string;
+    styleBundlePath?: string;
 };
 export type AbsoluteMobileCompatibilityRoute = {
     method: 'GET' | 'HEAD';

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

@@ -49,7 +49,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 +59,7 @@ export type AbsoluteRemoteIosOptions = {
     port: number;
     project: AbsoluteRemoteIosDevProject;
     signal?: AbortSignal;
+    serverHost?: string;
     installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
         remotePath: string;
         uploaded?: boolean;
@@ -69,6 +72,13 @@ export declare const validateAbsoluteSshDestination: (destination: string) => st
 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 +90,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[];

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

@@ -0,0 +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, options?: {
+    beforeSignOut?: () => Promise<void> | void;
+}) => Promise<AbsoluteMobileShellAuth>;

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

@@ -1 +1,23 @@
-export declare const startAbsoluteMobileShell: () => Promise<void>;
+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 = {
+    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);
+};
+export declare const startAbsoluteMobileShell: (options?: AbsoluteMobileShellOptions) => Promise<void>;

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

@@ -0,0 +1,3 @@
+/** Installs only capabilities implemented by the versioned Expo WebView bridge. */
+export declare const createAbsoluteExpoBridgeFetch: () => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare const installAbsoluteExpoWebDeviceAdapter: () => () => void;

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

@@ -0,0 +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';
+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/staticDocument.d.ts

@@ -0,0 +1,5 @@
+import type { AbsoluteMobileClientManifest, AbsoluteMobileClientPage } from './transport';
+export declare const hashAbsoluteMobileStaticDocument: (source: string) => Promise<string>;
+export declare const rewriteAbsoluteMobileHtmxRequests: (source: string, productionOrigin: string) => string;
+export declare const sanitizeAbsoluteMobileHtmxFragment: (source: string, productionOrigin: string, parse?: (source: string) => Document) => string;
+export declare const installAbsoluteMobileStaticDocument: (manifest: AbsoluteMobileClientManifest, page: AbsoluteMobileClientPage, localUrl: string) => 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,24 +1,38 @@
 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 & {
     localBundlePath: string;
+    localStylePath?: string;
 };
 export type AbsoluteMobileClientManifest = {
+    auth?: AbsoluteMobileAuthManifest;
     appBuild: string;
     appId: string;
     appName: string;
     deepLinkHosts: string[];
     deepLinkScheme?: string;
+    deviceCapabilities: string[];
     entry: string;
     format: typeof ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT;
     pages: AbsoluteMobileClientPage[];
     productionOrigin: string;
     routes: AbsoluteMobileCompatibilityRoute[];
     runtime: string;
+    sync?: {
+        socketTickets: true;
+        background: {
+            endpoint: string;
+            intervalMinutes: number;
+        };
+        storageSchema: SyncLocalStoreSchemaBundle;
+    };
 };
 export type AbsoluteMobileTransportOptions = {
-    fetch?: typeof globalThis.fetch;
+    fetch?: AbsoluteMobileFetch;
     headers?: HeadersInit;
 };
 export declare const createAbsoluteMobilePageRequest: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Request;
@@ -29,3 +43,4 @@ export declare const navigateAbsoluteMobilePage: (manifest: AbsoluteMobileClient
     pageId: string;
 }>;
 export declare const resolveAbsoluteMobileDeepLink: (manifest: AbsoluteMobileClientManifest, value: string) => string;
+export declare const resolveAbsoluteMobileNavigation: (manifest: AbsoluteMobileClientManifest, value: string, localOrigin: string) => string | undefined;

package/dist/src/plugins/hmr.d.ts

@@ -86,7 +86,10 @@ export declare const hmr: (hmrState: HMRState, manifest: Record<string, string>,
     entryWatcherReady: boolean;
     isRebuilding: boolean;
     manifestKeys: string[];
+    pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+    pendingFileChanges: number;
     rebuildCount: number;
     rebuildQueue: string[];
+    rebuildScheduled: boolean;
     timestamp: number;
 }>;

package/dist/src/plugins/imageOptimizer.d.ts

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

package/dist/src/react/hooks/useMediaQuery.d.ts

@@ -1,5 +1,5 @@
 import { Breakpoint, Breakpoints } from '../../../types/mediaQuery';
-export declare const UserAgentProvider: import("react").Provider<"console" | "other" | "bot" | "phone" | "tablet" | "tv" | "car" | "iot" | "desktop" | null>;
+export declare const UserAgentProvider: import("react").Provider<"console" | "other" | "phone" | "tablet" | "desktop" | "bot" | "tv" | "car" | "iot" | null>;
 export declare const useMediaQuery: (customBreakpoints?: Breakpoints) => {
     breakpoint: string;
     isSizeOrGreater: (target: Breakpoint) => boolean;

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

@@ -1,5 +1,6 @@
 import type { Component as SvelteComponent } from 'svelte';
 import type { SveltePropsOf } from '../../types/svelte';
+import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 export type SveltePageRenderOptions = {
     collectStreamingSlots?: boolean;
@@ -13,6 +14,8 @@ export type SveltePageRenderOptions = {
 } & StreamingSlotEnhancerOptions;
 type HasNoSvelteProps<Props> = [Props] extends [never] ? true : keyof Props extends never ? true : false;
 export type SveltePageRequestInput<Component extends SvelteComponent<never> = SvelteComponent<Record<never, never>>> = SveltePageRenderOptions & {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
     indexPath: string;
     pagePath: string;
     /** The incoming Elysia request. When provided, the request's pathname

package/dist/src/utils/imageProcessing.d.ts

@@ -24,6 +24,9 @@ export declare const getCacheKey: (url: string, width: number, quality: number,
 export declare const isCacheStale: (meta: CacheMeta) => boolean;
 export declare const matchRemotePattern: (urlString: string, patterns: RemotePattern[]) => boolean;
 export declare const negotiateFormat: (acceptHeader: string, configuredFormats: ImageFormat[]) => ImageFormat;
+/** The MIME type an image buffer actually is, from its magic bytes — used
+ *  when optimization fails and the original must be served as itself. */
+export declare const sniffImageMime: (buffer: Buffer) => "image/avif" | "image/gif" | "image/jpeg" | "image/png" | "image/webp" | null;
 export declare const optimizeImage: (buffer: Buffer | ArrayBuffer, width: number, quality: number, format: ImageFormat) => Promise<Buffer<ArrayBufferLike>>;
 export declare const readFromCache: (cacheDir: string, cacheKey: string) => {
     buffer: NonSharedBuffer;

package/dist/src/utils/loadConfig.d.ts

@@ -21,6 +21,7 @@ export declare const loadConfig: (configPath?: string) => Promise<{
     htmlDirectory?: string;
     htmxDirectory?: string;
     mobile?: import("..").MobileConfig;
+    pwa?: import("..").PwaConfig;
     stylesConfig?: string | import("..").StylesConfig;
     stylePreprocessors?: import("..").StylePreprocessorConfig;
     postcss?: import("..").PostCSSConfig;