@aerobuilt/core 0.2.9 → 0.3.0

package/dist/runtime/index.d.mts

@@ -0,0 +1,65 @@
+import { a as AeroRenderInput, d as MountOptions } from "../types-CLHGhnGA.mjs";
+
+//#region src/runtime/index.d.ts
+declare class Aero {
+  /** Global values merged into template context (e.g. from content modules). */
+  private globals;
+  /** Map from page name (or path) to module. Keys include both canonical name and full path for lookup. */
+  private pagesMap;
+  /** Set by client entry when running in the browser; used to attach the app to a DOM root. */
+  mount?: (options?: MountOptions) => Promise<void>;
+  /**
+   * Register a global value available in all templates as `name`.
+   *
+   * @param name - Key used in templates (e.g. `site`).
+   * @param value - Any value (object, string, etc.).
+   */
+  global(name: string, value: any): void;
+  /**
+   * Register page/layout modules from a Vite glob (e.g. `import.meta.glob('@pages/**\/*.html')`).
+   * Derives a lookup key from each path via pagePathToKey; also stores by full path for resolution.
+   *
+   * @param pages - Record of resolved path → module (default export is the render function).
+   */
+  registerPages(pages: Record<string, any>): void;
+  /** Type guard: true if value looks like an `AeroRenderInput` (has at least one of props, slots, request, url, params, routePath). */
+  private isRenderInput;
+  /** Coerce various call signatures into a single `AeroRenderInput` (e.g. plain object → `{ props }`). */
+  private normalizeRenderInput;
+  /** Convert a page name to a route path (e.g. `index` → `'/'`, `about` → `'/about'`). */
+  private toRoutePath;
+  /** Build a URL from route path and optional raw URL. Uses `http://localhost` as base when only a path is given. */
+  private toURL;
+  /** Build template context: globals, props, slots, request, url, params, site, and `renderComponent` / `nextPassDataId`. */
+  private createContext;
+  /** True if entry params and request params have the same keys and stringified values. */
+  private paramsMatch;
+  /**
+   * Render a page or layout to HTML.
+   *
+   * @remarks
+   * Resolves `component` (page name string or module) via `pagesMap`, with fallbacks: directory index
+   * (`foo` → `foo/index`), `index` → `home`, dynamic routes, and trailing-slash stripping. If the module
+   * exports `getStaticPaths` and no props are provided, finds the matching static path and uses its props.
+   * For root-level renders, injects accumulated styles and scripts into the document and fixes content
+   * that ends up after `</html>` when using layouts (moves it into `</body>`).
+   *
+   * @param component - Page name (e.g. `'index'`, `'about'`) or the module object.
+   * @param input - Render input (props, request, url, params, etc.). Can be a plain object (treated as props).
+   * @returns HTML string, or `null` if the page is not found or no static path match.
+   */
+  render(component: any, input?: any): Promise<any>;
+  /**
+   * Render a child component (layout or component) with the given props and slots.
+   * Used by compiled templates via context.renderComponent.
+   *
+   * @param component - Render function or module with `default` render function.
+   * @param props - Props object for the component.
+   * @param slots - Named slot content (key → HTML string).
+   * @param input - Optional request/url/params for context; `headScripts` is not passed through.
+   * @returns HTML string from the component's render function, or empty string if not invokable.
+   */
+  renderComponent(component: any, props?: any, slots?: Record<string, string>, input?: AeroRenderInput): Promise<any>;
+}
+//#endregion
+export { Aero };

package/dist/runtime/index.mjs

@@ -0,0 +1,207 @@
+import { r as resolvePageTarget, t as pagePathToKey } from "../routing-Bai79LCq.mjs";
+
+//#region src/runtime/index.ts
+var Aero = class {
+	/** Global values merged into template context (e.g. from content modules). */
+	globals = {};
+	/** Map from page name (or path) to module. Keys include both canonical name and full path for lookup. */
+	pagesMap = {};
+	/** Set by client entry when running in the browser; used to attach the app to a DOM root. */
+	mount;
+	/**
+	* Register a global value available in all templates as `name`.
+	*
+	* @param name - Key used in templates (e.g. `site`).
+	* @param value - Any value (object, string, etc.).
+	*/
+	global(name, value) {
+		this.globals[name] = value;
+	}
+	/**
+	* Register page/layout modules from a Vite glob (e.g. `import.meta.glob('@pages/**\/*.html')`).
+	* Derives a lookup key from each path via pagePathToKey; also stores by full path for resolution.
+	*
+	* @param pages - Record of resolved path → module (default export is the render function).
+	*/
+	registerPages(pages) {
+		for (const [path, mod] of Object.entries(pages)) {
+			const key = pagePathToKey(path);
+			this.pagesMap[key] = mod;
+			this.pagesMap[path] = mod;
+		}
+	}
+	/** Type guard: true if value looks like an `AeroRenderInput` (has at least one of props, slots, request, url, params, routePath). */
+	isRenderInput(value) {
+		if (!value || typeof value !== "object") return false;
+		return [
+			"props",
+			"slots",
+			"request",
+			"url",
+			"params",
+			"routePath"
+		].some((key) => key in value);
+	}
+	/** Coerce various call signatures into a single `AeroRenderInput` (e.g. plain object → `{ props }`). */
+	normalizeRenderInput(input) {
+		if (!input) return {};
+		if (this.isRenderInput(input)) return input;
+		if (typeof input === "object") return { props: input };
+		return { props: {} };
+	}
+	/** Convert a page name to a route path (e.g. `index` → `'/'`, `about` → `'/about'`). */
+	toRoutePath(pageName = "index") {
+		if (!pageName || pageName === "index" || pageName === "home") return "/";
+		if (pageName.endsWith("/index")) return "/" + pageName.slice(0, -6);
+		return pageName.startsWith("/") ? pageName : "/" + pageName;
+	}
+	/** Build a URL from route path and optional raw URL. Uses `http://localhost` as base when only a path is given. */
+	toURL(routePath, rawUrl) {
+		if (rawUrl instanceof URL) return rawUrl;
+		if (typeof rawUrl === "string" && rawUrl.length > 0) return new URL(rawUrl, "http://localhost");
+		return new URL(routePath, "http://localhost");
+	}
+	/** Build template context: globals, props, slots, request, url, params, site, and `renderComponent` / `nextPassDataId`. */
+	createContext(input) {
+		const routePath = input.routePath || "/";
+		const url = this.toURL(routePath, input.url);
+		const request = input.request || new Request(url.toString(), { method: "GET" });
+		let _passDataId = 0;
+		return {
+			...this.globals,
+			props: input.props || {},
+			slots: input.slots || {},
+			request,
+			url,
+			params: input.params || {},
+			site: input.site ?? "",
+			styles: input.styles,
+			scripts: input.scripts,
+			headScripts: input.headScripts,
+			nextPassDataId: () => `__aero_${_passDataId++}`,
+			renderComponent: this.renderComponent.bind(this)
+		};
+	}
+	/** True if entry params and request params have the same keys and stringified values. */
+	paramsMatch(entryParams, requestParams) {
+		const entryKeys = Object.keys(entryParams);
+		if (entryKeys.length !== Object.keys(requestParams).length) return false;
+		for (const key of entryKeys) if (String(entryParams[key]) !== String(requestParams[key])) return false;
+		return true;
+	}
+	/**
+	* Render a page or layout to HTML.
+	*
+	* @remarks
+	* Resolves `component` (page name string or module) via `pagesMap`, with fallbacks: directory index
+	* (`foo` → `foo/index`), `index` → `home`, dynamic routes, and trailing-slash stripping. If the module
+	* exports `getStaticPaths` and no props are provided, finds the matching static path and uses its props.
+	* For root-level renders, injects accumulated styles and scripts into the document and fixes content
+	* that ends up after `</html>` when using layouts (moves it into `</body>`).
+	*
+	* @param component - Page name (e.g. `'index'`, `'about'`) or the module object.
+	* @param input - Render input (props, request, url, params, etc.). Can be a plain object (treated as props).
+	* @returns HTML string, or `null` if the page is not found or no static path match.
+	*/
+	async render(component, input = {}) {
+		const renderInput = this.normalizeRenderInput(input);
+		const isRootRender = !renderInput.styles;
+		if (isRootRender) {
+			renderInput.styles = /* @__PURE__ */ new Set();
+			renderInput.scripts = /* @__PURE__ */ new Set();
+			renderInput.headScripts = /* @__PURE__ */ new Set();
+		}
+		const resolved = resolvePageTarget(component, this.pagesMap);
+		if (!resolved) return null;
+		let target = resolved.module;
+		const matchedPageName = resolved.pageName;
+		const dynamicParams = resolved.params;
+		if (typeof target === "function" && target.length === 0) target = await target();
+		if (typeof target.getStaticPaths === "function" && Object.keys(renderInput.props || {}).length === 0) {
+			const staticPaths = await target.getStaticPaths();
+			const combinedParams = {
+				...dynamicParams,
+				...renderInput.params || {}
+			};
+			const match = staticPaths.find((entry) => this.paramsMatch(entry.params, combinedParams));
+			if (!match) {
+				console.warn(`[aero] 404: Route params ${JSON.stringify(combinedParams)} not found in getStaticPaths for ${matchedPageName}`);
+				return null;
+			}
+			if (match.props) renderInput.props = match.props;
+		}
+		const routePath = renderInput.routePath || this.toRoutePath(matchedPageName);
+		const context = this.createContext({
+			props: renderInput.props || {},
+			slots: renderInput.slots || {},
+			request: renderInput.request,
+			url: renderInput.url,
+			params: {
+				...dynamicParams,
+				...renderInput.params || {}
+			},
+			routePath,
+			site: renderInput.site,
+			styles: renderInput.styles,
+			scripts: renderInput.scripts,
+			headScripts: renderInput.headScripts
+		});
+		let renderFn = target;
+		if (target.default) renderFn = target.default;
+		if (typeof renderFn === "function") {
+			let html = await renderFn(context);
+			if (isRootRender) {
+				if (html.includes("</html>")) {
+					const afterHtml = html.split("</html>")[1]?.trim();
+					if (afterHtml && html.includes("</body>")) {
+						html = html.split("</html>")[0] + "</html>";
+						html = html.replace("</body>", `\n${afterHtml}\n</body>`);
+					}
+				}
+				let headInjections = "";
+				if (context.styles && context.styles.size > 0) headInjections += Array.from(context.styles).join("\n") + "\n";
+				if (context.headScripts && context.headScripts.size > 0) headInjections += Array.from(context.headScripts).join("\n") + "\n";
+				if (headInjections) if (html.includes("</head>")) html = html.replace("</head>", `\n${headInjections}</head>`);
+				else if (html.includes("<body")) html = html.replace(/(<body[^>]*>)/i, `<head>\n${headInjections}</head>\n$1`);
+				else html = `${headInjections}${html}`;
+				if (context.scripts && context.scripts.size > 0) {
+					const scriptsHtml = Array.from(context.scripts).join("\n");
+					if (html.includes("</body>")) html = html.replace("</body>", `\n${scriptsHtml}\n</body>`);
+					else html = `${html}\n${scriptsHtml}`;
+				}
+			}
+			return html;
+		}
+		return "";
+	}
+	/**
+	* Render a child component (layout or component) with the given props and slots.
+	* Used by compiled templates via context.renderComponent.
+	*
+	* @param component - Render function or module with `default` render function.
+	* @param props - Props object for the component.
+	* @param slots - Named slot content (key → HTML string).
+	* @param input - Optional request/url/params for context; `headScripts` is not passed through.
+	* @returns HTML string from the component's render function, or empty string if not invokable.
+	*/
+	async renderComponent(component, props = {}, slots = {}, input = {}) {
+		const context = this.createContext({
+			props,
+			slots,
+			request: input.request,
+			url: input.url,
+			params: input.params,
+			routePath: input.routePath || "/",
+			site: input.site,
+			styles: input.styles,
+			scripts: input.scripts,
+			headScripts: input.headScripts
+		});
+		if (typeof component === "function") return await component(context);
+		if (component && typeof component.default === "function") return await component.default(context);
+		return "";
+	}
+};
+
+//#endregion
+export { Aero };

package/dist/runtime/instance.d.mts

@@ -0,0 +1,19 @@
+import { Aero } from "./index.mjs";
+
+//#region src/runtime/instance.d.ts
+/** Global slot for the singleton Aero instance; used so HMR re-execution reuses the same instance. */
+declare global {
+  var __AERO_INSTANCE__: Aero | undefined;
+  var __AERO_LISTENERS__: Set<() => void> | undefined;
+}
+declare const aero: Aero;
+/**
+ * Subscribe to update notifications (e.g. after globs or templates change).
+ * Used by the client entry to re-render on HMR.
+ *
+ * @param cb - Callback invoked when `notify()` runs (e.g. after this module re-executes).
+ * @returns Unsubscribe function that removes `cb` from the listener set.
+ */
+declare const onUpdate: (cb: () => void) => () => boolean;
+//#endregion
+export { aero, onUpdate };

package/dist/runtime/instance.mjs

@@ -0,0 +1,45 @@
+import { Aero } from "./index.mjs";
+
+//#region src/runtime/instance.ts
+/**
+* Singleton Aero instance and HMR update subscription.
+*
+* @remarks
+* Provides a single shared `Aero` instance and a listener set so the client entry can subscribe to
+* "something changed" (e.g. template or glob updates). Uses `globalThis` so the instance survives
+* Vite HMR re-execution. On load, runs Vite-specific `import.meta.glob` for pages, components, and
+* layouts, registers them with the instance, then calls `notify()` so any existing subscribers
+* (e.g. the client `mount()` HMR callback) can re-render. Only used in a Vite app context.
+*/
+const instance = globalThis.__AERO_INSTANCE__ || new Aero();
+const listeners = globalThis.__AERO_LISTENERS__ || /* @__PURE__ */ new Set();
+const aero = instance;
+/**
+* Subscribe to update notifications (e.g. after globs or templates change).
+* Used by the client entry to re-render on HMR.
+*
+* @param cb - Callback invoked when `notify()` runs (e.g. after this module re-executes).
+* @returns Unsubscribe function that removes `cb` from the listener set.
+*/
+const onUpdate = (cb) => {
+	listeners.add(cb);
+	return () => listeners.delete(cb);
+};
+/** Invoke all registered listeners. Called once after `registerPages` on load and after HMR re-run. */
+const notify = () => {
+	listeners.forEach((cb) => cb());
+};
+if (!globalThis.__AERO_INSTANCE__) globalThis.__AERO_INSTANCE__ = instance;
+if (!globalThis.__AERO_LISTENERS__) globalThis.__AERO_LISTENERS__ = listeners;
+/** Eager globs so pages, layouts, and components are available synchronously for SSR/build. */
+const components = import.meta.glob("@components/**/*.html", { eager: true });
+const layouts = import.meta.glob("@layouts/*.html", { eager: true });
+const pages = import.meta.glob("@pages/**/*.html", { eager: true });
+aero.registerPages(components);
+aero.registerPages(layouts);
+aero.registerPages(pages);
+notify();
+if (import.meta.hot) import.meta.hot.accept();
+
+//#endregion
+export { aero, onUpdate };

package/dist/types-CLHGhnGA.d.mts

@@ -0,0 +1,209 @@
+import * as vite from "vite";
+
+//#region src/types.d.ts
+/**
+ * Shared type definitions for the Aero framework (compiler, runtime, Vite plugin).
+ *
+ * @remarks
+ * Grouped roughly by: config/dirs, compile/parse, resolver/aliases, routing, render context.
+ */
+interface AeroDirs {
+  /** Site source directory; pages live at `client/pages` (default: `'client'`). */
+  client?: string;
+  /** Nitro server directory (default: `'server'`). */
+  server?: string;
+  /** Build output directory (default: `'dist'`). */
+  dist?: string;
+}
+/** One redirect rule: from path to URL, optional status (default 302). */
+interface RedirectRule {
+  from: string;
+  to: string;
+  status?: number;
+}
+interface AeroOptions {
+  /** Enable Nitro server integration (default: `false`). */
+  server?: boolean;
+  /** API route prefix (default: `'/api'`). */
+  apiPrefix?: string;
+  /** Directory overrides. */
+  dirs?: AeroDirs;
+  /**
+   * Canonical site URL (e.g. `'https://example.com'`). Exposed as `import.meta.env.SITE` and
+   * as `Aero.site` in templates. Used for sitemap, RSS, and canonical links.
+   */
+  site?: string;
+  /**
+   * Redirect rules applied in dev (Vite) and when using the Nitro server (preview:api / production).
+   * For static-only deploys use host redirect config (_redirects, vercel.json, etc.).
+   */
+  redirects?: RedirectRule[];
+  /**
+   * Optional request-time middleware (redirects, rewrites, custom responses).
+   * Runs in dev before rendering; for production redirects use Nitro server middleware or `redirects` config.
+   */
+  middleware?: AeroMiddleware[];
+  /**
+   * Optional plugins to add to the static render server (e.g. content plugin when using aero:content).
+   * Merged after the core Aero plugins so pages that import aero:content resolve during static build.
+   */
+  staticServerPlugins?: vite.Plugin[];
+}
+/** Request context passed to middleware (url, request, route path, resolved page name, site). */
+interface AeroRequestContext {
+  url: URL;
+  request: Request;
+  routePath: string;
+  pageName: string;
+  site?: string;
+}
+/** Result of middleware: redirect, rewrite render input, or send a custom response. */
+type AeroMiddlewareResult = {
+  redirect: {
+    url: string;
+    status?: number;
+  };
+} | {
+  rewrite: Partial<AeroRenderInput> & {
+    pageName?: string;
+  };
+} | {
+  response: Response;
+} | void;
+/** Middleware handler: receives request context; returns redirect/rewrite/response or nothing to continue. */
+type AeroMiddleware = (ctx: AeroRequestContext) => AeroMiddlewareResult | Promise<AeroMiddlewareResult>;
+/** Options for the client-side `mount()` entry (see `core/src/entry-dev.ts`). */
+interface MountOptions {
+  /** Root element: CSS selector or `HTMLElement`. Defaults to `#app`. */
+  target?: string | HTMLElement;
+  /** Called with the root element after mount and after each HMR re-render. */
+  onRender?: (root: HTMLElement) => void;
+}
+/**
+ * Single script entry: attrs (optional), content (body or virtual URL), optional pass:data expression.
+ * Used by parser, codegen, Vite plugin, and static build for client/inline/blocking script arrays.
+ */
+interface ScriptEntry {
+  attrs?: string;
+  content: string;
+  passDataExpr?: string;
+  /** If true, client script is injected in <head> instead of before </body>. */
+  injectInHead?: boolean;
+}
+/**
+ * Input to the codegen compiler for a single template.
+ *
+ * @remarks
+ * Script arrays come from the parser; `root` and `resolvePath` from the build.
+ */
+interface CompileOptions {
+  root: string;
+  /** Client script entries (plain `<script>`): after transform, `content` may be virtual URL. */
+  clientScripts?: ScriptEntry[];
+  /** Inline scripts (`is:inline`) to be emitted in the page. */
+  inlineScripts?: ScriptEntry[];
+  /** Blocking scripts (`is:blocking`) to be emitted in the page. */
+  blockingScripts?: ScriptEntry[];
+  /** Resolve import specifiers (e.g. `@components/foo`) from importer file path. */
+  resolvePath?: (specifier: string, importer: string) => string;
+  /** Importer file path (template) for resolution; required when resolvePath is used. */
+  importer?: string;
+}
+/** Options for the path resolver (e.g. resolving `@components/foo` to a file path). */
+interface ResolverOptions {
+  root: string;
+  resolvePath?: (specifier: string, importer: string) => string;
+  importer?: string;
+}
+/**
+ * Result of parsing one HTML template.
+ *
+ * @remarks
+ * Produced by `parser.ts`. Extracted script blocks and the remaining template string for codegen.
+ */
+interface ParseResult {
+  /** Single `<script is:build>` block, or `null` if none. */
+  buildScript: {
+    content: string;
+  } | null;
+  clientScripts: ScriptEntry[];
+  inlineScripts: ScriptEntry[];
+  blockingScripts: ScriptEntry[];
+  /** HTML after script blocks are stripped; used as input to codegen. */
+  template: string;
+}
+/** One path alias from tsconfig (e.g. find: `@components`, replacement: `.../src/components`). */
+interface UserAlias {
+  find: string;
+  replacement: string;
+}
+/** Result of loading project path aliases (`utils/aliases.ts`). */
+interface AliasResult {
+  aliases: UserAlias[];
+  /** Resolve specifier from importer file path using oxc-resolver. */
+  resolve: (specifier: string, importer: string) => string;
+  /** Project root (directory containing tsconfig.json) when a tsconfig was found. */
+  projectRoot?: string;
+}
+/** Head and body HTML fragments (e.g. from `runtime/client` `extractDocumentParts`). */
+interface PageFragments {
+  head: string;
+  body: string;
+}
+/** Dynamic route segment key → value (e.g. `{ id: '42' }` for `/posts/42`). */
+interface AeroRouteParams {
+  [key: string]: string;
+}
+/** One static path for pre-rendering (e.g. from static path discovery). */
+interface StaticPathEntry {
+  params: AeroRouteParams;
+  props?: Record<string, any>;
+}
+/**
+ * Input passed into a page or layout render (request, url, params, etc.).
+ *
+ * @remarks
+ * Used by the runtime when calling the compiled render function and when rendering child components.
+ */
+interface AeroRenderInput {
+  props?: Record<string, any>;
+  /** Named slot content (key → HTML string) for layout/page render. */
+  slots?: Record<string, string>;
+  request?: Request;
+  url?: URL | string;
+  params?: AeroRouteParams;
+  /** Resolved route path pattern (e.g. `'/posts/[id]'`) for the current request. */
+  routePath?: string;
+  /** Accumulated style URLs/labels for this request. */
+  styles?: Set<string>;
+  /** Accumulated script URLs/labels for this request. */
+  scripts?: Set<string>;
+  /** Scripts to inject in <head>. */
+  headScripts?: Set<string>;
+  /** Canonical site URL from config (e.g. `'https://example.com'`). Exposed as Aero.site in templates. */
+  site?: string;
+}
+/**
+ * Context object available inside compiled templates (`is:build`) and when rendering components.
+ *
+ * @remarks
+ * Includes `props`, `slots`, `renderComponent`, `request`, `url`, `params`, and optional style/script sets.
+ * The index signature allows extra keys (e.g. from content or page data).
+ */
+interface AeroTemplateContext {
+  [key: string]: any;
+  props: Record<string, any>;
+  slots: Record<string, string>;
+  /** Used by codegen to emit calls that render a child component and return its HTML. */
+  renderComponent: (component: any, props?: Record<string, any>, slots?: Record<string, string>, context?: AeroRenderInput) => Promise<string>;
+  request: Request;
+  url: URL;
+  params: AeroRouteParams;
+  /** Canonical site URL from config (e.g. `'https://example.com'`). */
+  site?: string;
+  styles?: Set<string>;
+  scripts?: Set<string>;
+  headScripts?: Set<string>;
+}
+//#endregion
+export { StaticPathEntry as _, AeroRenderInput as a, AeroTemplateContext as c, MountOptions as d, PageFragments as f, ScriptEntry as g, ResolverOptions as h, AeroOptions as i, AliasResult as l, RedirectRule as m, AeroMiddleware as n, AeroRequestContext as o, ParseResult as p, AeroMiddlewareResult as r, AeroRouteParams as s, AeroDirs as t, CompileOptions as u, UserAlias as v };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { _ as StaticPathEntry, a as AeroRenderInput, c as AeroTemplateContext, d as MountOptions, f as PageFragments, g as ScriptEntry, h as ResolverOptions, i as AeroOptions, l as AliasResult, m as RedirectRule, n as AeroMiddleware, o as AeroRequestContext, p as ParseResult, r as AeroMiddlewareResult, s as AeroRouteParams, t as AeroDirs, u as CompileOptions, v as UserAlias } from "./types-CLHGhnGA.mjs";
+export { AeroDirs, AeroMiddleware, AeroMiddlewareResult, AeroOptions, AeroRenderInput, AeroRequestContext, AeroRouteParams, AeroTemplateContext, AliasResult, CompileOptions, MountOptions, PageFragments, ParseResult, RedirectRule, ResolverOptions, ScriptEntry, StaticPathEntry, UserAlias };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/utils/aliases.d.mts

@@ -0,0 +1,38 @@
+import { l as AliasResult, v as UserAlias } from "../types-CLHGhnGA.mjs";
+
+//#region src/vite/defaults.d.ts
+/** Resolved directory paths (client, server, dist) after applying defaults. */
+interface ResolvedAeroDirs {
+  client: string;
+  server: string;
+  dist: string;
+}
+//#endregion
+//#region src/utils/aliases.d.ts
+/**
+ * Build default path aliases for @pages, @layouts, @components from project root and dirs.
+ * Used when tsconfig is missing or does not define these keys so the runtime globs resolve.
+ */
+declare function getDefaultAliases(root: string, dirs: ResolvedAeroDirs): UserAlias[];
+/**
+ * Load path aliases from tsconfig.json at or above the given root.
+ *
+ * @param root - Project root directory (e.g. `process.cwd()` or Vite config root).
+ * @returns AliasResult with `aliases` for Vite resolve.alias and `resolve(specifier, importer)` for compiler/build.
+ */
+declare function loadTsconfigAliases(root: string): AliasResult;
+/**
+ * Merge framework default aliases (from dirs) with tsconfig-derived aliases.
+ * Defaults are applied first; any alias from aliasResult with the same `find` overwrites.
+ * Produces a resolve that tries merged aliases first, then falls back to the original resolver.
+ *
+ * Ensures @pages, @layouts, @components always exist so the runtime import.meta.glob patterns resolve.
+ *
+ * @param aliasResult - Result from loadTsconfigAliases (may have empty aliases when no tsconfig).
+ * @param root - Project root.
+ * @param dirs - Resolved client/layouts/components dirs.
+ * @returns AliasResult with merged aliases and a resolve that uses them.
+ */
+declare function mergeWithDefaultAliases(aliasResult: AliasResult, root: string, dirs: ResolvedAeroDirs): AliasResult;
+//#endregion
+export { getDefaultAliases, loadTsconfigAliases, mergeWithDefaultAliases };