@aerobuilt/core 0.2.10 → 0.3.1

package/dist/build-script-analysis-Bd9EyItC.mjs

@@ -0,0 +1,193 @@
+import { compileInterpolationFromSegments, tokenizeCurlyInterpolation } from "@aerobuilt/interpolation";
+import { ImportNameKind, parseSync } from "oxc-parser";
+
+//#region src/compiler/directive-attributes.ts
+/** Default prefixes: Alpine.js (x-*) and shorthand (@, :, .). */
+const DEFAULT_DIRECTIVE_PREFIXES = [
+	"x-",
+	"@",
+	":",
+	"."
+];
+const defaultConfig = {
+	prefixes: DEFAULT_DIRECTIVE_PREFIXES,
+	exactNames: []
+};
+/**
+* Returns true if the attribute name is a directive that should skip
+* { } interpolation (e.g. Alpine x-model, :disabled, @click).
+*
+* @param attrName - HTML attribute name (e.g. 'x-data', ':disabled').
+* @param config - Optional config; uses default Alpine/shorthand prefixes when omitted.
+*/
+function isDirectiveAttr(attrName, config = defaultConfig) {
+	const prefixes = config.prefixes ?? defaultConfig.prefixes;
+	if ((config.exactNames ?? defaultConfig.exactNames).includes(attrName)) return true;
+	return prefixes.some((p) => attrName.startsWith(p));
+}
+
+//#endregion
+//#region src/compiler/build-script-analysis.ts
+/**
+* AST-based analysis of Aero build scripts: extract imports and getStaticPaths export.
+*
+* @remarks
+* Uses oxc-parser (TypeScript-capable) so the same pipeline supports JS and TS in
+* `<script is:build>`. Returns structured data for codegen to rewrite imports and
+* emit getStaticPaths as a named export.
+*/
+const BUILD_SCRIPT_FILENAME = "build.ts";
+/**
+* Analyze build script source: parse with oxc, extract static imports and
+* `export [async] function getStaticPaths(...)`, return bindings and script with those removed.
+*
+* @param script - Raw build script content (JS or TS).
+* @returns Structured result for codegen. On parse error, throws.
+*/
+function analyzeBuildScript(script) {
+	if (!script.trim()) return {
+		imports: [],
+		getStaticPathsFn: null,
+		scriptWithoutImportsAndGetStaticPaths: script
+	};
+	const result = parseSync(BUILD_SCRIPT_FILENAME, script, {
+		sourceType: "module",
+		range: true,
+		lang: "ts"
+	});
+	const errors = result.errors;
+	if (errors.length > 0) {
+		const first = errors[0];
+		throw new Error(`[aero] Build script parse error: ${first.message}${first.codeframe ? "\n" + first.codeframe : ""}`);
+	}
+	const mod = result.module;
+	const program = result.program;
+	const imports = [];
+	for (const imp of mod.staticImports) {
+		const specifier = imp.moduleRequest.value;
+		let defaultBinding = null;
+		const namedBindings = [];
+		let namespaceBinding = null;
+		for (const entry of imp.entries) {
+			if (entry.isType) continue;
+			const local = entry.localName.value;
+			switch (entry.importName.kind) {
+				case ImportNameKind.Default:
+					defaultBinding = local;
+					break;
+				case ImportNameKind.NamespaceObject:
+					namespaceBinding = local;
+					break;
+				case ImportNameKind.Name: {
+					const imported = entry.importName.name ?? local;
+					namedBindings.push({
+						imported,
+						local
+					});
+					break;
+				}
+				default: break;
+			}
+		}
+		imports.push({
+			specifier,
+			defaultBinding,
+			namedBindings,
+			namespaceBinding
+		});
+	}
+	let getStaticPathsRange = null;
+	const body = program.body;
+	if (body) for (const stmt of body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "FunctionDeclaration") continue;
+		if (decl.id?.name !== "getStaticPaths") continue;
+		const range = stmt.range;
+		if (range) {
+			getStaticPathsRange = range;
+			break;
+		}
+	}
+	const getStaticPathsFn = getStaticPathsRange !== null ? script.slice(getStaticPathsRange[0], getStaticPathsRange[1]) : null;
+	const rangesToRemove = [];
+	if (getStaticPathsRange) rangesToRemove.push(getStaticPathsRange);
+	for (const imp of mod.staticImports) rangesToRemove.push([imp.start, imp.end]);
+	rangesToRemove.sort((a, b) => a[0] - b[0]);
+	const parts = [];
+	let lastEnd = 0;
+	for (const [start, end] of rangesToRemove) {
+		if (start > lastEnd) parts.push(script.slice(lastEnd, start));
+		lastEnd = end;
+	}
+	if (lastEnd < script.length) parts.push(script.slice(lastEnd));
+	return {
+		imports,
+		getStaticPathsFn,
+		scriptWithoutImportsAndGetStaticPaths: parts.join("").trim()
+	};
+}
+/**
+* Analyze build script for editor use: same as analyzeBuildScript but returns imports with
+* source ranges (full statement and per-binding) so the extension can map to vscode.Range.
+*
+* @param script - Raw build script content (JS or TS).
+* @returns Imports with range and bindingRanges. On parse error, throws.
+*/
+function analyzeBuildScriptForEditor(script) {
+	if (!script.trim()) return { imports: [] };
+	const result = parseSync(BUILD_SCRIPT_FILENAME, script, {
+		sourceType: "module",
+		range: true,
+		lang: "ts"
+	});
+	const errors = result.errors;
+	if (errors.length > 0) {
+		const first = errors[0];
+		throw new Error(`[aero] Build script parse error: ${first.message}${first.codeframe ? "\n" + first.codeframe : ""}`);
+	}
+	const mod = result.module;
+	const imports = [];
+	for (const imp of mod.staticImports) {
+		const specifier = imp.moduleRequest.value;
+		let defaultBinding = null;
+		const namedBindings = [];
+		let namespaceBinding = null;
+		const bindingRanges = {};
+		for (const entry of imp.entries) {
+			if (entry.isType) continue;
+			const local = entry.localName.value;
+			bindingRanges[local] = [entry.localName.start, entry.localName.end];
+			switch (entry.importName.kind) {
+				case ImportNameKind.Default:
+					defaultBinding = local;
+					break;
+				case ImportNameKind.NamespaceObject:
+					namespaceBinding = local;
+					break;
+				case ImportNameKind.Name: {
+					const imported = entry.importName.name ?? local;
+					namedBindings.push({
+						imported,
+						local
+					});
+					break;
+				}
+				default: break;
+			}
+		}
+		imports.push({
+			specifier,
+			defaultBinding,
+			namedBindings,
+			namespaceBinding,
+			range: [imp.start, imp.end],
+			specifierRange: [imp.moduleRequest.start, imp.moduleRequest.end],
+			bindingRanges
+		});
+	}
+	return { imports };
+}
+
+//#endregion
+export { compileInterpolationFromSegments as a, isDirectiveAttr as i, analyzeBuildScriptForEditor as n, tokenizeCurlyInterpolation as o, DEFAULT_DIRECTIVE_PREFIXES as r, analyzeBuildScript as t };

package/dist/{entry-dev.d.ts → entry-dev.d.mts}

@@ -1,17 +1,7 @@
-import { MountOptions } from './types.js';
-import { Aero } from './runtime/index.js';
-import 'vite';
-
-/**
- * Client entry for the Aero framework.
- *
- * @remarks
- * Re-exports the shared `aero` instance with a `mount()` method attached.
- * Used as the app's client entry point (e.g. in the main script that runs in the browser).
- * Assumes HTML was server-rendered or pre-rendered; `mount()` does not perform an initial
- * render, only sets up the root element and (in dev) HMR re-renders.
- */
+import { d as MountOptions } from "./types-CLHGhnGA.mjs";
+import { Aero } from "./runtime/index.mjs";
 
+//#region src/entry-dev.d.ts
 /**
  * Attach the app to a DOM element and optionally set up HMR re-renders.
  *
@@ -28,7 +18,7 @@ import 'vite';
  */
 declare function mount(options?: MountOptions): Promise<void>;
 declare const _default: Aero & {
-    mount: typeof mount;
+  mount: typeof mount;
 };
-
-export { _default as default };
+//#endregion
+export { _default as default };

package/dist/entry-dev.mjs

@@ -0,0 +1,127 @@
+import { n as resolvePageName } from "./routing-Bai79LCq.mjs";
+import { aero, onUpdate } from "./runtime/instance.mjs";
+
+//#region src/runtime/client.ts
+/**
+* Parse a full HTML string into head and body fragments.
+* If the document has no head/body, body falls back to the raw HTML.
+*
+* @param html - Full document HTML (e.g. from the compiled render function).
+* @returns Head inner HTML and body inner HTML.
+*/
+function extractDocumentParts(html) {
+	const doc = new DOMParser().parseFromString(html, "text/html");
+	return {
+		head: doc.head?.innerHTML?.trim() || "",
+		body: doc.body?.innerHTML ?? html
+	};
+}
+/** Guard: skip starting a new render while one is in progress (avoids overlapping HMR runs). */
+let rendering = false;
+/** CSS selectors for nodes that must be kept in <head> during HMR (Vite dev client and dev-injected modules). */
+const PERSISTENT_SELECTORS = ["script[src*=\"/@vite/client\"]", "[data-vite-dev-id]"].join(", ");
+/**
+* Replace document head content with new HTML while preserving nodes matching PERSISTENT_SELECTORS.
+* Avoids re-adding duplicate Vite dev nodes by skipping if a node with the same data-vite-dev-id or script src already exists.
+*/
+function updateHead(headContent) {
+	const headEl = document.head;
+	const queriedNodes = headEl.querySelectorAll(PERSISTENT_SELECTORS);
+	const persistentSet = new Set(Array.from(queriedNodes));
+	for (const node of Array.from(headEl.children)) {
+		if (persistentSet.has(node)) continue;
+		headEl.removeChild(node);
+	}
+	const frag = new DOMParser().parseFromString(`<head>${headContent}</head>`, "text/html");
+	const nodes = Array.from(frag.head?.childNodes || []);
+	for (const node of nodes) {
+		if (node.nodeType === Node.ELEMENT_NODE) {
+			const el = node;
+			if (el.matches(PERSISTENT_SELECTORS)) {
+				const devId = el.getAttribute("data-vite-dev-id");
+				if (devId && headEl.querySelector(`[data-vite-dev-id="${devId}"]`)) continue;
+				if (el instanceof HTMLScriptElement && el.src && headEl.querySelector(`script[src="${el.src}"]`)) continue;
+			}
+		}
+		headEl.appendChild(document.importNode(node, true));
+	}
+}
+/**
+* Path prefix for content/docs routes. When on such a route in dev, we fetch HTML from the
+* dev server instead of re-running the full render (including markdown) in the browser.
+*/
+const DOCS_PATH_PREFIX = "/docs";
+/**
+* Re-render the current page in the browser (e.g. on HMR).
+* For content routes (e.g. `/docs/*`), fetches HTML from the dev server to avoid running the
+* full markdown pipeline in the browser. Otherwise resolves page name and uses `renderFn`.
+*
+* @param appEl - Root element to receive the new body content (e.g. `#app`).
+* @param renderFn - Async function that returns full document HTML for a given page name (e.g. `aero.render`).
+*/
+async function renderPage(appEl, renderFn) {
+	if (rendering) return;
+	rendering = true;
+	const pathname = window.location.pathname;
+	const pageName = resolvePageName(pathname);
+	try {
+		let html;
+		if (typeof window !== "undefined" && (pathname === DOCS_PATH_PREFIX || pathname.startsWith(DOCS_PATH_PREFIX + "/")) && import.meta.hot) {
+			const res = await fetch(pathname, { headers: { Accept: "text/html" } });
+			if (!res.ok) throw new Error(`Fetch failed: ${res.status}`);
+			html = await res.text();
+		} else html = await renderFn(pageName);
+		const { head, body } = extractDocumentParts(html);
+		if (head) updateHead(head);
+		appEl.innerHTML = body;
+	} catch (err) {
+		appEl.innerHTML = `<h1>Error rendering page: ${pageName}</h1><pre>${String(err)}</pre>`;
+		console.error("[aero] Render Error:", err);
+	} finally {
+		rendering = false;
+	}
+}
+
+//#endregion
+//#region src/entry-dev.ts
+/** Bound `aero.render` so the same function reference is passed to `renderPage` for HMR re-renders. */
+const coreRender = aero.render.bind(aero);
+/** HMR state: root element for re-renders and unsubscribe. Set when mount() runs; subscription is registered once per dev session. */
+const hmrState = {
+	lastEl: null,
+	unsubscribe: null
+};
+/**
+* Attach the app to a DOM element and optionally set up HMR re-renders.
+*
+* @remarks
+* Does not perform an initial render: we assume the document already has SSR/pre-rendered
+* HTML. Only runs `onRender` if provided, then in dev (Vite HMR) subscribes to template
+* updates and re-renders into the same target.
+*
+* @param options - Mount options. Defaults to `{ target: '#app' }`.
+* @param options.target - CSS selector (e.g. `#app`) or the root `HTMLElement`. Defaults to `#app`.
+* @param options.onRender - Called with the root element after mount and after each HMR re-render.
+* @returns A promise that resolves immediately. Does not wait for any async render (no initial render).
+* @throws When `target` is a string and no matching element is found in the document.
+*/
+function mount(options = {}) {
+	const { target = "#app", onRender } = options;
+	const el = typeof target === "string" ? document.querySelector(target) : target;
+	if (!el) throw new Error("Target element not found: " + target);
+	hmrState.lastEl = el;
+	if (onRender) onRender(el);
+	const done = Promise.resolve();
+	if (import.meta.hot && !hmrState.unsubscribe) hmrState.unsubscribe = onUpdate(() => {
+		const el = hmrState.lastEl;
+		if (el) renderPage(el, coreRender).then(() => {
+			if (onRender) onRender(el);
+		});
+	});
+	return done;
+}
+aero.mount = mount;
+var entry_dev_default = aero;
+
+//#endregion
+export { entry_dev_default as default };

package/dist/{entry-editor.d.ts → entry-editor.d.mts}

@@ -1,5 +1,6 @@
-export { InterpolationSegment, LiteralSegment, Segment, TokenizeOptions, compileInterpolationFromSegments, tokenizeCurlyInterpolation } from '@aerobuilt/interpolation';
+import { InterpolationSegment, LiteralSegment, Segment, TokenizeOptions, compileInterpolationFromSegments, tokenizeCurlyInterpolation } from "@aerobuilt/interpolation";
 
+//#region src/compiler/directive-attributes.d.ts
 /**
  * Classifier for directive attributes (Alpine.js, HTMX, Vue, etc.) that should
  * skip { } interpolation in the compiler. Replaces ALPINE_ATTR_REGEX with a
@@ -13,10 +14,10 @@ export { InterpolationSegment, LiteralSegment, Segment, TokenizeOptions, compile
  * like @, :, . match event and binding syntax.
  */
 interface DirectiveAttrConfig {
-    /** Prefixes that identify directive attributes (e.g. 'x-', '@', 'hx-'). */
-    prefixes?: string[];
-    /** Exact attribute names to treat as directives. */
-    exactNames?: string[];
+  /** Prefixes that identify directive attributes (e.g. 'x-', '@', 'hx-'). */
+  prefixes?: string[];
+  /** Exact attribute names to treat as directives. */
+  exactNames?: string[];
 }
 /** Default prefixes: Alpine.js (x-*) and shorthand (@, :, .). */
 declare const DEFAULT_DIRECTIVE_PREFIXES: string[];
@@ -28,7 +29,8 @@ declare const DEFAULT_DIRECTIVE_PREFIXES: string[];
  * @param config - Optional config; uses default Alpine/shorthand prefixes when omitted.
  */
 declare function isDirectiveAttr(attrName: string, config?: DirectiveAttrConfig): boolean;
-
+//#endregion
+//#region src/compiler/build-script-analysis.d.ts
 /**
  * AST-based analysis of Aero build scripts: extract imports and getStaticPaths export.
  *
@@ -39,26 +41,26 @@ declare function isDirectiveAttr(attrName: string, config?: DirectiveAttrConfig)
  */
 /** Single import entry for codegen: specifier and bindings. */
 interface BuildScriptImport {
-    specifier: string;
-    defaultBinding: string | null;
-    namedBindings: Array<{
-        imported: string;
-        local: string;
-    }>;
-    namespaceBinding: string | null;
+  specifier: string;
+  defaultBinding: string | null;
+  namedBindings: Array<{
+    imported: string;
+    local: string;
+  }>;
+  namespaceBinding: string | null;
 }
 /** Editor-oriented import entry: same bindings as BuildScriptImport plus source range and per-binding ranges. */
 interface BuildScriptImportForEditor extends BuildScriptImport {
-    /** Character range of the full import statement [start, end]. */
-    range: [number, number];
-    /** Character range of the specifier string (path) within the script. */
-    specifierRange: [number, number];
-    /** Per-binding character ranges: local name -> [start, end]. */
-    bindingRanges?: Record<string, [number, number]>;
+  /** Character range of the full import statement [start, end]. */
+  range: [number, number];
+  /** Character range of the specifier string (path) within the script. */
+  specifierRange: [number, number];
+  /** Per-binding character ranges: local name -> [start, end]. */
+  bindingRanges?: Record<string, [number, number]>;
 }
 /** Result of analyzeBuildScriptForEditor: imports with source ranges for editor use (e.g. definition provider). */
 interface BuildScriptAnalysisForEditorResult {
-    imports: BuildScriptImportForEditor[];
+  imports: BuildScriptImportForEditor[];
 }
 /**
  * Analyze build script for editor use: same as analyzeBuildScript but returns imports with
@@ -68,5 +70,5 @@ interface BuildScriptAnalysisForEditorResult {
  * @returns Imports with range and bindingRanges. On parse error, throws.
  */
 declare function analyzeBuildScriptForEditor(script: string): BuildScriptAnalysisForEditorResult;
-
-export { type BuildScriptAnalysisForEditorResult, type BuildScriptImportForEditor, DEFAULT_DIRECTIVE_PREFIXES, type DirectiveAttrConfig, analyzeBuildScriptForEditor, isDirectiveAttr };
+//#endregion
+export { type BuildScriptAnalysisForEditorResult, type BuildScriptImportForEditor, DEFAULT_DIRECTIVE_PREFIXES, type DirectiveAttrConfig, type InterpolationSegment, type LiteralSegment, type Segment, type TokenizeOptions, analyzeBuildScriptForEditor, compileInterpolationFromSegments, isDirectiveAttr, tokenizeCurlyInterpolation };

package/dist/entry-editor.mjs

@@ -0,0 +1,3 @@
+import { a as compileInterpolationFromSegments, i as isDirectiveAttr, n as analyzeBuildScriptForEditor, o as tokenizeCurlyInterpolation, r as DEFAULT_DIRECTIVE_PREFIXES } from "./build-script-analysis-Bd9EyItC.mjs";
+
+export { DEFAULT_DIRECTIVE_PREFIXES, analyzeBuildScriptForEditor, compileInterpolationFromSegments, isDirectiveAttr, tokenizeCurlyInterpolation };

package/dist/entry-prod.d.mts

@@ -0,0 +1,10 @@
+import { d as MountOptions } from "./types-CLHGhnGA.mjs";
+import { Aero } from "./runtime/index.mjs";
+
+//#region src/entry-prod.d.ts
+declare function mount(options?: MountOptions): Promise<void>;
+declare const _default: Aero & {
+  mount: typeof mount;
+};
+//#endregion
+export { _default as default };

package/dist/entry-prod.mjs

@@ -0,0 +1,15 @@
+import { Aero } from "./runtime/index.mjs";
+
+//#region src/entry-prod.ts
+function mount(options = {}) {
+	const { target = "#app", onRender } = options;
+	const el = typeof target === "string" ? document.querySelector(target) : target;
+	if (!el) throw new Error("Target element not found: " + target);
+	if (onRender) onRender(el);
+	return Promise.resolve();
+}
+const aero = new Aero();
+aero.mount = mount;
+
+//#endregion
+export { aero as default };

package/dist/routing-Bai79LCq.mjs

@@ -0,0 +1,198 @@
+//#region src/utils/path.ts
+/**
+* Shared path utilities for the Aero framework.
+*/
+/**
+* Convert a path to POSIX format (forward slashes).
+* Handles Windows backslashes and ensures consistent path format across platforms.
+*/
+function toPosix(value) {
+	return value.replace(/\\/g, "/");
+}
+/**
+* Normalize a path to be relative to root and POSIX format.
+*/
+function toPosixRelative(value, root) {
+	const valuePosix = toPosix(value);
+	const rootPosix = toPosix(root);
+	if (valuePosix.startsWith(rootPosix + "/")) return valuePosix.slice(rootPosix.length + 1);
+	return valuePosix;
+}
+
+//#endregion
+//#region src/utils/route-pattern.ts
+/** Matches a single [param] segment; capture is param name (no leading . or ..., no ]). */
+const PARAM_SEGMENT_REGEX = /^\[([^.\]\[]+)\]$/;
+/**
+* Parses a route pattern (page name) into segments.
+*
+* @param pattern - Page name with optional [param] segments (e.g. `blog/[id]`, `[slug]`).
+* @returns Parsed pattern; segments are static literals or params.
+*/
+function parseRoutePattern(pattern) {
+	return { segments: pattern.split("/").filter(Boolean).map((seg) => {
+		const paramMatch = seg.match(PARAM_SEGMENT_REGEX);
+		if (paramMatch) return {
+			type: "param",
+			name: paramMatch[1]
+		};
+		return {
+			type: "static",
+			value: seg
+		};
+	}) };
+}
+/**
+* Returns true if the pattern contains at least one param segment.
+*
+* @param pattern - Page name (e.g. `blog/[id]`).
+*/
+function isDynamicRoutePattern(pattern) {
+	const { segments } = parseRoutePattern(pattern);
+	return segments.some((s) => s.type === "param");
+}
+/**
+* Matches a concrete page name against a route pattern.
+*
+* @param pattern - Route pattern (e.g. `blog/[id]`).
+* @param pageName - Requested page name (e.g. `blog/123`).
+* @returns Extracted params if the page name matches, otherwise null.
+*/
+function matchRoutePattern(pattern, pageName) {
+	const { segments } = parseRoutePattern(pattern);
+	const requestedSegments = pageName.split("/").filter(Boolean);
+	if (segments.length !== requestedSegments.length) return null;
+	const params = {};
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		const requestSeg = requestedSegments[i];
+		if (seg.type === "param") params[seg.name] = decodeURIComponent(requestSeg);
+		else if (seg.value !== requestSeg) return null;
+	}
+	return params;
+}
+/**
+* Replaces each [key] in the pattern with params[key].
+*
+* @param pattern - Route pattern (e.g. `docs/[slug]`).
+* @param params - Map of param names to values.
+* @returns Expanded page name (e.g. `docs/intro`).
+* @throws If a required param is missing from params.
+*/
+function expandRoutePattern(pattern, params) {
+	const { segments } = parseRoutePattern(pattern);
+	const parts = [];
+	for (const seg of segments) if (seg.type === "param") {
+		if (!(seg.name in params)) throw new Error(`[aero] getStaticPaths: missing param "${seg.name}" for pattern "${pattern}". Provided params: ${JSON.stringify(params)}`);
+		parts.push(params[seg.name]);
+	} else parts.push(seg.value);
+	return parts.join("/");
+}
+
+//#endregion
+//#region src/utils/routing.ts
+/**
+* Derives a canonical page key from a resolved file path (e.g. from import.meta.glob).
+* Used by the runtime when registering pages so lookup keys match build's page names.
+*
+* - Paths containing `pages/`: key is the segment after `pages/` (e.g. `client/pages/about.html` → `about`).
+* - Multiple segments without `pages/` (e.g. layouts, components): key is full path without extension.
+* - Single segment: key is that segment.
+*
+* @param path - Resolved path (with or without `.html`).
+* @returns Canonical key for pagesMap lookup.
+*/
+function pagePathToKey(path) {
+	const withoutExt = toPosix(path).replace(/\.html$/i, "");
+	if (withoutExt.includes("pages/")) return withoutExt.split("pages/").pop();
+	const segments = withoutExt.split("/").filter(Boolean);
+	if (segments.length > 1) return segments.join("/");
+	return segments.pop() || path;
+}
+/**
+* Resolves a URL path to an Aero page name.
+*
+* @param url - Full URL or path (e.g. `/about`, `/about?foo=bar`, `/blog/`).
+* @returns Page name for lookup in pagesMap (e.g. `index`, `about`, `blog/index`, `blog/post`).
+*
+* @example
+* resolvePageName('/') // 'index'
+* resolvePageName('/about') // 'about'
+* resolvePageName('/about.html') // 'about'
+* resolvePageName('/blog/') // 'blog/index'
+* resolvePageName('/blog/post') // 'blog/post'
+* resolvePageName('/about?foo=bar') // 'about'
+*/
+function resolvePageName(url) {
+	const [pathPart] = url.split("?");
+	let clean = pathPart || "/";
+	if (clean === "/" || clean === "") return "index";
+	if (clean.endsWith("/")) clean = clean + "index";
+	clean = clean.replace(/^\//, "");
+	clean = clean.replace(/\.html$/, "");
+	return clean || "index";
+}
+/**
+* Matches a page name (e.g. `posts/42`) against registered dynamic routes (e.g. `posts/[id]`).
+* Returns the first matching module, its canonical page name, and extracted params.
+*
+* @param pageName - Requested page name (e.g. `blog/123`).
+* @param pagesMap - Map of page key → module (from registerPages).
+* @returns PageTargetResult or null if no match.
+*/
+function resolveDynamicPage(pageName, pagesMap) {
+	for (const [key, mod] of Object.entries(pagesMap)) {
+		if (!key.includes("[") || !key.includes("]") || key.includes(".")) continue;
+		const params = matchRoutePattern(key, pageName);
+		if (params != null) return {
+			module: mod,
+			pageName: key,
+			params
+		};
+	}
+	return null;
+}
+/**
+* Resolves a component (page name string or module) to a page target for rendering.
+* Implements the same lookup order as the runtime: direct key, directory index, home fallback,
+* dynamic routes, then trailing-slash stripping.
+*
+* @param component - Page name (e.g. `'index'`, `'about'`) or a module object.
+* @param pagesMap - Map of page key → module (from registerPages).
+* @returns PageTargetResult or null if not found.
+*/
+function resolvePageTarget(component, pagesMap) {
+	if (typeof component !== "string") return component != null ? {
+		module: component,
+		pageName: "index",
+		params: {}
+	} : null;
+	const pageName = component;
+	let target = pagesMap[pageName];
+	if (!target) target = pagesMap[`${pageName}/index`];
+	if (!target && pageName === "index") target = pagesMap["home"];
+	if (!target) {
+		const dynamicMatch = resolveDynamicPage(pageName, pagesMap) ?? resolveDynamicPage(`${pageName}/index`, pagesMap);
+		if (dynamicMatch) return dynamicMatch;
+	}
+	if (!target && pageName.endsWith("/index")) {
+		const stripped = pageName.slice(0, -6);
+		target = pagesMap[stripped];
+		if (target) return {
+			module: target,
+			pageName: stripped,
+			params: {}
+		};
+		const dynamicMatch = resolveDynamicPage(stripped, pagesMap);
+		if (dynamicMatch) return dynamicMatch;
+	}
+	if (!target) return null;
+	return {
+		module: target,
+		pageName,
+		params: {}
+	};
+}
+
+//#endregion
+export { isDynamicRoutePattern as a, expandRoutePattern as i, resolvePageName as n, toPosix as o, resolvePageTarget as r, toPosixRelative as s, pagePathToKey as t };