@absolutejs/absolute 0.20.0-beta.3 → 0.20.0-beta.30

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

@@ -0,0 +1,85 @@
+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;
+    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[];
+    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/remoteMacAgent.d.ts

@@ -0,0 +1,2 @@
+export declare const runAbsoluteRemoteMacAgent: (args: string[]) => Promise<void>;
+export declare const runAbsoluteRemoteMacAgentSafely: (args: string[]) => Promise<void>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,114 @@
+import type { FileSink } from 'bun';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import type { AbsoluteIosDevPhaseTiming, AbsoluteIosDevSession, AbsoluteIosDevState, AbsoluteIosNativeLogEntry } from './iosSimulatorController';
+export { ABSOLUTE_REMOTE_MAC_EVENT_PREFIX, ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION } from './remoteMacWire';
+export type AbsoluteRemoteMacProfile = {
+    bunPath: string;
+    createdAt: string;
+    destination: string;
+    name: string;
+    port?: number;
+    workspaceRoot: string;
+    xcodeVersion: string;
+};
+export type AbsoluteRemoteMacInspection = {
+    bunPath: string;
+    home: string;
+    os: string;
+    xcodeVersion: string;
+};
+export type AbsoluteRemoteIosDevProject = {
+    cap: string;
+    config: NormalizedAbsoluteMobileConfig;
+    nativeDirectory: string;
+    projectRoot: string;
+    profile: AbsoluteRemoteMacProfile;
+    remoteProjectRoot: string;
+    remote: true;
+    xcodebuild: string;
+    xcrun: string;
+};
+export type AbsoluteIosDevelopmentProject = AbsoluteRemoteIosDevProject | (import('./iosSimulatorController').AbsoluteIosDevProject & {
+    remote?: false;
+});
+export type AbsoluteRemoteMacCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type AbsoluteRemoteMacTransport = {
+    capture: (command: string[]) => Promise<AbsoluteRemoteMacCommandResult>;
+    spawn: (command: string[], options: {
+        signal?: AbortSignal;
+    }) => {
+        exited: Promise<number>;
+        kill: () => void;
+        stderr: ReadableStream<Uint8Array>;
+        stdin: FileSink;
+        stdout: ReadableStream<Uint8Array>;
+    };
+};
+export type AbsoluteRemoteIosOptions = {
+    https?: boolean;
+    log?: (message: string) => void;
+    nativeLog?: (entry: AbsoluteIosNativeLogEntry) => void;
+    onPhaseTiming?: (timing: AbsoluteIosDevPhaseTiming) => void;
+    onStateChange?: (state: AbsoluteIosDevState) => void;
+    port: number;
+    project: AbsoluteRemoteIosDevProject;
+    signal?: AbortSignal;
+    installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
+        remotePath: string;
+        uploaded?: boolean;
+    }>;
+    syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+    transport?: AbsoluteRemoteMacTransport;
+};
+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[];
+export declare const getAbsoluteRemoteMacProfile: (name?: string, profilePath?: string) => Promise<AbsoluteRemoteMacProfile | undefined>;
+export declare const inspectAbsoluteRemoteMac: (destination: string, options?: {
+    acceptNew?: boolean;
+    port?: number;
+    transport?: Pick<AbsoluteRemoteMacTransport, "capture">;
+}) => Promise<{
+    bunPath: string;
+    home: string;
+    os: string;
+    xcodeVersion: string;
+}>;
+export declare const listAbsoluteRemoteMacProfiles: (profilePath?: string) => Promise<{
+    defaultProfile: string | undefined;
+    profiles: AbsoluteRemoteMacProfile[];
+}>;
+export declare const pairAbsoluteRemoteMac: (options: {
+    destination: string;
+    name: string;
+    port?: number;
+    profilePath?: string;
+    transport?: Pick<AbsoluteRemoteMacTransport, "capture">;
+    workspaceRoot?: string;
+}) => Promise<AbsoluteRemoteMacProfile>;
+export declare const removeAbsoluteRemoteMacProfile: (name: string, profilePath?: string) => Promise<boolean>;
+export declare const createAbsoluteRemoteIosDevProject: (config: NormalizedAbsoluteMobileConfig, projectRoot: string, profile: AbsoluteRemoteMacProfile) => AbsoluteRemoteIosDevProject;
+export declare const installAbsoluteRemoteMacAgent: (project: AbsoluteRemoteIosDevProject) => Promise<{
+    remotePath: string;
+    uploaded: boolean;
+    bytes: number;
+    path: string;
+    sha256: string;
+}>;
+export declare const materializeAbsoluteRemoteMacAgent: (projectRoot: string) => Promise<{
+    bytes: number;
+    path: string;
+    sha256: string;
+}>;
+export declare const absoluteRemoteProjectSyncCommands: (project: AbsoluteRemoteIosDevProject) => {
+    remote: string[];
+    tar: string[];
+};
+export declare const syncAbsoluteRemoteMacProject: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+export declare const startAbsoluteRemoteIosDevSession: (options: AbsoluteRemoteIosOptions) => Promise<AbsoluteIosDevSession>;

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

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

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,22 @@
-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 = {
+    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/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/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 | 302 | 101 | 102 | 103 | 201 | 202 | 203 | 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 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

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;

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

@@ -1,5 +1,6 @@
 import type { Component as VueComponent } from 'vue';
 import type { VuePropsOf } from '../../types/vue';
+import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type VuePageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
@@ -29,6 +30,8 @@ type VuePageClientMode = {
     indexPath: string;
 };
 export type VuePageRequestInput<Component extends VueComponent> = VuePageRenderOptions & VuePageClientMode & {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
     headTag?: `<head>${string}</head>`;
     pagePath: string;
     Page?: Component;