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

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

@@ -0,0 +1,24 @@
+import { type AbsoluteNativeAutomatedRun, type AbsoluteNativeTestReport } from './nativeTestReport';
+export type AbsoluteIosAutomatedResult = Omit<AbsoluteNativeAutomatedRun, 'platform' | 'targetId' | 'targetKind'> & {
+    targetId: string;
+    targetKind: 'device' | 'simulator';
+};
+export type AbsoluteIosPartnerReport = AbsoluteNativeTestReport;
+type CreateAbsoluteIosPartnerReportOptions = {
+    absolutejsVersion: string;
+    bunVersion: string;
+    generatedAt?: string;
+    macosVersion: string;
+    run: AbsoluteIosAutomatedResult;
+    xcodeVersion: string;
+};
+export declare const readPackageVersionForIosReport: (packageJsonPath: string) => Promise<string>;
+export declare const renderAbsoluteIosPartnerReport: (report: AbsoluteNativeTestReport) => string;
+export declare const sanitizeIosReportText: (value: string) => string;
+export declare const writeAbsoluteIosPartnerReport: (directory: string, report: AbsoluteNativeTestReport) => Promise<{
+    directory: string;
+    jsonPath: string;
+    markdownPath: string;
+}>;
+export declare const createAbsoluteIosPartnerReport: (options: CreateAbsoluteIosPartnerReportOptions) => AbsoluteNativeTestReport;
+export {};

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

@@ -0,0 +1,63 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type MobileBundleInspection = {
+    appBuild?: string;
+    auth?: boolean;
+    capabilities?: string[];
+    entryResolved?: boolean;
+    frameworks?: string[];
+    issue?: string;
+    manifest: string;
+    pageCount?: number;
+    routeCount?: number;
+    runtime?: string;
+    nativeRuntime?: string;
+    status: 'invalid' | 'missing' | 'valid';
+    sync?: boolean;
+    updates?: boolean;
+};
+export declare const inspectAbsoluteMobileBundle: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<{
+    manifest: string;
+    status: "missing";
+    appBuild?: undefined;
+    auth?: undefined;
+    capabilities?: undefined;
+    entryResolved?: undefined;
+    frameworks?: undefined;
+    nativeRuntime?: undefined;
+    pageCount?: undefined;
+    routeCount?: undefined;
+    runtime?: undefined;
+    sync?: undefined;
+    updates?: undefined;
+    issue?: undefined;
+} | {
+    appBuild: string;
+    auth: boolean;
+    capabilities: string[];
+    entryResolved: true;
+    frameworks: string[];
+    manifest: string;
+    nativeRuntime: string;
+    pageCount: number;
+    routeCount: number;
+    runtime: string;
+    status: "valid";
+    sync: boolean;
+    updates: boolean;
+    issue?: undefined;
+} | {
+    issue: string;
+    manifest: string;
+    status: "invalid";
+    appBuild?: undefined;
+    auth?: undefined;
+    capabilities?: undefined;
+    entryResolved?: undefined;
+    frameworks?: undefined;
+    nativeRuntime?: undefined;
+    pageCount?: undefined;
+    routeCount?: undefined;
+    runtime?: undefined;
+    sync?: undefined;
+    updates?: undefined;
+}>;

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

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

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

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

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

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

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

@@ -1,5 +1,11 @@
 import type { NormalizedAbsoluteMobileConfig } from './config';
 export declare const ABSOLUTE_AUTH_PACKAGE: "@absolutejs/auth";
+export declare const ABSOLUTE_EXPO_AUTH_CORE_VERSION: "0.75.6";
+export declare const ABSOLUTE_EXPO_AUTH_PACKAGE: "@absolutejs/auth-expo";
+export declare const ABSOLUTE_EXPO_AUTH_VERSION: "0.0.2";
+export declare const ABSOLUTE_EXPO_SYNC_CORE_VERSION: "2.31.0";
+export declare const ABSOLUTE_EXPO_SYNC_PACKAGE: "@absolutejs/sync-expo";
+export declare const ABSOLUTE_EXPO_SYNC_VERSION: "0.0.2";
 export declare const ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV: "ABSOLUTE_AUTH_NATIVE_CLIENTS";
 export declare const ABSOLUTE_NATIVE_AUTH_SCOPES: readonly ["openid", "profile"];
 export declare const ABSOLUTE_SYNC_PACKAGE: "@absolutejs/sync";

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

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

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

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

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

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

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

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

package/dist/src/mobile/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;