@absolutejs/absolute 0.13.11 → 0.15.0

package/dist/{build → src/build}/compileSvelte.d.ts

@@ -3,7 +3,8 @@ type Built = {
     client: string;
 };
 type Cache = Map<string, Built>;
-export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache) => Promise<{
+export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache, isDev?: boolean) => Promise<{
+    svelteIndexPaths: string[];
     svelteClientPaths: string[];
     svelteServerPaths: string[];
 }>;

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

@@ -0,0 +1,33 @@
+import { type SFCDescriptor } from '@vue/compiler-sfc';
+export type VueChangeType = 'style-only' | 'template-only' | 'script' | 'full';
+export declare const vueHmrMetadata: Map<string, {
+    hmrId: string;
+    changeType: VueChangeType;
+}>;
+/**
+ * Detect what type of change occurred in a Vue component
+ * Returns 'template-only' for template changes (supports rerender)
+ * Returns 'script' for script/scriptSetup changes (requires reload)
+ * Returns 'full' for first compile or when detection fails
+ */
+export declare const detectVueChangeType: (filePath: string, descriptor: SFCDescriptor) => VueChangeType;
+/**
+ * Generate a stable HMR ID for a Vue component
+ * Uses relative path from Vue root without extension
+ * Example: "pages/VueExample" or "components/CountButton"
+ */
+export declare const generateVueHmrId: (sourceFilePath: string, vueRootDir: string) => string;
+/**
+ * Clear HMR caches (useful for testing or full rebuilds)
+ */
+export declare const clearVueHmrCaches: () => void;
+export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean) => Promise<{
+    vueClientPaths: string[];
+    vueCssPaths: string[];
+    vueIndexPaths: string[];
+    vueServerPaths: string[];
+    hmrMetadata: Map<string, {
+        hmrId: string;
+        changeType: VueChangeType;
+    }>;
+}>;

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

@@ -0,0 +1 @@
+export declare const generateReactIndexFiles: (reactPagesDirectory: string, reactIndexesDirectory: string, isDev?: boolean) => Promise<void>;

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

@@ -0,0 +1,13 @@
+/**
+ * Bun build plugin that wraps HTML/HTMX scripts with import.meta.hot support
+ * for granular HMR. This allows script changes to hot-reload independently
+ * without triggering a full HTML page rebuild.
+ */
+import type { BunPlugin } from 'bun';
+/**
+ * Creates a Bun build plugin that wraps HTML/HTMX scripts with HMR support
+ * @param htmlDir - The HTML directory path (normalized with forward slashes)
+ * @param htmxDir - The HTMX directory path (normalized with forward slashes)
+ * @returns Bun build plugin
+ */
+export declare const createHTMLScriptHMRPlugin: (htmlDir?: string, htmxDir?: string) => BunPlugin;

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

@@ -0,0 +1,24 @@
+/**
+ * Wraps HTML/HTMX TypeScript/JavaScript scripts with import.meta.hot support
+ * for granular HMR updates. This allows script changes to hot-reload
+ * without triggering a full HTML page rebuild.
+ *
+ * The wrapper is minimal - it just adds import.meta.hot.accept() so Bun
+ * knows this module can be hot-reloaded. Event listener cleanup is handled
+ * by the HMR client (cloning elements before script re-execution).
+ */
+/**
+ * Wrap a script with HMR support using Bun's import.meta.hot API
+ * @param code - The original script code
+ * @param scriptId - Unique identifier for this script (usually the file path)
+ * @returns Wrapped code with HMR support
+ */
+export declare const wrapHTMLScriptWithHMR: (code: string, scriptId: string) => string;
+/**
+ * Check if a file path is an HTML/HTMX script that should be wrapped
+ * @param filePath - The file path to check
+ * @param htmlDir - The HTML directory path
+ * @param htmxDir - The HTMX directory path
+ * @returns true if this script should be wrapped with HMR
+ */
+export declare const isHTMLScript: (filePath: string, htmlDir?: string, htmxDir?: string) => boolean;

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

@@ -0,0 +1,2 @@
+import type { BuildConfig } from '../../types/build';
+export declare const build: ({ buildDirectory, assetsDirectory, publicDirectory, reactDirectory, htmlDirectory, htmxDirectory, angularDirectory, svelteDirectory, vueDirectory, tailwind, options, incrementalFiles }: BuildConfig) => Promise<Record<string, string>>;

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

@@ -0,0 +1,6 @@
+import type { BuildConfig } from '../../types/build';
+import { type HMRState } from '../dev/clientManager';
+export declare const devBuild: (config: BuildConfig) => Promise<{
+    hmrState: HMRState;
+    manifest: Record<string, string>;
+}>;

package/dist/{core → src/core}/index.d.ts

@@ -1,3 +1,4 @@
 export * from './build';
-export * from './pageHandlers';
+export * from './devBuild';
 export * from './lookup';
+export * from './pageHandlers';

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

@@ -0,0 +1,3 @@
+export declare const asset: (source: Record<string, string> | {
+    manifest: Record<string, string>;
+}, name: string) => string;

package/dist/{core → src/core}/pageHandlers.d.ts

@@ -1,15 +1,15 @@
 import { ComponentType as ReactComponent } from 'react';
 import { Component as SvelteComponent } from 'svelte';
 import { Component as VueComponent } from 'vue';
-import { PropsArgs } from '../types';
-export declare const handleReactPageRequest: <Props extends Record<string, unknown> = Record<never, never>>(pageComponent: ReactComponent<Props>, index: string, ...props: keyof Props extends never ? [] : [props: Props]) => Promise<Response>;
+import { PropsArgs } from '../../types/build';
+export declare const handleReactPageRequest: <Props extends Record<string, unknown> = Record<never, never>>(PageComponent: ReactComponent<Props>, index: string, ...props: keyof Props extends never ? [] : [props: Props]) => Promise<Response>;
 type HandleSveltePageRequest = {
     (PageComponent: SvelteComponent<Record<string, never>>, pagePath: string, indexPath: string): Promise<Response>;
     <P extends Record<string, unknown>>(PageComponent: SvelteComponent<P>, pagePath: string, indexPath: string, props: P): Promise<Response>;
 };
 export declare const handleSveltePageRequest: HandleSveltePageRequest;
 export declare const handleVuePageRequest: <Props extends Record<string, unknown> = Record<never, never>>(_PageComponent: VueComponent<Props>, pagePath: string, indexPath: string, headTag?: `<head>${string}</head>`, ...props: keyof Props extends never ? [] : [props: Props]) => Promise<Response>;
-export declare const handleHTMLPageRequest: (html: string) => Bun.BunFile;
-export declare const handleHTMXPageRequest: (htmx: string) => Bun.BunFile;
+export declare const handleHTMLPageRequest: (pagePath: string) => Bun.BunFile;
+export declare const handleHTMXPageRequest: (pagePath: string) => Bun.BunFile;
 export declare const handlePageRequest: <Component>(PageComponent: Component, ...props: PropsArgs<Component>) => void;
 export {};

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

@@ -0,0 +1,12 @@
+/** Determine Content-Type from a file path extension */
+export declare const getMimeType: (filePath: string) => string;
+/** Upsert build outputs into the in-memory asset store.
+ *  Evicts previous entries for the same logical asset (same base name,
+ *  different hash) so stale paths don't accumulate. */
+export declare const populateAssetStore: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;
+/** Remove hashed build files whose logical identity has a newer version.
+ *  Checks both client assets (from the store) and SSR server files (from
+ *  the manifest's absolute-path entries). Non-blocking async version. */
+export declare const cleanStaleAssets: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;
+/** Look up an asset by its web path. Returns bytes or undefined. */
+export declare const lookupAsset: (store: Map<string, Uint8Array>, path: string) => Uint8Array | undefined;

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

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

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

@@ -0,0 +1,26 @@
+import type { FSWatcher } from 'fs';
+import { type DependencyGraph } from './dependencyGraph';
+import { type ModuleVersions } from './moduleVersionTracker';
+import type { HMRWebSocket } from '../../types/websocket';
+import type { BuildConfig } from '../../types/build';
+import { type ResolvedBuildPaths } from './configResolver';
+export type HMRState = {
+    connectedClients: Set<HMRWebSocket>;
+    dependencyGraph: DependencyGraph;
+    isRebuilding: boolean;
+    rebuildQueue: Set<string>;
+    rebuildTimeout: NodeJS.Timeout | null;
+    fileChangeQueue: Map<string, string[]>;
+    debounceTimeout: NodeJS.Timeout | null;
+    fileHashes: Map<string, string>;
+    watchers: FSWatcher[];
+    moduleVersions: ModuleVersions;
+    sourceFileVersions: Map<string, number>;
+    config: BuildConfig;
+    resolvedPaths: ResolvedBuildPaths;
+    vueChangeTypes: Map<string, 'template-only' | 'script' | 'full'>;
+    assetStore: Map<string, Uint8Array>;
+};
+export declare const createHMRState: (config: BuildConfig) => HMRState;
+export declare const incrementSourceFileVersion: (state: HMRState, filePath: string) => number;
+export declare const incrementSourceFileVersions: (state: HMRState, filePaths: string[]) => void;

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

@@ -0,0 +1,13 @@
+import type { BuildConfig } from '../../types/build';
+/** Normalize and default build paths so HMR works outside the example app. */
+export declare const resolveBuildPaths: (config: BuildConfig) => {
+    buildDir: string;
+    assetsDir: string | undefined;
+    reactDir: string | undefined;
+    svelteDir: string | undefined;
+    vueDir: string | undefined;
+    angularDir: string | undefined;
+    htmlDir: string | undefined;
+    htmxDir: string | undefined;
+};
+export type ResolvedBuildPaths = ReturnType<typeof resolveBuildPaths>;

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

@@ -0,0 +1,13 @@
+export type DependencyGraph = {
+    dependents: Map<string, Set<string>>;
+    dependencies: Map<string, Set<string>>;
+};
+export declare const createDependencyGraph: () => {
+    dependencies: Map<any, any>;
+    dependents: Map<any, any>;
+};
+export declare const extractDependencies: (filePath: string) => string[];
+export declare const addFileToGraph: (graph: DependencyGraph, filePath: string) => void;
+export declare const getAffectedFiles: (graph: DependencyGraph, changedFile: string) => string[];
+export declare const removeFileFromGraph: (graph: DependencyGraph, filePath: string) => void;
+export declare const buildInitialDependencyGraph: (graph: DependencyGraph, directories: string[]) => void;

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

@@ -0,0 +1,2 @@
+export declare const computeFileHash: (filePath: string) => string;
+export declare const hasFileChanged: (filePath: string, currentHash: string, previousHashes: Map<string, string>) => boolean;

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

@@ -0,0 +1,3 @@
+import type { BuildConfig } from '../../types/build';
+import type { HMRState } from './clientManager';
+export declare const startFileWatching: (state: HMRState, config: BuildConfig, onFileChange: (filePath: string) => void) => void;

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

@@ -0,0 +1,21 @@
+import { type ComponentType } from './reactComponentClassifier';
+export type ModuleUpdate = {
+    sourceFile: string;
+    framework: string;
+    moduleKeys: string[];
+    modulePaths: Record<string, string>;
+    componentType?: ComponentType;
+};
+export declare const mapSourceFileToManifestKeys: (sourceFile: string, framework: string, resolvedPaths?: {
+    reactDir?: string;
+    svelteDir?: string;
+    vueDir?: string;
+    angularDir?: string;
+}) => string[];
+export declare const createModuleUpdates: (changedFiles: string[], framework: string, manifest: Record<string, string>, resolvedPaths?: {
+    reactDir?: string;
+    svelteDir?: string;
+    vueDir?: string;
+    angularDir?: string;
+}) => ModuleUpdate[];
+export declare const groupModuleUpdatesByFramework: (updates: ModuleUpdate[]) => Map<string, ModuleUpdate[]>;

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

@@ -0,0 +1,7 @@
+export type ModuleVersion = number;
+export type ModuleVersions = Map<string, ModuleVersion>;
+export declare const getNextVersion: () => number;
+export declare const createModuleVersionTracker: () => Map<string, number>;
+export declare const incrementModuleVersion: (versions: ModuleVersions, modulePath: string) => number;
+export declare const incrementModuleVersions: (versions: ModuleVersions, modulePaths: string[]) => Map<string, number>;
+export declare const serializeModuleVersions: (versions: ModuleVersions) => Record<string, number>;

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

@@ -0,0 +1,5 @@
+import { BuildConfig } from '../../types/build';
+import type { ResolvedBuildPaths } from './configResolver';
+export declare const getWatchPaths: (config: BuildConfig, resolved?: ResolvedBuildPaths) => string[];
+export declare const shouldIgnorePath: (path: string) => boolean;
+export declare const detectFramework: (filePath: string, resolved?: ResolvedBuildPaths) => "react" | "vue" | "svelte" | "html" | "assets" | "htmx" | "ignored" | "angular" | "unknown";

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

@@ -0,0 +1,2 @@
+export type ComponentType = 'client' | 'server';
+export declare const classifyComponent: (filePath: string) => "client" | "server";

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

@@ -0,0 +1,10 @@
+import type { BuildConfig } from '../../types/build';
+import type { HMRState } from './clientManager';
+export declare const queueFileChange: (state: HMRState, filePath: string, config: BuildConfig, onRebuildComplete: (result: {
+    manifest: Record<string, string>;
+    hmrState: HMRState;
+}) => void) => void;
+export declare const triggerRebuild: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
+    manifest: Record<string, string>;
+    hmrState: HMRState;
+}) => void, filesToRebuild?: string[]) => Promise<Record<string, string> | null>;

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

@@ -0,0 +1,4 @@
+export declare const handleHTMLUpdate: (htmlFilePath: string) => Promise<string | {
+    body: string;
+    head: string | null;
+} | null>;

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

@@ -0,0 +1,4 @@
+export declare const handleHTMXUpdate: (htmxFilePath: string) => Promise<string | {
+    body: string;
+    head: string | null;
+} | null>;

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

@@ -0,0 +1 @@
+export declare const handleSvelteUpdate: (svelteFilePath: string, manifest: Record<string, string>, buildDir?: string) => Promise<string | null>;

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

@@ -0,0 +1 @@
+export declare const handleVueUpdate: (vueFilePath: string, manifest: Record<string, string>, buildDir?: string) => Promise<string | null>;

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

@@ -0,0 +1,9 @@
+import type { HMRState } from './clientManager';
+import type { HMRWebSocket } from '../../types/websocket';
+export declare const handleClientConnect: (state: HMRState, client: HMRWebSocket, manifest: Record<string, string>) => void;
+export declare const handleClientDisconnect: (state: HMRState, client: HMRWebSocket) => void;
+export declare const handleHMRMessage: (state: HMRState, client: HMRWebSocket, message: unknown) => void;
+export declare const broadcastToClients: (state: HMRState, message: {
+    type: string;
+    [key: string]: any;
+}) => void;

package/dist/{index.d.ts → src/index.d.ts}

@@ -1,3 +1,4 @@
+export * from '../types';
 export * from './constants';
 export * from './core';
 export * from './plugins/index';

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

@@ -0,0 +1,62 @@
+import Elysia from 'elysia';
+import { HMRState } from '../dev/clientManager';
+export declare const hmr: (hmrState: HMRState, manifest: Record<string, string>) => (app: Elysia) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    hmr: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    "hmr-status": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | {
+                    connectedClients: number;
+                    isRebuilding: boolean;
+                    manifestKeys: string[];
+                    rebuildQueue: string[];
+                    timestamp: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

package/dist/{plugins → src/plugins}/index.d.ts

@@ -1,2 +1,3 @@
-export * from './networking';
 export * from './pageRouter';
+export * from './hmr';
+export * from './networking';

package/dist/{plugins → src/plugins}/networking.d.ts

@@ -13,14 +13,17 @@ export declare const networking: (app: Elysia) => Elysia<"", {
     macro: {};
     macroFn: {};
     parser: {};
+    response: {};
 }, {}, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }>;

package/dist/{svelte → src/svelte}/renderToReadableStream.d.ts

@@ -7,5 +7,7 @@ export type RenderStreamOptions = {
     onError?: (error: unknown) => void;
     progressiveChunkSize?: number;
     signal?: AbortSignal;
+    headContent?: string;
+    bodyContent?: string;
 };
-export declare const renderToReadableStream: <Props extends Record<string, unknown> = Record<string, never>>(component: Component<Props>, props?: Props, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal }?: RenderStreamOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+export declare const renderToReadableStream: <Props extends Record<string, unknown> = Record<string, never>>(component: Component<Props>, props?: Props, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal, headContent, bodyContent }?: RenderStreamOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;

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

@@ -0,0 +1,10 @@
+/**
+ * Type-safe helper to get the registerClientScript function during SSR.
+ *
+ * This function safely accesses the global registerClientScript that's made
+ * available during Angular SSR rendering. It returns null if not available
+ * (e.g., when running outside of SSR context).
+ *
+ * @returns The registerClientScript function if available, null otherwise
+ */
+export declare const getRegisterClientScript: () => ((script: () => void) => string) | null;

package/dist/{utils → src/utils}/index.d.ts

@@ -2,3 +2,5 @@ export * from './networking';
 export * from '../build/updateAssetPaths';
 export * from './generateHeadElement';
 export * from './getEnv';
+export * from './registerClientScript';
+export * from './getRegisterClientScript';

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

@@ -0,0 +1,45 @@
+/**
+ * Centralized logger utility for AbsoluteJS
+ * Provides Vite-style formatted output with ANSI colors and timestamps
+ */
+export declare const logger: {
+    /**
+     * HMR update message
+     * Format: "10:30:45 AM [hmr] hmr update /pages/App.tsx"
+     */
+    hmrUpdate(path: string, framework?: string): void;
+    /**
+     * Page reload message
+     * Format: "10:30:45 AM [hmr] page reload /src/App.tsx"
+     */
+    pageReload(path: string, framework?: string): void;
+    /**
+     * CSS update message
+     * Format: "10:30:45 AM [hmr] css update /styles/main.css"
+     */
+    cssUpdate(path: string, framework?: string): void;
+    /**
+     * Script update message
+     * Format: "10:30:45 AM [hmr] script update /scripts/counter.ts"
+     */
+    scriptUpdate(path: string, framework?: string): void;
+    /**
+     * Rebuild complete message
+     * Format: "10:30:45 AM [hmr] rebuilt (125ms)"
+     */
+    rebuilt(duration: number): void;
+    /**
+     * Build error
+     * Format: "10:30:45 AM [hmr] error Build failed: ..."
+     */
+    error(message: string, error?: Error | string): void;
+    /**
+     * Warning message
+     * Format: "10:30:45 AM [hmr] warning ..."
+     */
+    warn(message: string): void;
+    /**
+     * Generic info message
+     */
+    info(message: string): void;
+};

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

@@ -0,0 +1,2 @@
+export declare const getAllNetworkIPs: () => string[];
+export declare const getLocalIPAddress: () => string;

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

@@ -0,0 +1,9 @@
+/**
+ * Normalize file paths to use forward slashes for cross-platform compatibility.
+ * Windows uses backslashes, but this codebase standardizes on forward slashes.
+ */
+export declare const normalizePath: (path: string) => string;
+/**
+ * Normalize all paths in an array.
+ */
+export declare const normalizePaths: (paths: string[]) => string[];

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

@@ -0,0 +1,51 @@
+/**
+ * Utility for registering client-side scripts that need to run after Angular SSR hydration.
+ *
+ * This is necessary because Angular's lifecycle hooks don't always run reliably on the client
+ * after SSR hydration, especially for event listeners attached to DOM elements.
+ *
+ * Usage in Angular components:
+ * ```typescript
+ * import { registerClientScript } from '@absolutejs/absolute';
+ *
+ * // Register an event listener script
+ * registerClientScript(() => {
+ *   const element = document.querySelector('.my-element');
+ *   if (element) {
+ *     element.addEventListener('click', () => {
+ *       console.log('Clicked!');
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * The script will be automatically injected into the HTML response and executed on the client.
+ */
+/**
+ * Register a client-side script to be injected into the HTML response.
+ *
+ * @param script - A function containing the client-side code to execute
+ * @param requestId - Optional request ID. If not provided, uses the current request context.
+ * @returns The request ID for this script registration
+ */
+export declare const registerClientScript: (script: () => void, requestId?: string) => any;
+/**
+ * Get all registered scripts for a request and clear them.
+ * This is called by the page handler after rendering.
+ *
+ * @param requestId - The request ID to get scripts for
+ * @returns Array of script functions, or empty array if none registered
+ */
+export declare const getAndClearClientScripts: (requestId: string) => (() => void)[];
+/**
+ * Generate JavaScript code from registered scripts.
+ * Wraps each script in an IIFE and combines them.
+ *
+ * @param scripts - Array of script functions
+ * @returns JavaScript code string to inject
+ */
+export declare const generateClientScriptCode: (scripts: (() => void)[]) => string;
+/**
+ * Clear all registered scripts (useful for cleanup or testing)
+ */
+export declare const clearAllClientScripts: () => void;

package/dist/{types.d.ts → types/build.d.ts}

@@ -3,10 +3,16 @@ import { Component as SvelteComponent } from 'svelte';
 import { Component as VueComponent } from 'vue';
 export type BuildOptions = {
     preserveIntermediateFiles?: boolean;
+    /** When true, build() throws on error instead of exit(1) - used by HMR rebuilds */
+    throwOnError?: boolean;
+    hmr?: {
+        debounceMs?: number;
+    };
 };
 export type BuildConfig = {
     buildDirectory?: string;
     assetsDirectory?: string;
+    publicDirectory?: string;
     reactDirectory?: string;
     vueDirectory?: string;
     angularDirectory?: string;
@@ -19,6 +25,7 @@ export type BuildConfig = {
         output: string;
     };
     options?: BuildOptions;
+    incrementalFiles?: string[];
 };
 export type PropsOf<Component> = Component extends ReactComponent<infer Props> ? Props : Component extends SvelteComponent<infer Props> ? Props : Component extends VueComponent<infer Props> ? Props : Record<string, never>;
 export type PropsArgs<C> = keyof PropsOf<C> extends never ? [] : [PropsOf<C>];