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

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

@@ -0,0 +1,35 @@
+import { type AbsoluteMobilePageResult, type AbsoluteMobileUpgradeRequiredResult } from './pageProtocol';
+type AbsoluteMobileClientTarget = {
+    __ABSOLUTE_PAGE_RENDER_MODE__?: 'client' | 'hydrate';
+    __INITIAL_PROPS__?: Record<string, unknown>;
+};
+export type AbsoluteMobilePageLoader = (input: {
+    contract: string;
+    pageId: string;
+}) => Promise<unknown>;
+export type AbsoluteMobilePageActivation = {
+    kind: 'rendered';
+    contract: string;
+    pageId: string;
+} | AbsoluteMobileUpgradeRequiredResult;
+export type AbsoluteMobilePageActivationOptions = {
+    loadPage: AbsoluteMobilePageLoader;
+    target?: AbsoluteMobileClientTarget;
+};
+export declare class AbsoluteMobilePageProtocolError extends Error {
+    readonly code: 'invalid-envelope' | 'invalid-props' | 'server-error' | 'server-rejected-request';
+    constructor(code: AbsoluteMobilePageProtocolError['code'], message: string);
+}
+export declare const activateAbsoluteMobilePage: (value: unknown, options: AbsoluteMobilePageActivationOptions) => Promise<AbsoluteMobileUpgradeRequiredResult | {
+    contract: string;
+    kind: "rendered";
+    pageId: string;
+}>;
+export declare const parseAbsoluteMobilePageEnvelope: (value: unknown) => {
+    protocol: 1;
+    response: AbsoluteMobilePageResult;
+} | {
+    protocol: 1;
+    response: AbsoluteMobileUpgradeRequiredResult;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { Elysia } from 'elysia';
+import { type AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+export type AbsoluteMobileCompatibilityProducerHandler = {
+    handle: (request: Request) => Promise<Response> | Response;
+};
+export type AbsoluteMobileCompatibilityProducerLoader = (artifact: AbsoluteMobileCompatibilityArtifact) => Promise<AbsoluteMobileCompatibilityProducerHandler>;
+export type AbsoluteMobileCompatibilityDispatcherOptions = {
+    artifacts: readonly AbsoluteMobileCompatibilityArtifact[];
+    currentReleaseId: string;
+    loadProducer: AbsoluteMobileCompatibilityProducerLoader;
+};
+export declare const createAbsoluteMobileCompatibilityDispatcher: (options: AbsoluteMobileCompatibilityDispatcherOptions) => Elysia<"", "local", {
+    decorator: {};
+    store: {};
+    derive: {};
+}, {
+    typebox: {};
+    error: [];
+}, {
+    schema: {};
+    schemas: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;

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

@@ -0,0 +1,16 @@
+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;
+    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

@@ -0,0 +1,19 @@
+export * from './artifactStore';
+export * from './androidRelease';
+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 './routeMetadataTransform';
+export * from './routeMatcher';
+export * from './transport';

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

@@ -0,0 +1,36 @@
+import { type AbsoluteMobileStoredCompatibilityRelease } from './artifactStore';
+import type { AbsoluteMobileCompatibilityDispatcherOptions } from './compatibilityDispatcher';
+import { type AbsoluteMobileCompatibilityArtifact } from './releaseArtifact';
+export declare const ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT: 1;
+export type AbsoluteMobileMaterializedBundleInput = {
+    currentReleaseId: string;
+    releases: readonly AbsoluteMobileStoredCompatibilityRelease[];
+    root: string;
+};
+export type AbsoluteMobileMaterializedBundleIndex = {
+    bundleId: string;
+    currentReleaseId: string;
+    format: typeof ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT;
+    releases: AbsoluteMobileCompatibilityArtifact[];
+};
+export declare const loadAbsoluteMobileMaterializedBundle: (root: string) => Promise<AbsoluteMobileCompatibilityDispatcherOptions>;
+export declare const materializeAbsoluteMobileCompatibilityBundle: (input: AbsoluteMobileMaterializedBundleInput) => Promise<{
+    bundleId: string;
+    currentReleaseId: string;
+    format: 1;
+    releases: AbsoluteMobileCompatibilityArtifact[];
+}>;
+export declare const readAbsoluteMobileMaterializedReleases: (root: string) => Promise<{
+    artifact: {
+        releaseId: string;
+        pages: import("./releaseArtifact").AbsoluteMobileCompatibilityPage[];
+        routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
+        format: typeof import("./releaseArtifact").ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+        runtime: string;
+        appBuild: string;
+        appId: string;
+        generation: number;
+        producer: import("./releaseArtifact").AbsoluteMobileCompatibilityProducer;
+    };
+    producer: Bun.BunFile;
+}[]>;

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

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

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

@@ -0,0 +1,89 @@
+export declare const ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+export declare const ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION: 1;
+declare const SERVER_ERROR_STATUS = 500;
+export declare const MOBILE_PAGE_REQUEST_HEADERS: {
+    readonly appBuild: "x-absolute-mobile-app-build";
+    readonly pageBundle: "x-absolute-mobile-page-bundle";
+    readonly pageContracts: "x-absolute-mobile-page-contracts";
+    readonly pageId: "x-absolute-mobile-page-id";
+    readonly protocol: "x-absolute-mobile-protocol";
+    readonly runtime: "x-absolute-mobile-runtime";
+};
+export type AbsoluteMobilePageFramework = 'angular' | 'ember' | 'html' | 'htmx' | 'react' | 'svelte' | 'vue';
+export type AbsoluteMobilePageClient = {
+    appBuild: string;
+    pageBundle: string;
+    pageContracts: string[];
+    pageId: string;
+    protocol: number;
+    runtime: string;
+};
+export type AbsoluteMobilePageRepresentation<Props> = {
+    /** Stable data contract understood by an embedded page bundle. */
+    contract: string;
+    /**
+     * Adapts the current route props to an older compatible contract. The
+     * current representation normally uses the identity function.
+     */
+    mapProps: (props: Props) => Record<string, unknown>;
+};
+export type AbsoluteMobilePageCompatibility<Props> = {
+    framework: AbsoluteMobilePageFramework;
+    pageId: string;
+    /** Newest representation first, followed by retained compatibility forms. */
+    representations: readonly AbsoluteMobilePageRepresentation<Props>[];
+    /** Current runtime plus every retained compatible runtime generation. */
+    runtimes: readonly string[];
+};
+export type AbsoluteMobilePageResult = {
+    kind: 'page';
+    contract: string;
+    framework: AbsoluteMobilePageFramework;
+    pageId: string;
+    props: Record<string, unknown>;
+    status: number;
+};
+export type AbsoluteMobileUpgradeReason = 'app-release' | 'page-contract' | 'protocol' | 'runtime';
+export type AbsoluteMobileUpgradeRequiredResult = {
+    kind: 'upgrade-required';
+    reason: AbsoluteMobileUpgradeReason;
+    pageId: string;
+    supportedContracts?: string[];
+    supportedRuntimes?: string[];
+};
+export type AbsoluteMobileInvalidRequestResult = {
+    kind: 'invalid-request';
+    message: string;
+};
+export type AbsoluteMobilePageErrorResult = {
+    code: 'representation-failed';
+    kind: 'error';
+    pageId: string;
+    status: typeof SERVER_ERROR_STATUS;
+};
+export type AbsoluteMobilePageEnvelope = {
+    protocol: typeof ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
+    response: AbsoluteMobilePageErrorResult | AbsoluteMobileInvalidRequestResult | AbsoluteMobilePageResult | AbsoluteMobileUpgradeRequiredResult;
+};
+type ParsedMobilePageRequest = {
+    kind: 'not-mobile';
+} | {
+    kind: 'invalid';
+    message: string;
+} | {
+    kind: 'mobile';
+    client: AbsoluteMobilePageClient;
+};
+type FinalizeAbsoluteMobilePageInput<Props> = {
+    compatibility: AbsoluteMobilePageCompatibility<Props>;
+    props: Props;
+    request: Request | undefined;
+    status?: number;
+};
+export declare const acceptsAbsoluteMobilePage: (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;
+export declare const createAbsoluteMobileUpgradeResponse: (result: AbsoluteMobileUpgradeRequiredResult) => Response;
+export declare const finalizeAbsoluteMobilePage: <Props>(input: FinalizeAbsoluteMobilePageInput<Props>) => Response | undefined;
+export {};

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

@@ -0,0 +1,4 @@
+import { type AbsoluteMobileProducerContext } from './producerContextState';
+export type { AbsoluteMobileProducerContext } from './producerContextState';
+export { getCurrentAbsoluteMobileProducerContext } from './producerContextState';
+export declare const runWithAbsoluteMobileProducer: <Result>(context: AbsoluteMobileProducerContext, callback: () => Result) => Result;

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

@@ -0,0 +1,10 @@
+import type { AbsoluteMobileCompatibilityPage } from './releaseArtifact';
+export type AbsoluteMobileProducerContext = {
+    page: AbsoluteMobileCompatibilityPage;
+    releaseId: string;
+};
+export declare const ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY: unique symbol;
+export declare const getCurrentAbsoluteMobileProducerContext: () => {
+    page: AbsoluteMobileCompatibilityPage;
+    releaseId: string;
+} | undefined;

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

@@ -0,0 +1,75 @@
+import type { AbsoluteMobilePageClient, AbsoluteMobilePageFramework, AbsoluteMobileUpgradeRequiredResult } from './pageProtocol';
+export declare const ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT: 1;
+export declare const ABSOLUTE_MOBILE_RETAINED_GENERATIONS = 3;
+export type AbsoluteMobileCompatibilityPage = {
+    bundleHash: string;
+    bundlePath: string;
+    contract: string;
+    framework: AbsoluteMobilePageFramework;
+    pageId: string;
+    propsSchemaHash: string;
+};
+export type AbsoluteMobileCompatibilityRoute = {
+    method: 'GET' | 'HEAD';
+    pageId: string;
+    pattern: string;
+};
+export type AbsoluteMobileCompatibilityProducer = {
+    bundleHash: string;
+    bytes: number;
+    exportName: string;
+    module: string;
+};
+export type AbsoluteMobileCompatibilityArtifactInput = {
+    appBuild: string;
+    appId: string;
+    generation: number;
+    pages: readonly AbsoluteMobileCompatibilityPage[];
+    producer: AbsoluteMobileCompatibilityProducer;
+    routes: readonly AbsoluteMobileCompatibilityRoute[];
+    runtime: string;
+};
+export type AbsoluteMobileCompatibilityArtifact = {
+    appBuild: string;
+    appId: string;
+    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+    generation: number;
+    pages: AbsoluteMobileCompatibilityPage[];
+    producer: AbsoluteMobileCompatibilityProducer;
+    releaseId: string;
+    routes: AbsoluteMobileCompatibilityRoute[];
+    runtime: string;
+};
+export type AbsoluteMobileResolvedRelease = {
+    artifact: AbsoluteMobileCompatibilityArtifact;
+    kind: 'retained';
+    page: AbsoluteMobileCompatibilityPage;
+} | {
+    kind: 'upgrade-required';
+    result: AbsoluteMobileUpgradeRequiredResult;
+};
+export declare const createAbsoluteMobileCompatibilityArtifact: (input: AbsoluteMobileCompatibilityArtifactInput) => {
+    releaseId: string;
+    pages: AbsoluteMobileCompatibilityPage[];
+    routes: AbsoluteMobileCompatibilityRoute[];
+    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+    runtime: string;
+    appBuild: string;
+    appId: string;
+    generation: number;
+    producer: AbsoluteMobileCompatibilityProducer;
+};
+export declare const hashAbsoluteMobilePropsSchema: (schema: unknown) => string;
+export declare const parseAbsoluteMobileCompatibilityArtifact: (value: unknown) => {
+    releaseId: string;
+    pages: AbsoluteMobileCompatibilityPage[];
+    routes: AbsoluteMobileCompatibilityRoute[];
+    format: typeof ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+    runtime: string;
+    appBuild: string;
+    appId: string;
+    generation: number;
+    producer: AbsoluteMobileCompatibilityProducer;
+};
+export declare const resolveAbsoluteMobileCompatibilityRelease: (client: AbsoluteMobilePageClient, artifacts: readonly AbsoluteMobileCompatibilityArtifact[]) => AbsoluteMobileResolvedRelease;
+export declare const retainAbsoluteMobileCompatibilityArtifacts: (artifacts: readonly AbsoluteMobileCompatibilityArtifact[]) => AbsoluteMobileCompatibilityArtifact[];

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

@@ -0,0 +1,13 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type AbsoluteMobileReleaseCheck = {
+    detail: string;
+    id: string;
+    path?: string;
+    remediation?: string;
+    status: 'fail' | 'pass';
+};
+export type AbsoluteMobileReleaseDoctorResult = {
+    checks: AbsoluteMobileReleaseCheck[];
+    ready: boolean;
+};
+export declare const inspectAbsoluteMobileRelease: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<AbsoluteMobileReleaseDoctorResult>;

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

@@ -0,0 +1,3 @@
+import type { AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
+export declare const matchesAbsoluteMobileRoutePattern: (pattern: string, pathname: string) => boolean;
+export declare const resolveAbsoluteMobileRoute: (routes: readonly AbsoluteMobileCompatibilityRoute[], pathname: string, method?: "GET" | "HEAD") => AbsoluteMobileCompatibilityRoute | undefined;

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

@@ -0,0 +1,13 @@
+import type { BunPlugin } from 'bun';
+import { type AbsoluteMobileBuildPageMetadata } from './buildMetadata';
+type MobileRouteTransformOptions = {
+    entry: string;
+    projectRoot?: string;
+};
+export declare const ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL: 1;
+export declare const createAbsoluteMobileRouteMetadataPlugin: (options: MobileRouteTransformOptions) => BunPlugin;
+export declare const inspectAbsoluteMobileRouteMetadata: (options: MobileRouteTransformOptions) => {
+    file: string;
+    metadata: AbsoluteMobileBuildPageMetadata;
+}[];
+export {};

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

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

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

@@ -0,0 +1,31 @@
+import { type AbsoluteMobilePageActivationOptions } from './client';
+import type { AbsoluteMobileCompatibilityPage, AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
+export declare const ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT: 1;
+export type AbsoluteMobileClientPage = AbsoluteMobileCompatibilityPage & {
+    localBundlePath: string;
+};
+export type AbsoluteMobileClientManifest = {
+    appBuild: string;
+    appId: string;
+    appName: string;
+    deepLinkHosts: string[];
+    deepLinkScheme?: string;
+    entry: string;
+    format: typeof ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT;
+    pages: AbsoluteMobileClientPage[];
+    productionOrigin: string;
+    routes: AbsoluteMobileCompatibilityRoute[];
+    runtime: string;
+};
+export type AbsoluteMobileTransportOptions = {
+    fetch?: typeof globalThis.fetch;
+    headers?: HeadersInit;
+};
+export declare const createAbsoluteMobilePageRequest: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Request;
+export declare const fetchAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Promise<unknown>;
+export declare const navigateAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options: AbsoluteMobileTransportOptions & AbsoluteMobilePageActivationOptions) => Promise<import("./pageProtocol").AbsoluteMobileUpgradeRequiredResult | {
+    contract: string;
+    kind: "rendered";
+    pageId: string;
+}>;
+export declare const resolveAbsoluteMobileDeepLink: (manifest: AbsoluteMobileClientManifest, value: string) => string;

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

@@ -1,4 +1,3 @@
-import { Elysia } from 'elysia';
 export type DevtoolsJsonOptions = {
     projectRoot?: string;
     uuid?: string;
@@ -6,53 +5,13 @@ export type DevtoolsJsonOptions = {
     normalizeForWindowsContainer?: boolean;
 };
 export declare const resolveDevtoolsUuidCachePath: (buildDir: string, uuidCachePath?: string) => string;
-export declare const devtoolsJson: (buildDir: string, options?: DevtoolsJsonOptions) => Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
+export declare const devtoolsJson: (buildDir: string, options?: DevtoolsJsonOptions) => import("elysia/types").AddRoute<"", "local", import("elysia/types").DefaultSingleton, {
     typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
-    ".well-known": {
-        appspecific: {
-            "com.chrome.devtools.json": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            workspace: {
-                                root: string;
-                                uuid: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
+    error: [];
+}, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral, "get", "/.well-known/appspecific/com.chrome.devtools.json", import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, "/.well-known/appspecific/com.chrome.devtools.json">, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, () => {
+    workspace: {
+        root: string;
+        uuid: string;
     };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
 }>;
 export declare const normalizeDevtoolsWorkspaceRoot: (root: string) => string;