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

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

@@ -0,0 +1,16 @@
+import type { PwaConfig } from '../../types/build';
+export declare const injectPwaBootstrapHtml: (html: string) => string;
+export type AbsolutePwaBuildArtifacts = {
+    bootstrapBanner: string;
+    bootstrapPublicPath: string;
+    manifestPath?: string;
+    serviceWorkerPath: string;
+};
+export declare const materializeAbsolutePwa: ({ buildPath, config, generatedRoot, projectRoot, write }: {
+    buildPath: string;
+    config: PwaConfig;
+    generatedRoot: string;
+    projectRoot: string;
+    /** Incremental HMR builds reuse the stable artifacts from the full build. */
+    write?: boolean;
+}) => Promise<AbsolutePwaBuildArtifacts>;

package/dist/src/cli/config/server.d.ts

@@ -391,7 +391,7 @@ export declare const launchConfig: (args: string[], cwd?: string) => Promise<imp
         status?: number | keyof import("elysia").StatusMap;
         cookie?: Record<string, import("elysia").BaseCookie>;
     };
-    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 426 | 204 | 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 ? {
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 426 | 204 | 101 | 102 | 103 | 201 | 202 | 203 | 205 | 206 | 207 | 208 | 301 | 302 | 303 | 307 | 308 | 401 | 402 | 403 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 428 | 429 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

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

@@ -11,6 +11,7 @@ export declare const enrichInstances: (records: InstanceRecord[]) => Promise<{
     frameworks: string[];
     host: string;
     https: boolean;
+    iosRemoteMac?: string;
     logFile: string | null;
     name: string;
     pid: number;

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

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

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

@@ -0,0 +1,19 @@
+type TextBaseline = ReadonlyMap<number, string>;
+type SsrTextBaselines = WeakMap<Element, TextBaseline>;
+declare global {
+    interface Window {
+        __ABSOLUTE_SSR_TEXT_BASELINES__?: SsrTextBaselines;
+    }
+}
+/** Capture server-authored text before client modules load. Absolute page
+ * handlers install the same snapshot inline; this export supports custom
+ * documents and non-standard bootstraps. */
+export declare const captureSsrTextBaselines: (root: Element | null) => void;
+/** Temporarily restore server text while a framework attaches to SSR DOM,
+ * then reapply translated text. Paths preserve translations even when a
+ * framework replaces nodes while mounting. Genuine server/client mismatches
+ * are left unchanged. */
+export declare const prepareBrowserTranslationHydration: (root: Element | null) => (() => void) & {
+    hasTranslation: boolean;
+};
+export {};

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

@@ -2,3 +2,4 @@ export { createIslandManifestResolver } from './islandResolver';
 export { getStreamSwapRuntimeScript } from './streamSwap';
 export { createIslandStore, getIslandStoreServerSnapshot, initializeIslandStores, readIslandStore, subscribeIslandStore } from './islandStore';
 export { startIslands } from './islandRuntime';
+export { captureSsrTextBaselines, prepareBrowserTranslationHydration } from './browserTranslation';

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

@@ -0,0 +1,6 @@
+/** Inline this after SSR markup and before any client entry executes. The
+ * snapshot records server-authored text while keeping it out of the DOM, so
+ * browser translation remains free to edit the rendered text. */
+export declare const BROWSER_TRANSLATION_BASELINE_SCRIPT: string;
+export declare const browserTranslationBaselineTag: () => string;
+export declare const injectBrowserTranslationBaseline: (html: string) => string;

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

@@ -1,5 +1,6 @@
 import type { BuildConfig } from '../../types/build';
 declare const FRAMEWORK_DIR_KEYS: readonly ["reactDirectory", "svelteDirectory", "vueDirectory", "htmlDirectory", "htmxDirectory", "angularDirectory"];
+export declare const collectDepVendorSourceDirs: (config: BuildConfig) => string[];
 /** Result of `detectConfigChanges`: which framework dir keys were
  *  added and which were removed in the new config. The additive case
  *  is handled in-place by this function (vendor paths set, watchers

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

@@ -37,6 +37,337 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                     error: never;
                 };
             };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        ".well-known": {
+            appspecific: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                        error: never;
+                    };
+                };
+            };
+        };
+        "@src": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@stub": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@hmr": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@ng": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        hmr: {
+            subscribe: {
+                body: unknown;
+                headers: unknown;
+                query: unknown;
+                params: {};
+                response: {};
+            };
+        };
+        "hmr-status": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        connectedClients: number;
+                        connectedTargets: {
+                            [k: string]: number;
+                        };
+                        entryWatcherReady: boolean;
+                        isRebuilding: boolean;
+                        manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
+                        rebuildCount: number;
+                        rebuildQueue: string[];
+                        rebuildScheduled: boolean;
+                        timestamp: number;
+                    };
+                };
+                error: never;
+            };
+        };
+    } | {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {};
+                error: never;
+            };
+        };
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        ".well-known": {
+            appspecific: {
+                "com.chrome.devtools.json": {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                workspace: {
+                                    root: string;
+                                    uuid: string;
+                                };
+                            };
+                        };
+                        error: never;
+                    };
+                };
+            };
+        };
+        "@src": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@stub": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@hmr": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {};
+                    error: never;
+                };
+            };
+        };
+        "@ng": {
+            "*": {
+                get: {
+                    body: unknown;
+                    params: {
+                        "*": string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+        };
+        hmr: {
+            subscribe: {
+                body: unknown;
+                headers: unknown;
+                query: unknown;
+                params: {};
+                response: {};
+            };
+        };
+        "hmr-status": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        connectedClients: number;
+                        connectedTargets: {
+                            [k: string]: number;
+                        };
+                        entryWatcherReady: boolean;
+                        isRebuilding: boolean;
+                        manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
+                        rebuildCount: number;
+                        rebuildQueue: string[];
+                        rebuildScheduled: boolean;
+                        timestamp: number;
+                    };
+                };
+                error: never;
+            };
+        };
+    } | {
+        __absolute: {
+            requests: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("..").RequestRecord[];
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview-telemetry": {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: {
+                            readonly error: "invalid-preview-telemetry";
+                        };
+                        204: "No Content";
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {
@@ -141,8 +472,11 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                         entryWatcherReady: boolean;
                         isRebuilding: boolean;
                         manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
                         rebuildCount: number;
                         rebuildQueue: string[];
+                        rebuildScheduled: boolean;
                         timestamp: number;
                     };
                 };
@@ -173,6 +507,45 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                     error: never;
                 };
             };
+            "mobile-preview": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
+            "mobile-preview-telemetry": {
+                post: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: {
+                            readonly error: "invalid-preview-telemetry";
+                        };
+                        204: "No Content";
+                    };
+                    error: never;
+                };
+            };
+            "native-device-adapter.js": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: Response;
+                    };
+                    error: never;
+                };
+            };
         };
         ".well-known": {
             appspecific: {
@@ -277,8 +650,11 @@ export declare const prepare: (configOrPath?: string) => Promise<{
                         entryWatcherReady: boolean;
                         isRebuilding: boolean;
                         manifestKeys: string[];
+                        pendingBundleRebuilds: ("svelte" | "vue" | "angular")[];
+                        pendingFileChanges: number;
                         rebuildCount: number;
                         rebuildQueue: string[];
+                        rebuildScheduled: boolean;
                         timestamp: number;
                     };
                 };

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

@@ -17,6 +17,7 @@ export type HMRState = {
     isRebuilding: boolean;
     rebuildQueue: Set<string>;
     rebuildTimeout: NodeJS.Timeout | null;
+    pendingBundleRebuilds: Set<'angular' | 'svelte' | 'vue'>;
     fileChangeQueue: Map<string, string[]>;
     debounceTimeout: NodeJS.Timeout | null;
     fileHashes: Map<string, number>;

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

@@ -1,11 +1,13 @@
+export declare const normalizeDevCertificateHosts: (hosts?: readonly string[]) => string[];
 export declare const hasMkcert: () => boolean;
-export declare const ensureDevCert: () => {
+export declare const ensureDevCert: (hosts?: readonly string[]) => {
     cert: string;
     key: string;
 } | null;
-export declare const hasCert: () => boolean;
-export declare const loadDevCert: () => {
+export declare const hasCert: (hosts?: readonly string[]) => boolean;
+export declare const loadDevCert: (hosts?: readonly string[]) => {
     cert: string;
     key: string;
 } | null;
-export declare const setupMkcert: () => boolean;
+export declare const getDevCertificateAuthorityPath: () => string | null;
+export declare const setupMkcert: (hosts?: readonly string[]) => boolean;

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

@@ -0,0 +1,3 @@
+export declare const absoluteServerEntryCopyOwnerPid: (name: string) => number | null;
+export declare const isProcessAlive: (pid: number) => boolean;
+export declare const isStaleAbsoluteServerEntryCopy: (name: string, currentPid?: number, ownerIsAlive?: (pid: number) => boolean) => boolean;

package/dist/src/ember/browser.d.ts

@@ -1,19 +1,3 @@
-/**
- * Phase 1 Ember client entry.
- *
- * The page index file (emitted by the build) imports this module and
- * the user's compiled page module. We mount the page component into
- * `#ember-root` using the same `renderComponent` API SSR used — Ember
- * Router's hydration story is post-Phase-1 work; for v1 we re-render
- * client-side over the SSR'd HTML.
- *
- * `@ember/renderer` is loaded dynamically rather than via static import
- * because (a) the AbsoluteJS framework typecheck shouldn't require
- * ember-source as a dep, and (b) the resolved URL at runtime is
- * `/ember/vendor/ember_renderer.js` (the vendor build's output) rather
- * than the bare specifier — only the user's bundle pass knows which
- * mapping to apply.
- */
 declare global {
     interface Window {
         __INITIAL_PROPS__?: Record<string, unknown>;

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

@@ -0,0 +1,27 @@
+import { keyboard, network, platform, systemBars, type DeviceKeyboardState, type DeviceNetworkStatus, type DevicePlatformInfo } from '@absolutejs/devices';
+export type AbsoluteMobileAdaptiveShellState = {
+    availableHeight: number;
+    keyboard: DeviceKeyboardState;
+    network: DeviceNetworkStatus;
+    platform: DevicePlatformInfo;
+    viewportHeight: number;
+    viewportWidth: number;
+};
+declare global {
+    interface WindowEventMap {
+        'absolute:adaptive-shell-change': CustomEvent<AbsoluteMobileAdaptiveShellState>;
+    }
+}
+export type AbsoluteMobileAdaptiveShellDevices = {
+    keyboard: Pick<typeof keyboard, 'capability' | 'getState' | 'onChange'>;
+    network: Pick<typeof network, 'getStatus' | 'onChange'>;
+    platform: Pick<typeof platform, 'getInfo'>;
+    systemBars: Pick<typeof systemBars, 'capability' | 'setAppearance'>;
+};
+export type AbsoluteMobileAdaptiveShell = {
+    dispose(): Promise<void>;
+    refreshDocument(): void;
+    state(): AbsoluteMobileAdaptiveShellState;
+};
+/** Installs the framework-neutral environment contract owned by the native shell. */
+export declare const installAbsoluteMobileAdaptiveShell: (devices?: AbsoluteMobileAdaptiveShellDevices) => Promise<AbsoluteMobileAdaptiveShell>;

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

@@ -24,7 +24,7 @@ export type AbsoluteAndroidDevProject = {
     androidRoot: string;
     cap: string;
     config: NormalizedAbsoluteMobileConfig;
-    emulator: string;
+    emulator?: string;
     host: AbsoluteMobileHost;
     nativeDirectory: string;
     projectRoot: string;
@@ -47,6 +47,7 @@ export type AbsoluteAndroidDevPhaseTiming = {
 export type PrepareAbsoluteAndroidDevOptions = {
     createNativeProject: boolean;
     projectRoot: string;
+    target?: 'device' | 'emulator';
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
 };
 export type StartAbsoluteAndroidDevOptions = {
@@ -59,8 +60,14 @@ export type StartAbsoluteAndroidDevOptions = {
     /** Launch the locally embedded production web bundle while forwarding
      * `port` only for its configured backend. No dev-server URL is written. */
     embeddedBundle?: boolean;
+    /** A connected physical device selected explicitly by ADB serial. */
+    deviceSerial?: string;
+    /** CA certificate temporarily trusted only by this development app. */
+    certificateAuthorityPath?: string;
     port: number;
     project: AbsoluteAndroidDevProject;
+    /** Hostname or LAN address loaded by the physical device. */
+    serverHost?: string;
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
     signal?: AbortSignal;
     sleep?: (milliseconds: number) => Promise<void>;

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

@@ -7,7 +7,7 @@ export type AbsoluteAndroidReleaseMetadata = {
     appId: string;
     artifact: string;
     bytes: number;
-    engine: 'capacitor';
+    engine: 'capacitor' | 'expo';
     format: typeof ABSOLUTE_ANDROID_RELEASE_FORMAT;
     platform: 'android';
     releaseId: string;
@@ -22,12 +22,19 @@ export type BuildAbsoluteAndroidReleaseOptions = {
     androidRoot?: string;
     capture?: (command: string[], options?: AbsoluteAndroidCommandOptions) => AbsoluteAndroidCommandResult;
     config: NormalizedAbsoluteMobileConfig;
+    env?: Record<string, string | undefined>;
     host?: AbsoluteMobileHost;
     jarsigner?: string | null;
     outputDirectory?: string;
     projectRoot: string;
     run?: (command: string[], options?: AbsoluteAndroidCommandOptions) => Promise<number>;
     prepareVersionCode?: (buildIdentity: string) => Promise<number>;
+    signing?: {
+        keyAlias: string;
+        keyPasswordEnvironment: string;
+        keystorePath: string;
+        storePasswordEnvironment: string;
+    };
     versionCode?: number;
 };
 export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroidReleaseOptions) => Promise<{
@@ -43,7 +50,7 @@ export declare const buildAbsoluteAndroidRelease: (options: BuildAbsoluteAndroid
         appBuild: string;
         appId: string;
         platform: "android";
-        engine: "capacitor";
+        engine: "capacitor" | "expo";
         signed: boolean;
         versionCode?: number | undefined;
     };

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

@@ -0,0 +1,14 @@
+import { type AbsoluteNativeAutomatedRun } from './nativeTestReport';
+export type AbsoluteAndroidAutomatedResult = Omit<AbsoluteNativeAutomatedRun, 'platform' | 'targetId' | 'targetKind'> & {
+    serial: string;
+};
+type CreateAbsoluteAndroidTestReportOptions = {
+    absolutejsVersion: string;
+    adbVersion: string;
+    bunVersion: string;
+    generatedAt?: string;
+    host: string;
+    run: AbsoluteAndroidAutomatedResult;
+};
+export declare const createAbsoluteAndroidTestReport: (options: CreateAbsoluteAndroidTestReportOptions) => import("./nativeTestReport").AbsoluteNativeTestReport;
+export {};