@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

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

@@ -2,8 +2,12 @@ import type { FSWatcher } from 'fs';
 import { type DependencyGraph } from './dependencyGraph';
 import { type ModuleVersions } from './moduleVersionTracker';
 import type { HMRWebSocket } from '../../types/websocket';
-import type { BuildConfig } from '../../types/build';
+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,9 +29,14 @@ export type HMRState = {
     rebuildCount: number;
     lastHmrPath?: string;
     lastHmrFramework?: string;
+    lastBroadcastTimestamp: number;
+    hmrUpdates: Map<number, HMRUpdateMetadata>;
     lastUserEditedFiles?: Set<string>;
     initialBuildFailed?: boolean;
+    lastBuildErrors?: BuildPassError[];
+    svelteSurgicallyHandled?: Set<string>;
 };
 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/dev/rebuildTrigger.d.ts

@@ -5,6 +5,10 @@ export declare const queueFileChange: (state: HMRState, filePath: string, config
     hmrState: HMRState;
 }) => void) => Promise<void>;
 export type AngularHmrTier = 0 | 1 | 2;
+export declare const drainPendingQueue: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
+    manifest: Record<string, string>;
+    hmrState: HMRState;
+}) => void) => void;
 export declare const triggerRebuild: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
     manifest: Record<string, string>;
     hmrState: HMRState;

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

@@ -0,0 +1,31 @@
+import { Elysia } from 'elysia';
+export declare const requestInspector: Elysia<"", "local", {
+    decorator: {};
+    store: {};
+    derive: {};
+}, {
+    typebox: {};
+    error: [];
+}, {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    __absolute: {
+        requests: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: import("..").RequestRecord[];
+                };
+                error: never;
+            };
+        };
+    };
+}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;

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

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

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

@@ -1,5 +1,5 @@
-declare global {
-    var __absoluteEntryWatcherStarted: boolean | undefined;
-}
 export declare const isAtomicWriteTemp: (filename: string) => boolean;
+export declare const startFilePollingFallback: (path: string, onChange: () => void, interval?: number) => {
+    close: () => void;
+};
 export declare const startServerEntryWatcher: () => void;

package/dist/src/dev/tunnel/client.d.ts

@@ -0,0 +1,20 @@
+type TunnelClientOptions = {
+    /** Public relay base URL, e.g. `https://my-relay.ondigitalocean.app`. */
+    relayUrl: string;
+    /** Shared secret matching the relay's token. */
+    token: string;
+    /** Local app origin to replay requests against, e.g. `http://localhost:3000`. */
+    localOrigin: string;
+    /** Called once the relay confirms the public URL is live. */
+    onReady?: (publicUrl: string) => void;
+};
+/**
+ * Start the dev-side tunnel client. Dials the relay's control socket and
+ * replays each forwarded request against the local app, streaming responses
+ * back. Auto-reconnects so an HMR restart or a relay blip self-heals.
+ */
+export declare const startTunnelClient: (options: TunnelClientOptions) => {
+    publicUrl: string;
+    close(): void;
+};
+export {};

package/dist/src/dev/tunnel/protocol.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Reverse-tunnel wire protocol (pure Bun, no third-party deps).
+ *
+ * A dev machine behind NAT cannot accept inbound connections, so the dev
+ * `client` dials OUT to a public `relay` over a single control WebSocket. The
+ * relay receives public HTTP requests and forwards each one down that socket;
+ * the client replays it against the local app and sends the response back.
+ *
+ * Stage 1 covers HTTP request/response (webhooks). WebSocket passthrough for
+ * telephony media streams is layered on later with additional message types.
+ */
+/** Control-channel path the client connects to on the relay. */
+export declare const TUNNEL_CONTROL_PATH = "/__abs_tunnel/control";
+/** Header the relay strips/sets; lets the app know its public origin. */
+export declare const TUNNEL_FORWARDED_HOST_HEADER = "x-absolute-tunnel-host";
+/** A forwarded HTTP request (relay → client). Body is base64 (binary-safe). */
+export type TunnelRequestMessage = {
+    type: 'request';
+    id: string;
+    method: string;
+    /** Path + query, e.g. `/v1/sms/intake?x=1`. */
+    url: string;
+    headers: Record<string, string>;
+    bodyBase64?: string;
+};
+/** The client's response to a forwarded request (client → relay). */
+export type TunnelResponseMessage = {
+    type: 'response';
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    bodyBase64?: string;
+};
+/** Client could not produce a response (local app down, fetch threw). */
+export type TunnelErrorMessage = {
+    type: 'error';
+    id: string;
+    message: string;
+};
+/** Sent by the relay right after a successful auth handshake. */
+export type TunnelReadyMessage = {
+    type: 'ready';
+    /** Public base URL the relay is reachable at, e.g. `https://x.app`. */
+    publicUrl: string;
+};
+/** A public WS connection opened; client should dial the local app (relay → client). */
+export type TunnelWsOpenMessage = {
+    type: 'ws_open';
+    id: string;
+    /** Path + query of the upgraded request. */
+    url: string;
+    headers: Record<string, string>;
+};
+/** Result of the client opening the local WS (client → relay). */
+export type TunnelWsOpenAckMessage = {
+    type: 'ws_open_ack';
+    id: string;
+    ok: boolean;
+    error?: string;
+};
+/** One WS frame, either direction. Binary frames are base64. */
+export type TunnelWsDataMessage = {
+    type: 'ws_data';
+    id: string;
+    dataBase64: string;
+    binary: boolean;
+};
+/** A WS closed, either direction. */
+export type TunnelWsCloseMessage = {
+    type: 'ws_close';
+    id: string;
+    code?: number;
+    reason?: string;
+};
+/** App-level keepalive (either direction). */
+export type TunnelPingMessage = {
+    type: 'ping';
+};
+export type TunnelPongMessage = {
+    type: 'pong';
+};
+export type TunnelClientMessage = TunnelResponseMessage | TunnelErrorMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPongMessage | TunnelPingMessage;
+export type TunnelServerMessage = TunnelRequestMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage;
+export declare const decodeTunnelMessage: (raw: string) => TunnelRequestMessage | TunnelResponseMessage | TunnelErrorMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage | null;
+export declare const encodeTunnelMessage: (message: TunnelClientMessage | TunnelServerMessage) => string;

package/dist/src/dev/tunnel/relay.d.ts

@@ -0,0 +1,28 @@
+type RelayOptions = {
+    /** Port the relay listens on (App Platform injects PORT). */
+    port?: number;
+    /** Shared secret the dev client must present (?token=). */
+    token: string;
+    /** Public base URL the relay is reachable at. Falls back to the request
+     *  origin when omitted (App Platform: set APP_URL or pass explicitly). */
+    publicUrl?: string;
+    /** How long to wait for the dev client to answer a forwarded request. */
+    requestTimeoutMs?: number;
+};
+type ControlSocketData = {
+    control: true;
+};
+type PublicSocketData = {
+    control: false;
+    id: string;
+    url: string;
+    headers: Record<string, string>;
+};
+type SocketData = ControlSocketData | PublicSocketData;
+/**
+ * Start the public reverse-tunnel relay. Holds one dev-client control socket
+ * and forwards every other inbound HTTP request — and public WebSocket — down
+ * it. Single-tenant: the shared `token` gates the control channel.
+ */
+export declare const startTunnelRelay: (options: RelayOptions) => Bun.Server<SocketData>;
+export {};

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

@@ -1,5 +1,5 @@
 import type { HMRState } from './clientManager';
-import { type HMRWebSocket } from '../../types/websocket';
+import type { HMRWebSocket } from '../../types/websocket';
 export declare const broadcastToClients: (state: HMRState, message: {
     type: string;
     [key: string]: unknown;

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,99 @@
+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: AbsoluteAndroidDevProject) => 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>;
+    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,47 @@
+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';
+};
+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>;
+};
+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;
+    };
+    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/artifactStore.d.ts

@@ -0,0 +1,47 @@
+import { type AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+export type AbsoluteMobileStoredCompatibilityRelease = {
+    artifact: AbsoluteMobileCompatibilityArtifact;
+    producer: Blob;
+};
+export type AbsoluteMobileCompatibilityArtifactStore = {
+    delete: (appId: string, releaseId: string) => Promise<void>;
+    list: (appId: string) => Promise<AbsoluteMobileCompatibilityArtifact[]>;
+    read: (appId: string, releaseId: string) => Promise<AbsoluteMobileStoredCompatibilityRelease | null>;
+    write: (release: AbsoluteMobileStoredCompatibilityRelease) => Promise<void>;
+};
+export type AbsoluteMobileFileArtifactStoreOptions = {
+    maxProducerBytes?: number;
+    root: string;
+};
+export type AbsoluteMobileBlobStore = {
+    delete: (key: string) => Promise<void>;
+    get: (key: string) => Promise<Uint8Array | null>;
+    list: (options: {
+        cursor?: string;
+        prefix: string;
+    }) => Promise<{
+        cursor?: string;
+        objects: Array<{
+            key: string;
+        }>;
+        truncated: boolean;
+    }>;
+    put: (key: string, body: ReadableStream<Uint8Array> | Uint8Array | string, options?: {
+        contentType?: string;
+        maxBytes?: number;
+        metadata?: Record<string, string>;
+    }) => Promise<unknown>;
+};
+export type AbsoluteMobileBlobArtifactStoreOptions = {
+    maxProducerBytes?: number;
+    prefix?: string;
+    store: AbsoluteMobileBlobStore;
+};
+export type AbsoluteMobileCarryForwardInput = {
+    current: AbsoluteMobileStoredCompatibilityRelease;
+    store: AbsoluteMobileCompatibilityArtifactStore;
+};
+export declare const carryForwardAbsoluteMobileCompatibilityReleases: (input: AbsoluteMobileCarryForwardInput) => Promise<AbsoluteMobileStoredCompatibilityRelease[]>;
+export declare const createAbsoluteMobileBlobArtifactStore: (options: AbsoluteMobileBlobArtifactStoreOptions) => AbsoluteMobileCompatibilityArtifactStore;
+export declare const createAbsoluteMobileFileArtifactStore: (options: AbsoluteMobileFileArtifactStoreOptions) => AbsoluteMobileCompatibilityArtifactStore;
+export declare const verifyAbsoluteMobileCompatibilityProducer: (release: AbsoluteMobileStoredCompatibilityRelease, maxProducerBytes?: number) => Promise<AbsoluteMobileStoredCompatibilityRelease>;

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

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './pageProtocol';

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