@absolutejs/absolute 0.20.0-beta.0 → 0.20.0-beta.2

package/dist/src/build/resolveBuildMode.d.ts

@@ -0,0 +1,7 @@
+import type { BuildConfig } from '../../types/build';
+export declare const resolveBuildDevelopmentMode: (mode: BuildConfig["mode"], nodeEnv: string | undefined) => boolean;
+export declare const resolveVueFeatureFlags: (development: boolean) => {
+    __VUE_OPTIONS_API__: string;
+    __VUE_PROD_DEVTOOLS__: string;
+    __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: string;
+};

package/dist/src/cli/scripts/dev.d.ts

@@ -1,2 +1,5 @@
 export declare const formatServerBootDiagnostic: (output: string, serverEntry: string) => string | null;
-export declare const dev: (serverEntry: string, configPath?: string) => Promise<void>;
+export type AbsoluteDevOptions = {
+    mobile?: boolean;
+};
+export declare const dev: (serverEntry: string, configPath?: string, options?: AbsoluteDevOptions) => Promise<void>;

package/dist/src/cli/scripts/mobile.d.ts

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

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

@@ -2,10 +2,10 @@ import type { DbScripts } from '../../types/cli';
 export declare const COMPOSE_PATH = "db/docker-compose.db.yml";
 export declare const DEFAULT_SERVER_ENTRY = "src/backend/server.ts";
 export declare const isWSLEnvironment: () => boolean;
-export declare const findFreePort: () => number;
+export declare const findFreePort: () => Promise<number>;
 export declare const killStaleProcesses: (port: number, logMessage?: (message: string) => void) => void;
 export declare const openUrlInBrowser: (url: string, onError?: (message: string) => void) => boolean;
-export declare const printHelp: (subject?: string) => void;
+export declare const printHelp: (subject?: string, mobile?: boolean) => void;
 export declare const printHint: () => void;
 export declare const readDbScripts: () => Promise<{
     downCommand: string;

package/dist/src/core/build.d.ts

@@ -3,7 +3,7 @@ import type { ConventionsMap } from '../../types/conventions';
 import type { BuildConfig, BuildPassError, BunBuildConfigOverride, BunBuildPassKey } from '../../types/build';
 export declare const scanWorkerReferences: (dirs: string[]) => Promise<string[]>;
 type BunBuildOptions = Parameters<typeof bunBuild>[0];
-export declare const resolveBunBuildOverride: (config: BuildConfig["bunBuild"], pass: BunBuildPassKey) => Partial<Omit<Bun.BuildConfig, "entrypoints" | "outdir" | "root" | "target" | "format" | "throw" | "compile">>;
+export declare const resolveBunBuildOverride: (config: BuildConfig["bunBuild"], pass: BunBuildPassKey) => Partial<Omit<Bun.BuildConfig, "target" | "entrypoints" | "outdir" | "root" | "format" | "throw" | "compile">>;
 /** Resolve the Bun `sourcemap` mode for CLIENT bundles from the `sourcemaps`
  *  config. Dev always uses inline maps (HMR / devtools); production emits
  *  external maps only when explicitly enabled — they're then chained back to

package/dist/src/dev/clientManager.d.ts

@@ -4,6 +4,10 @@ import { type ModuleVersions } from './moduleVersionTracker';
 import type { HMRWebSocket } from '../../types/websocket';
 import type { BuildConfig, BuildPassError } from '../../types/build';
 import { type ResolvedBuildPaths } from './configResolver';
+type HMRUpdateMetadata = {
+    framework?: string;
+    path?: string;
+};
 export type HMRState = {
     connectedClients: Set<HMRWebSocket>;
     activeFrameworks: Set<string>;
@@ -25,6 +29,8 @@ export type HMRState = {
     rebuildCount: number;
     lastHmrPath?: string;
     lastHmrFramework?: string;
+    lastBroadcastTimestamp: number;
+    hmrUpdates: Map<number, HMRUpdateMetadata>;
     lastUserEditedFiles?: Set<string>;
     initialBuildFailed?: boolean;
     lastBuildErrors?: BuildPassError[];
@@ -33,3 +39,4 @@ export type HMRState = {
 export declare const createHMRState: (config: BuildConfig) => HMRState;
 export declare const incrementSourceFileVersion: (state: HMRState, filePath: string) => number;
 export declare const incrementSourceFileVersions: (state: HMRState, filePaths: string[]) => void;
+export {};

package/dist/src/dev/configResolver.d.ts

@@ -7,6 +7,8 @@ export declare const resolveBuildPaths: (config: BuildConfig) => {
     emberDir: string | undefined;
     htmlDir: string | undefined;
     htmxDir: string | undefined;
+    mobileBundleDir: string | undefined;
+    mobileNativeDir: string | undefined;
     publicDir: string | undefined;
     reactDir: string | undefined;
     stylesDir: string | undefined;

package/dist/src/dev/moduleMapper.d.ts

@@ -12,7 +12,7 @@ export declare const createModuleUpdates: (changedFiles: string[], framework: st
     vueDir?: string;
     angularDir?: string;
 }) => {
-    componentType: "server" | "client" | undefined;
+    componentType: "client" | "server" | undefined;
     framework: string;
     moduleKeys: string[];
     modulePaths: Record<string, string>;

package/dist/src/dev/moduleServer.d.ts

@@ -10,6 +10,7 @@ type ModuleServerConfig = {
     };
     stylePreprocessors?: StylePreprocessorConfig;
 };
+export declare const isReactFastRefreshSupported: () => boolean;
 export declare const warnIfReactFastRefreshUnsupported: () => void;
 export declare const warmCompilers: (frameworks: {
     svelte?: boolean;
@@ -17,7 +18,7 @@ export declare const warmCompilers: (frameworks: {
 }) => Promise<void>;
 export declare const createModuleServer: (config: ModuleServerConfig) => (pathname: string) => Promise<Response | undefined>;
 export declare const invalidateModule: (filePath: string) => void;
-export declare const warmCache: (pathname: string) => void;
+export declare const warmCache: (pathname: string) => Promise<void>;
 declare let globalModuleServer: ((pathname: string) => Promise<Response | undefined> | Response | undefined) | null;
 export declare const SRC_URL_PREFIX = "/@src/";
 export declare const setGlobalModuleServer: (handler: typeof globalModuleServer) => void;

package/dist/src/dev/pathUtils.d.ts

@@ -1,6 +1,6 @@
 import { BuildConfig } from '../../types/build';
 import type { ResolvedBuildPaths } from './configResolver';
-export declare const detectFramework: (filePath: string, resolved?: ResolvedBuildPaths) => "react" | "svelte" | "vue" | "angular" | "ember" | "html" | "unknown" | "ignored" | "styles" | "htmx" | "assets";
+export declare const detectFramework: (filePath: string, resolved?: ResolvedBuildPaths) => "react" | "svelte" | "vue" | "angular" | "ember" | "html" | "htmx" | "unknown" | "ignored" | "styles" | "assets";
 export declare const getWatchPaths: (config: BuildConfig, resolved?: ResolvedBuildPaths) => string[];
 /** A path is ignored when it is NOT inside any of the configured
  *  positive watch roots, OR when it falls inside a hard-denied

package/dist/src/dev/reactComponentClassifier.d.ts

@@ -1,2 +1,2 @@
 export type ComponentType = 'client' | 'server';
-export declare const classifyComponent: (filePath: string) => "server" | "client";
+export declare const classifyComponent: (filePath: string) => "client" | "server";

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

@@ -0,0 +1,42 @@
+import type { HMRApplyKind, HMRApplyOutcome, HMRClientTarget } from '../../types/messages';
+import type { AbsoluteAndroidWebViewSession } from './androidWebView';
+export type AbsoluteAndroidHmrApply = {
+    clientMs: number;
+    duration: number;
+    kind?: HMRApplyKind;
+    outcome: HMRApplyOutcome;
+    serverMs: number;
+    target: HMRClientTarget;
+    updateId?: number;
+};
+export type AbsoluteAndroidRouteCheck = {
+    bodyText: string;
+    hmrConnected: boolean;
+    lastApply?: AbsoluteAndroidHmrApply;
+    nativeTarget: string;
+    overlayVisible: boolean;
+    route: string;
+    title: string;
+    url: string;
+};
+export declare const absoluteAndroidDevelopmentUrl: (port: number, route: string, https?: boolean) => string;
+export declare const inspectAbsoluteAndroidRoute: (session: AbsoluteAndroidWebViewSession, options: {
+    https?: boolean;
+    port: number;
+    route: string;
+    timeoutMs?: number;
+}) => Promise<{
+    route: string;
+    title: string;
+    url: string;
+    bodyText: string;
+    hmrConnected: boolean;
+    lastApply?: AbsoluteAndroidHmrApply | undefined;
+    nativeTarget: string;
+    overlayVisible: boolean;
+}>;
+export declare const waitForAbsoluteAndroidHmrApply: (session: AbsoluteAndroidWebViewSession, options: {
+    afterUpdateId?: number;
+    kind?: HMRApplyKind;
+    timeoutMs?: number;
+}) => Promise<AbsoluteAndroidHmrApply>;

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

@@ -0,0 +1,100 @@
+import { type AbsoluteMobileHost } from './emulatorDoctor';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type AbsoluteAndroidCommandOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    signal?: AbortSignal;
+};
+export type AbsoluteAndroidCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type AbsoluteAndroidDevState = 'booting' | 'building' | 'closed' | 'closing' | 'configuring' | 'connecting' | 'failed' | 'forwarding' | 'installing' | 'checking-native' | 'launching' | 'ready' | 'streaming-logs' | 'syncing';
+export type AbsoluteAndroidNativeLogEntry = {
+    level: 'debug' | 'error' | 'fatal' | 'info' | 'verbose' | 'warn';
+    message: string;
+    tag: string;
+};
+type AbsoluteAndroidLogStream = {
+    close: () => Promise<void>;
+};
+export type AbsoluteAndroidDevProject = {
+    adb: string;
+    androidRoot: string;
+    cap: string;
+    config: NormalizedAbsoluteMobileConfig;
+    emulator: string;
+    host: AbsoluteMobileHost;
+    nativeDirectory: string;
+    projectRoot: string;
+};
+export type AbsoluteAndroidDevSession = {
+    close: () => Promise<void>;
+    nativeCacheHit: boolean;
+    rebuild: () => Promise<AbsoluteAndroidDevSession>;
+    relaunch: () => Promise<void>;
+    serial: string;
+    state: AbsoluteAndroidDevState;
+    startedEmulator: boolean;
+    timings: Record<string, number>;
+};
+export type AbsoluteAndroidDevPhaseTiming = {
+    durationMs: number;
+    phase: AbsoluteAndroidDevState;
+    totalMs: number;
+};
+export type PrepareAbsoluteAndroidDevOptions = {
+    createNativeProject: boolean;
+    projectRoot: string;
+    run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
+};
+export type StartAbsoluteAndroidDevOptions = {
+    capture?: (command: string[], options?: AbsoluteAndroidCommandOptions) => AbsoluteAndroidCommandResult;
+    log?: (message: string) => void;
+    nativeLog?: (entry: AbsoluteAndroidNativeLogEntry) => void;
+    onPhaseTiming?: (timing: AbsoluteAndroidDevPhaseTiming) => void;
+    onStateChange?: (state: AbsoluteAndroidDevState) => void;
+    https?: boolean;
+    port: number;
+    project: AbsoluteAndroidDevProject;
+    run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
+    signal?: AbortSignal;
+    sleep?: (milliseconds: number) => Promise<void>;
+    spawn?: (command: string[], options?: AbsoluteAndroidCommandOptions) => void;
+    startNativeLogs?: (command: string[], options: AbsoluteAndroidCommandOptions, onLine: (line: string) => void) => AbsoluteAndroidLogStream;
+};
+export declare const redactAbsoluteAndroidLog: (value: string) => string;
+export declare const isIgnorableAbsoluteAndroidLog: (entry: AbsoluteAndroidNativeLogEntry) => boolean;
+export declare const parseAbsoluteAndroidLogLine: (line: string) => AbsoluteAndroidNativeLogEntry | null;
+export declare const fingerprintAbsoluteAndroidNativeProject: (project: Pick<AbsoluteAndroidDevProject, "nativeDirectory">) => Promise<string>;
+export declare const repairAbsoluteAndroidDevSession: (projectRoot: string) => Promise<boolean>;
+export declare const parseAdbDevices: (output: string) => string[];
+export type AbsoluteAndroidGradleTask = 'assembleDebug' | 'assembleRelease' | 'bundleRelease';
+export type BuildAbsoluteAndroidGradleOptions = {
+    capture?: NonNullable<StartAbsoluteAndroidDevOptions['capture']>;
+    env?: Record<string, string | undefined>;
+    gradleArguments?: readonly string[];
+    project: Pick<AbsoluteAndroidDevProject, 'androidRoot' | 'config' | 'host' | 'nativeDirectory' | 'projectRoot'>;
+    run?: NonNullable<StartAbsoluteAndroidDevOptions['run']>;
+    signal?: AbortSignal;
+    task: AbsoluteAndroidGradleTask;
+};
+export declare const buildAbsoluteAndroidGradleArtifact: (options: BuildAbsoluteAndroidGradleOptions) => Promise<{
+    artifactPath: string;
+    installPath: string;
+}>;
+export declare const prepareAbsoluteAndroidDevProject: (config: NormalizedAbsoluteMobileConfig, options: PrepareAbsoluteAndroidDevOptions) => Promise<AbsoluteAndroidDevProject>;
+export declare const startAbsoluteAndroidDevSession: (options: StartAbsoluteAndroidDevOptions) => Promise<{
+    close: () => Promise<void>;
+    nativeCacheHit: boolean;
+    serial: string;
+    startedEmulator: boolean;
+    timings: {
+        [x: string]: number;
+    };
+    rebuild: () => Promise</*elided*/ any>;
+    relaunch: () => Promise<void>;
+    readonly state: AbsoluteAndroidDevState;
+}>;
+export {};

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

@@ -0,0 +1,19 @@
+import { type AbsoluteAndroidDevProject } from './androidEmulatorController';
+export type AbsoluteAndroidNativeChange = {
+    afterFingerprint: string;
+    beforeFingerprint: string;
+    paths: string[];
+    rootInputChanged: boolean;
+};
+export type AbsoluteAndroidNativeWatcher = {
+    close: () => void;
+};
+export type AbsoluteAndroidNativeWatcherOptions = {
+    debounceMs?: number;
+    onChange: (change: AbsoluteAndroidNativeChange) => Promise<void>;
+    onError?: (error: unknown) => void;
+    project: AbsoluteAndroidDevProject;
+    signal?: AbortSignal;
+};
+export declare const createAbsoluteAndroidNativeWatcher: (options: AbsoluteAndroidNativeWatcherOptions) => Promise<AbsoluteAndroidNativeWatcher>;
+export declare const isAbsoluteAndroidNativeRootInput: (path: string) => boolean;

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

@@ -0,0 +1,51 @@
+import { type AbsoluteMobileHost } from './emulatorDoctor';
+import { type AbsoluteAndroidCommandOptions, type AbsoluteAndroidCommandResult } from './androidEmulatorController';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const ABSOLUTE_ANDROID_RELEASE_FORMAT: 1;
+export type AbsoluteAndroidReleaseMetadata = {
+    appBuild: string;
+    appId: string;
+    artifact: string;
+    bytes: number;
+    engine: 'capacitor';
+    format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
+    platform: 'android';
+    releaseId: string;
+    runtime: string;
+    sha256: string;
+    signed: boolean;
+    type: 'aab';
+    versionCode?: number;
+};
+export type BuildAbsoluteAndroidReleaseOptions = {
+    allowUnsigned?: boolean;
+    androidRoot?: string;
+    capture?: (command: string[], options?: AbsoluteAndroidCommandOptions) => AbsoluteAndroidCommandResult;
+    config: NormalizedAbsoluteMobileConfig;
+    host?: AbsoluteMobileHost;
+    jarsigner?: string | null;
+    outputDirectory?: string;
+    projectRoot: string;
+    run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
+    prepareVersionCode?: (buildIdentity: string) => Promise<number>;
+    versionCode?: number;
+};
+export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroidReleaseOptions) => Promise<{
+    artifactPath: string;
+    metadata: {
+        artifact: string;
+        sha256: string;
+        type: "aab";
+        format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
+        bytes: number;
+        runtime: string;
+        releaseId: string;
+        appBuild: string;
+        appId: string;
+        platform: "android";
+        engine: "capacitor";
+        signed: boolean;
+        versionCode?: number | undefined;
+    };
+    releaseRoot: string;
+}>;

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

@@ -0,0 +1,46 @@
+type AndroidCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+type AndroidCommandCapture = (command: string[]) => AndroidCommandResult;
+type CdpTarget = {
+    description?: string;
+    title?: string;
+    type?: string;
+    url?: string;
+    webSocketDebuggerUrl?: string;
+};
+export type AbsoluteAndroidWebViewDiagnostic = {
+    level: 'error' | 'info' | 'warning';
+    message: string;
+    source: 'console' | 'exception' | 'log';
+};
+export type AbsoluteAndroidWebViewSession = {
+    close: () => Promise<void>;
+    diagnostics: readonly AbsoluteAndroidWebViewDiagnostic[];
+    evaluate: <T>(expression: string) => Promise<T>;
+    hostPort: number;
+    navigate: (url: string) => Promise<void>;
+    screenshot: (path: string) => Promise<string>;
+    serial: string;
+    socket: string;
+    target: CdpTarget;
+    waitFor: <T>(expression: string, options?: {
+        timeoutMs?: number;
+    }) => Promise<T>;
+};
+export type AttachAbsoluteAndroidWebViewOptions = {
+    adb: string;
+    appId: string;
+    capture?: AndroidCommandCapture;
+    fetch?: typeof fetch;
+    serial: string;
+    timeoutMs?: number;
+};
+export declare const parseAndroidWebViewDevtoolsSockets: (output: string, options: {
+    appId: string;
+    pids: readonly string[];
+}) => string[];
+export declare const attachAbsoluteAndroidWebView: (options: AttachAbsoluteAndroidWebViewOptions) => Promise<AbsoluteAndroidWebViewSession>;
+export {};

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

@@ -0,0 +1,49 @@
+import { Elysia } from 'elysia';
+import type { MobileConfig } from '../../types/build';
+import { type NormalizedAbsoluteMobileConfig } from './config';
+export type AbsoluteAssociationRequest = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare const ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json";
+export declare const APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
+export type AbsoluteMobileAssociationDocuments = {
+    android?: readonly [
+        {
+            relation: readonly ['delegate_permission/common.handle_all_urls'];
+            target: {
+                namespace: 'android_app';
+                package_name: string;
+                sha256_cert_fingerprints: string[];
+            };
+        }
+    ];
+    apple?: {
+        applinks: {
+            details: readonly [
+                {
+                    appIDs: readonly [string];
+                    components: readonly [{
+                        '/': '/*';
+                    }];
+                }
+            ];
+        };
+    };
+};
+export declare const createAbsoluteMobileAssociationDocuments: (config: NormalizedAbsoluteMobileConfig, options?: {
+    requireAll?: boolean;
+}) => AbsoluteMobileAssociationDocuments;
+export declare const createAbsoluteMobileAssociationPlugin: (mobile: MobileConfig | undefined, projectRoot: string, options?: {
+    requireAll?: boolean;
+}) => Elysia<"", "local", import("elysia/types").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;
+export declare const materializeAbsoluteMobileAssociationFiles: (config: NormalizedAbsoluteMobileConfig, outputDirectory: string) => Promise<{
+    root: string;
+    written: string[];
+}>;
+export declare const verifyAbsoluteMobileAssociationFiles: (config: NormalizedAbsoluteMobileConfig, request?: AbsoluteAssociationRequest) => Promise<{
+    results: {
+        platform: string;
+        url: string;
+    }[];
+}>;

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

@@ -0,0 +1,10 @@
+import type { AbsoluteMobilePageFramework } from './pageProtocol';
+export declare const ABSOLUTE_MOBILE_ROUTE_DETAIL: "x-absolute-mobile";
+export type AbsoluteMobileBuildPageMetadata = {
+    bundleKey: string;
+    contract: string;
+    framework: AbsoluteMobilePageFramework;
+    pageId: string;
+    propsSchemaHash: string;
+};
+export declare const parseAbsoluteMobileBuildPageMetadata: (value: unknown) => AbsoluteMobileBuildPageMetadata | undefined;

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

@@ -0,0 +1,8 @@
+import type { MobileConfig } from '../../types/build';
+export type FinalizeAbsoluteMobileBuildOptions = {
+    buildDirectory: string;
+    mobile: MobileConfig;
+    producerPath: string;
+    projectRoot: string;
+};
+export declare const finalizeAbsoluteMobileCompatibilityBuild: (options: FinalizeAbsoluteMobileBuildOptions) => Promise<import("./releaseArtifact").AbsoluteMobileCompatibilityArtifact>;

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

@@ -0,0 +1,24 @@
+import type { Elysia } from 'elysia';
+import { type AbsoluteMobileBuildPageMetadata } from './buildMetadata';
+import { type AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+import type { AbsoluteMobileStoredCompatibilityRelease } from './artifactStore';
+export type AbsoluteMobileBuildReleaseOptions = {
+    app: Pick<Elysia, 'compile' | 'modules' | 'routes'>;
+    appId: string;
+    buildDirectory: string;
+    manifest: Record<string, string>;
+    previousArtifacts?: readonly AbsoluteMobileCompatibilityArtifact[];
+    producerExport?: string;
+    producerModule?: string;
+    producerPath: string;
+    runtime: string;
+};
+export declare const buildAbsoluteMobileCompatibilityRelease: (options: AbsoluteMobileBuildReleaseOptions) => Promise<AbsoluteMobileStoredCompatibilityRelease>;
+export declare const captureAbsoluteMobileRouteGraph: (app: Pick<Elysia, "compile" | "modules" | "routes">) => Promise<{
+    metadata: AbsoluteMobileBuildPageMetadata;
+    route: {
+        method: "GET" | "HEAD";
+        pageId: string;
+        pattern: string;
+    };
+}[]>;

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

@@ -0,0 +1,28 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import type { AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+export type AbsoluteCapacitorBundleOptions = {
+    artifact: AbsoluteMobileCompatibilityArtifact;
+    buildDirectory: string;
+    config: NormalizedAbsoluteMobileConfig;
+};
+export declare const materializeAbsoluteCapacitorWebBundle: (options: AbsoluteCapacitorBundleOptions) => Promise<{
+    appBuild: string;
+    appId: string;
+    appName: string;
+    deepLinkHosts: string[];
+    deepLinkScheme: string | undefined;
+    entry: string;
+    format: 1;
+    pages: {
+        localBundlePath: string;
+        bundleHash: string;
+        bundlePath: string;
+        contract: string;
+        framework: import("./pageProtocol").AbsoluteMobilePageFramework;
+        pageId: string;
+        propsSchemaHash: string;
+    }[];
+    productionOrigin: string;
+    routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
+    runtime: string;
+}>;

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

@@ -0,0 +1,9 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type WriteAbsoluteCapacitorConfigOptions = {
+    force?: boolean;
+    projectRoot: string;
+};
+export declare const writeAbsoluteCapacitorConfig: (config: NormalizedAbsoluteMobileConfig, options: WriteAbsoluteCapacitorConfigOptions) => Promise<{
+    changed: boolean;
+    path: string;
+}>;

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

@@ -12,7 +12,7 @@ export type AbsoluteMobilePageActivation = {
     contract: string;
     pageId: string;
 } | AbsoluteMobileUpgradeRequiredResult;
-type AbsoluteMobilePageActivationOptions = {
+export type AbsoluteMobilePageActivationOptions = {
     loadPage: AbsoluteMobilePageLoader;
     target?: AbsoluteMobileClientTarget;
 };

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

@@ -0,0 +1,17 @@
+import type { MobileConfig, MobilePlatform } from '../../types/build';
+export type NormalizedAbsoluteMobileConfig = {
+    appId: string;
+    appName: string;
+    androidCertificateFingerprints: string[];
+    appleAppIdPrefix?: string;
+    bundleDirectory: string;
+    deepLinkHosts: string[];
+    deepLinkScheme?: string;
+    engine: 'capacitor';
+    entry: string;
+    iosVersion?: string;
+    nativeProjectDirectory: string;
+    platforms: MobilePlatform[];
+    productionOrigin: string;
+};
+export declare const normalizeAbsoluteMobileConfig: (config: MobileConfig, projectRoot: string) => NormalizedAbsoluteMobileConfig;

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

@@ -0,0 +1,25 @@
+export type AbsoluteMobileHost = 'macos' | 'windows' | 'linux' | 'wsl';
+export type AbsoluteMobileDoctorStatus = 'pass' | 'warn' | 'fail' | 'skip';
+export declare const ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36";
+export type AbsoluteMobileDoctorCheck = {
+    id: string;
+    label: string;
+    path?: string;
+    platform: 'host' | 'android' | 'ios';
+    remediation?: string;
+    status: AbsoluteMobileDoctorStatus;
+};
+export type InspectAbsoluteMobileToolchainOptions = {
+    androidRoot?: string | null;
+    capture?: (command: string[]) => {
+        exitCode: number;
+        stdout: string;
+    };
+    env?: Record<string, string | undefined>;
+    exists?: (path: string) => Promise<boolean>;
+    host?: AbsoluteMobileHost;
+    which?: (command: string) => string | null;
+};
+export declare const absoluteManagedAndroidSdkRoot: (host: AbsoluteMobileHost, env?: Record<string, string | undefined>) => string;
+export declare const detectAbsoluteMobileHost: (platform?: NodeJS.Platform, wsl?: boolean) => "linux" | "macos" | "windows" | "wsl";
+export declare const inspectAbsoluteMobileToolchain: (input?: InspectAbsoluteMobileToolchainOptions) => Promise<AbsoluteMobileDoctorCheck[]>;

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

@@ -0,0 +1,41 @@
+import { type AbsoluteMobileDoctorCheck, type AbsoluteMobileHost } from './emulatorDoctor';
+export type AbsoluteMobileInstallStep = {
+    detail: string;
+    id: string;
+    label: string;
+};
+export type AbsoluteMobileInstallPlan = {
+    androidRoot: string;
+    host: AbsoluteMobileHost;
+    platform: 'android' | 'ios';
+    steps: AbsoluteMobileInstallStep[];
+};
+export type AbsoluteMobileInstallResult = {
+    checks: AbsoluteMobileDoctorCheck[];
+    completed: string[];
+    plan: AbsoluteMobileInstallPlan;
+};
+type RunOptions = {
+    env?: Record<string, string | undefined>;
+    input?: string;
+};
+type CaptureResult = {
+    exitCode: number;
+    stdout: string;
+};
+type AbsoluteMobileInstallerDependencies = {
+    arch?: string;
+    capture?: (command: string[], options?: RunOptions) => CaptureResult;
+    download?: (url: string) => Promise<Uint8Array>;
+    env?: Record<string, string | undefined>;
+    exists?: (path: string) => Promise<boolean>;
+    host?: AbsoluteMobileHost;
+    log?: (message: string) => void;
+    run?: (command: string[], options?: RunOptions) => Promise<number>;
+    which?: (command: string) => string | null;
+};
+export declare const planAbsoluteMobileEmulatorInstall: (platform: "android" | "ios", input?: AbsoluteMobileInstallerDependencies) => AbsoluteMobileInstallPlan;
+export declare const fixAbsoluteMobileEmulatorToolchain: (platform: "android" | "ios", options?: AbsoluteMobileInstallerDependencies & {
+    acceptLicenses?: boolean;
+}) => Promise<AbsoluteMobileInstallResult>;
+export {};

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

@@ -1,7 +1,21 @@
 export * from './artifactStore';
+export * from './androidRelease';
+export * from './iosRelease';
+export * from './associationFiles';
+export * from './buildMetadata';
+export * from './buildPipeline';
+export * from './buildRelease';
+export * from './capacitorBundle';
+export * from './capacitorProject';
+export * from './config';
 export * from './client';
 export * from './compatibilityDispatcher';
 export * from './materializedBundle';
+export * from './nativeDeepLinks';
 export * from './pageProtocol';
 export * from './producerContext';
 export * from './releaseArtifact';
+export * from './releasePublisher';
+export * from './routeMetadataTransform';
+export * from './routeMatcher';
+export * from './transport';