@absolutejs/absolute 0.20.0-beta.66 → 0.20.0-beta.67

package/dist/mobile/mobilePreviewClient.ts

@@ -0,0 +1,246 @@
+import { installDeviceAdapter } from '@absolutejs/devices';
+import {
+	createAbsoluteHttpTransport,
+	installAbsoluteHttpTransport
+} from '@absolutejs/http';
+import {
+	createTestDeviceAdapter,
+	type TestDeviceController
+} from '@absolutejs/devices/testing';
+
+type PreviewMessage =
+	| { type: 'absolute-preview:back' }
+	| { type: 'absolute-preview:deep-link'; url: string }
+	| { type: 'absolute-preview:keyboard'; heightPx: number; visible: boolean }
+	| {
+			type: 'absolute-preview:lifecycle';
+			state: 'active' | 'background' | 'inactive';
+	  }
+	| {
+			type: 'absolute-preview:network';
+			connected: boolean;
+			connectionType: 'cellular' | 'none' | 'unknown' | 'wifi';
+	  }
+	| {
+			type: 'absolute-preview:permission';
+			capability: 'camera' | 'location' | 'notifications';
+			state: 'blocked' | 'denied' | 'granted' | 'prompt';
+	  };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === 'object' && value !== null;
+
+const isPreviewMessage = (value: unknown): value is PreviewMessage => {
+	if (!isRecord(value) || typeof value.type !== 'string') return false;
+	if (value.type === 'absolute-preview:back') return true;
+	if (value.type === 'absolute-preview:deep-link')
+		return typeof value.url === 'string';
+	if (value.type === 'absolute-preview:keyboard')
+		return (
+			typeof value.heightPx === 'number' &&
+			Number.isFinite(value.heightPx) &&
+			typeof value.visible === 'boolean'
+		);
+	if (value.type === 'absolute-preview:lifecycle')
+		return ['active', 'background', 'inactive'].includes(
+			String(value.state)
+		);
+	if (value.type === 'absolute-preview:network')
+		return (
+			typeof value.connected === 'boolean' &&
+			['cellular', 'none', 'unknown', 'wifi'].includes(
+				String(value.connectionType)
+			)
+		);
+	if (value.type === 'absolute-preview:permission')
+		return (
+			['camera', 'location', 'notifications'].includes(
+				String(value.capability)
+			) &&
+			['blocked', 'denied', 'granted', 'prompt'].includes(
+				String(value.state)
+			)
+		);
+
+	return false;
+};
+
+const previewPlatform = () =>
+	new URLSearchParams(location.search).get('__absolute_preview_platform') ===
+	'android'
+		? 'android'
+		: 'ios';
+
+const PREVIEW_STATE_KEY = Symbol.for('@absolutejs/mobile-preview/state');
+type AbsoluteMobilePreviewState = { connected: boolean };
+const isAbsoluteMobilePreviewState = (
+	value: unknown
+): value is AbsoluteMobilePreviewState =>
+	isRecord(value) && typeof value.connected === 'boolean';
+const getPreviewState = () => {
+	const existing = Reflect.get(globalThis, PREVIEW_STATE_KEY);
+	if (isAbsoluteMobilePreviewState(existing)) return existing;
+	const created: AbsoluteMobilePreviewState = { connected: true };
+	Reflect.set(globalThis, PREVIEW_STATE_KEY, created);
+
+	return created;
+};
+const previewState = getPreviewState();
+const browserFetch = globalThis.fetch;
+const nativeFetch = browserFetch.bind(globalThis);
+const isPreviewInfrastructureRequest = (url: URL) =>
+	url.origin === location.origin &&
+	(url.pathname.startsWith('/__absolute/') ||
+		url.pathname.startsWith('/@src/') ||
+		url.pathname === '/hmr-status');
+
+const previewPreconnect = (
+	...args: Parameters<typeof globalThis.fetch.preconnect>
+) => {
+	const preconnect = Reflect.get(browserFetch, 'preconnect');
+	if (typeof preconnect === 'function')
+		Reflect.apply(preconnect, browserFetch, args);
+};
+
+const previewFetch: typeof globalThis.fetch = Object.assign(
+	(
+		input: Parameters<typeof globalThis.fetch>[0],
+		init?: Parameters<typeof globalThis.fetch>[1]
+	) => {
+		const requestUrl = new URL(
+			input instanceof Request ? input.url : String(input),
+			location.href
+		);
+		if (
+			!previewState.connected &&
+			!isPreviewInfrastructureRequest(requestUrl)
+		) {
+			return Promise.reject(
+				new TypeError(
+					'AbsoluteJS mobile preview is offline. Restore connectivity from the preview controls.'
+				)
+			);
+		}
+
+		return nativeFetch(input, init);
+	},
+	{ preconnect: previewPreconnect }
+);
+
+const installPreviewFetch = () => {
+	globalThis.fetch = previewFetch;
+};
+
+let removePreviewHttpTransport: (() => void) | undefined;
+const installPreviewHttpTransport = () => {
+	removePreviewHttpTransport?.();
+	removePreviewHttpTransport = installAbsoluteHttpTransport(
+		createAbsoluteHttpTransport({
+			fetch: previewFetch,
+			origin: location.origin,
+			runtime: 'web'
+		})
+	);
+};
+
+installPreviewFetch();
+
+const postState = (
+	type: 'event' | 'ready',
+	detail: Record<string, unknown> = {}
+) => {
+	if (window.parent === window) return;
+	window.parent.postMessage(
+		{
+			...detail,
+			platform: previewPlatform(),
+			type: `absolute-preview:${type}`
+		},
+		location.origin
+	);
+};
+
+const reportReady = () => {
+	const durationMs = Math.max(0, Math.round(performance.now()));
+	void nativeFetch('/__absolute/mobile-preview-telemetry', {
+		body: JSON.stringify({ durationMs, platform: previewPlatform() }),
+		headers: { 'content-type': 'application/json' },
+		keepalive: true,
+		method: 'POST'
+	}).catch(() => undefined);
+};
+
+const emitPermission = (
+	controller: TestDeviceController,
+	message: Extract<PreviewMessage, { type: 'absolute-preview:permission' }>
+) => {
+	const status = {
+		canRequest: message.state === 'prompt',
+		state: message.state
+	} as const;
+	if (message.capability === 'camera')
+		controller.cameraPermission.setStatus(status);
+	else if (message.capability === 'location')
+		controller.locationPermission.setStatus(status);
+	else controller.notificationPermission.setStatus(status);
+};
+
+const handlePreviewMessage = (
+	controller: TestDeviceController,
+	message: PreviewMessage
+) => {
+	if (message.type === 'absolute-preview:back') {
+		controller.emitBack({ canGoBack: history.length > 1 });
+	} else if (message.type === 'absolute-preview:deep-link') {
+		controller.emitLink(message.url);
+	} else if (message.type === 'absolute-preview:keyboard') {
+		controller.emitKeyboard({
+			heightPx: Math.max(0, Math.round(message.heightPx)),
+			visible: message.visible
+		});
+	} else if (message.type === 'absolute-preview:lifecycle') {
+		controller.emitLifecycle(message.state);
+	} else if (message.type === 'absolute-preview:network') {
+		previewState.connected = message.connected;
+		// Some framework runtimes replace window.fetch while bootstrapping.
+		// Reassert the raw-fetch simulation whenever connectivity changes;
+		// @absolutejs/http remains pinned to this provider independently.
+		installPreviewFetch();
+		installPreviewHttpTransport();
+		controller.emitNetwork({
+			connected: message.connected,
+			connectionType: message.connectionType
+		});
+	} else emitPermission(controller, message);
+	postState('event', { event: message.type });
+};
+
+export const installAbsoluteMobilePreview = () => {
+	if (Reflect.has(globalThis, '__ABS_MOBILE_PREVIEW__')) return;
+	const platform = previewPlatform();
+	const controller = createTestDeviceAdapter({
+		lifecycle: 'active',
+		network: { connected: true, connectionType: 'wifi' },
+		platform: {
+			formFactor: 'phone',
+			isNative: true,
+			os: platform,
+			runtime: 'capacitor',
+			safeAreaInsets:
+				platform === 'ios'
+					? { bottom: 34, left: 0, right: 0, top: 59 }
+					: { bottom: 24, left: 0, right: 0, top: 24 }
+		}
+	});
+	installDeviceAdapter(controller.adapter);
+	installPreviewHttpTransport();
+	Reflect.set(globalThis, '__ABS_MOBILE_PREVIEW__', controller);
+	addEventListener('message', (event: MessageEvent<unknown>) => {
+		if (event.origin !== location.origin || event.source !== window.parent)
+			return;
+		if (!isPreviewMessage(event.data)) return;
+		handlePreviewMessage(controller, event.data);
+	});
+	postState('ready');
+	reportReady();
+};

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

@@ -10,5 +10,7 @@ export declare const inlineLineMapComment: (sourcePath: string, sourceContent: s
 export declare const remapGeneratedLines: (mappings: string, lineRemap: number[]) => string;
 export declare const chainSourcemap: (outer: SourceMap, fetchInner: (sourcePath: string) => SourceMap | null) => SourceMap;
 export declare const chainBundleInlineSourcemap: (bundleFilePath: string) => void;
+/** Chain every server bundle of a dev build (each bundle is independent). */
+export declare const chainBundleInlineSourcemaps: (bundlePaths: string[]) => Promise<void>;
 export declare const chainExternalSourcemap: (mapFilePath: string) => void;
 export {};

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

@@ -0,0 +1,43 @@
+import type { ParsedVueSpaRoute } from './parseVueSpaRoutes';
+export type VueCompileCacheResult = {
+    clientPath: string;
+    serverPath: string;
+    cssPaths: string[];
+    cssCodes: string[];
+    tsHelperPaths: string[];
+    hmrId: string;
+    spaRoutes?: ParsedVueSpaRoute[];
+};
+export type VueCompileCacheEntry = {
+    key: string;
+    clientCode: string;
+    serverCode: string;
+    result: VueCompileCacheResult;
+    /** Absolute path → content hash of every file `compileScript` read
+     *  while resolving imported types. Re-verified on read. */
+    typeDeps: Record<string, string>;
+};
+export declare const vueCompileCacheEnabled: () => boolean;
+export declare const hashContent: (content: string) => string;
+export declare const hashParts: (parts: readonly string[]) => string;
+export declare const frameworkVersionForCache: () => string | null;
+export declare const vueCompileCacheDir: (projectRoot?: string) => string;
+/** Build the environment part of every key: anything that changes the
+ *  compiler's output without changing the component's own source. */
+export declare const vueCompileCacheFingerprint: (parts: {
+    compilerVersion: string | undefined;
+    stylePreprocessors: unknown;
+    vueRootDir: string;
+    outputDirs: {
+        client: string;
+        server: string;
+        css: string;
+    };
+}) => string | null;
+/** Read a cached compile for `sourceFilePath` if its key matches and every
+ *  recorded type dependency is unchanged. Any I/O or shape problem is a
+ *  miss — the cache can only ever make a build faster, never wrong. */
+export declare const readVueCompileCacheEntry: (sourceFilePath: string, key: string, projectRoot?: string) => VueCompileCacheEntry | null;
+/** Persist a compile. Written via a temp file + rename so a crash mid-write
+ *  can never leave a torn entry for the next process to trust. */
+export declare const writeVueCompileCacheEntry: (sourceFilePath: string, entry: VueCompileCacheEntry, projectRoot?: string) => void;

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 | 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 ? {
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 503 | 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 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

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

@@ -0,0 +1,11 @@
+/** Record which boot step is currently running so the early listener's
+ *  "Building…" page can show it. Cheap enough to call from every step. */
+export declare const getBootPhase: () => string | undefined;
+export declare const setBootPhase: (phase: string) => void;
+type DeferredBootTask = () => void | Promise<void>;
+/** Run every task queued by `deferUntilServing`. Called by the
+ *  `networking` plugin once the real server is bound, so the work runs
+ *  after the port is serving real traffic instead of delaying it. */
+export declare const deferUntilServing: (task: DeferredBootTask) => void;
+export declare const runDeferredBootTasks: () => void;
+export {};

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

@@ -0,0 +1,41 @@
+import type { Server } from 'bun';
+export declare const BOOT_STATUS_HEADER = "X-Absolute-Boot";
+export type EarlyListenerOptions = {
+    host: string;
+    port: number;
+    tls?: {
+        cert: string;
+        key: string;
+    } | null;
+};
+export type EarlyListener = {
+    /** The placeholder server, or null while a bind retry is pending or
+     *  after release. */
+    readonly server: Server<undefined> | null;
+    readonly startedAt: number;
+    readonly released: boolean;
+    release: () => void;
+};
+export declare const bootStatusSnapshot: (startedAt: number) => {
+    elapsedMs: number;
+    elapsedSeconds: number;
+    phase: string;
+    status: "building";
+};
+/** 503 response for one request while the boot build is still running.
+ *  HTML for browsers (`Accept: text/html`), JSON for JSON clients, plain
+ *  text otherwise; WebSocket upgrade attempts (the HMR client) get a plain
+ *  503 instead of an upgrade so they fail the handshake cleanly and fall
+ *  back to their `/hmr-status` polling loop. */
+export declare const buildingResponse: (request: Request, startedAt: number) => Response;
+/** Defensive hand-off for entries that call `.listen()` without the
+ *  `networking` plugin: any `Bun.serve` that targets the placeholder's
+ *  port first releases it. Installed once per process by the bootstrap. */
+export declare const installEarlyListenerServeGuard: (port: number) => void;
+export declare const releaseEarlyListener: () => boolean;
+/** Bind the placeholder. A failed bind (the previous child's socket is
+ *  still draining, or the port genuinely conflicts) is retried in the
+ *  background for a few seconds and then given up on silently — the real
+ *  `.listen()` still reports the conflict the way it always did. Never
+ *  throws: the placeholder is a nicety and must not break boot. */
+export declare const startEarlyListener: (options: EarlyListenerOptions) => EarlyListener;

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

@@ -36,7 +36,7 @@ export declare const createAbsoluteMobilePreviewPlugin: (mobile: MobileConfig |
         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 | 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 ? {
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 503 | 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 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

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

@@ -19,7 +19,7 @@ export declare const imageOptimizer: (config: ImageConfig | undefined, buildDir:
         status?: number | keyof import("elysia").StatusMap;
         cookie?: Record<string, import("elysia").BaseCookie>;
     };
-    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 426 | 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 ? {
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 500 | 100 | 200 | 400 | 404 | 300 | 304 | 503 | 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 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
         readonly 100: "Continue";
         readonly 101: "Switching Protocols";
         readonly 102: "Processing";

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

@@ -2,6 +2,10 @@ export type StartupTimingStep = {
     label: string;
     durationMs: number;
 };
+/** `ABSOLUTE_DEV_PROFILE=1` is the one-stop profiling switch: it turns on
+ *  these per-step startup timings AND the per-phase build trace
+ *  (`ABSOLUTE_BUILD_TRACE`, written to `<buildDir>/.absolute-trace/`). */
+export declare const devProfileEnabled: boolean;
 export declare const startupTimingsEnabled: boolean;
 export declare const formatStartupTimingBlock: (title: string, steps: StartupTimingStep[]) => string;
 export declare const logStartupTimingBlock: (title: string, steps: StartupTimingStep[]) => void;

package/dist/types/globals.d.ts

@@ -46,6 +46,21 @@ declare global {
 	 *  detect this and call `.reload({ fetch })` on the existing server
 	 *  instead of re-binding the port. Stays unset outside dev. */
 	var __absoluteBunServer: import('bun').Server | null | undefined;
+	/** "Building…" placeholder bound by the dev bootstrap before the entry
+	 *  is imported; released by `networking` right before the real listen.
+	 *  See `src/dev/earlyListener.ts`. */
+	var __absoluteEarlyListener:
+		| import('../src/dev/earlyListener').EarlyListener
+		| undefined;
+	var __absoluteEarlyListenerServeGuard: boolean | undefined;
+	/** Label of the boot step currently running (shown on the placeholder
+	 *  page). See `src/dev/bootLifecycle.ts`. */
+	var __absoluteBootPhase: string | undefined;
+	/** Boot work deferred until the server is serving real traffic. */
+	var __absoluteDeferredBootTasks:
+		| Array<() => void | Promise<void>>
+		| undefined;
+	var __absoluteDeferredBootTasksRan: boolean | undefined;
 
 	/** Dev-only request inspector ring buffer, filled by the global
 	 *  request/afterResponse hooks in `requestInspector` and served at

package/package.json

@@ -296,12 +296,12 @@
 	"main": "./dist/index.js",
 	"name": "@absolutejs/absolute",
 	"optionalDependencies": {
-		"@absolutejs/native-darwin-arm64": "0.20.0-beta.66",
-		"@absolutejs/native-darwin-x64": "0.20.0-beta.66",
-		"@absolutejs/native-linux-arm64": "0.20.0-beta.66",
-		"@absolutejs/native-linux-x64": "0.20.0-beta.66",
-		"@absolutejs/native-windows-arm64": "0.20.0-beta.66",
-		"@absolutejs/native-windows-x64": "0.20.0-beta.66"
+		"@absolutejs/native-darwin-arm64": "0.20.0-beta.67",
+		"@absolutejs/native-darwin-x64": "0.20.0-beta.67",
+		"@absolutejs/native-linux-arm64": "0.20.0-beta.67",
+		"@absolutejs/native-linux-x64": "0.20.0-beta.67",
+		"@absolutejs/native-windows-arm64": "0.20.0-beta.67",
+		"@absolutejs/native-windows-x64": "0.20.0-beta.67"
 	},
 	"overrides": {
 		"@sinclair/typebox": "0.34.52",
@@ -519,7 +519,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.66",
+	"version": "0.20.0-beta.67",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"