@absolutejs/absolute 0.20.0-beta.7 → 0.20.0-beta.70

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