@pracht/core 0.0.0

package/dist/app-CAoDWWNO.mjs

@@ -0,0 +1,227 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/app.ts
+var app_exports = /* @__PURE__ */ __exportAll({
+	buildPathFromSegments: () => buildPathFromSegments,
+	defineApp: () => defineApp,
+	group: () => group,
+	matchApiRoute: () => matchApiRoute,
+	matchAppRoute: () => matchAppRoute,
+	resolveApiRoutes: () => resolveApiRoutes,
+	resolveApp: () => resolveApp,
+	route: () => route,
+	timeRevalidate: () => timeRevalidate
+});
+function timeRevalidate(seconds) {
+	if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("timeRevalidate expects a positive integer number of seconds.");
+	return {
+		kind: "time",
+		seconds
+	};
+}
+function route(path, fileOrConfig, meta = {}) {
+	if (typeof fileOrConfig === "string") return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: fileOrConfig,
+		...meta
+	};
+	const { component, loader, ...routeMeta } = fileOrConfig;
+	return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: component,
+		loaderFile: loader,
+		...routeMeta
+	};
+}
+function group(meta, routes) {
+	return {
+		kind: "group",
+		meta,
+		routes
+	};
+}
+function defineApp(config) {
+	return {
+		shells: config.shells ?? {},
+		middleware: config.middleware ?? {},
+		api: config.api ?? {},
+		routes: config.routes
+	};
+}
+function resolveApp(app) {
+	const routes = [];
+	const inherited = {
+		pathPrefix: "/",
+		middleware: []
+	};
+	for (const node of app.routes) flattenRouteNode(app, node, inherited, routes);
+	return {
+		shells: app.shells,
+		middleware: app.middleware,
+		api: app.api,
+		routes,
+		apiRoutes: []
+	};
+}
+function matchAppRoute(app, pathname) {
+	const resolved = isResolvedApp(app) ? app : resolveApp(app);
+	const normalizedPathname = normalizeRoutePath(pathname);
+	const targetSegments = splitPathSegments(normalizedPathname);
+	for (const currentRoute of resolved.routes) {
+		const params = matchRouteSegments(currentRoute.segments, targetSegments);
+		if (params) return {
+			route: currentRoute,
+			params,
+			pathname: normalizedPathname
+		};
+	}
+}
+function flattenRouteNode(app, node, inherited, routes) {
+	if (node.kind === "group") {
+		const nextInherited = {
+			pathPrefix: mergeRoutePaths(inherited.pathPrefix, node.meta.pathPrefix),
+			shell: node.meta.shell ?? inherited.shell,
+			render: node.meta.render ?? inherited.render,
+			middleware: [...inherited.middleware, ...node.meta.middleware ?? []]
+		};
+		for (const child of node.routes) flattenRouteNode(app, child, nextInherited, routes);
+		return;
+	}
+	const fullPath = mergeRoutePaths(inherited.pathPrefix, node.path);
+	const shell = node.shell ?? inherited.shell;
+	const middleware = [...inherited.middleware, ...node.middleware ?? []];
+	routes.push({
+		id: node.id ?? createRouteId(fullPath),
+		path: fullPath,
+		file: node.file,
+		loaderFile: node.loaderFile,
+		shell,
+		shellFile: shell ? app.shells[shell] : void 0,
+		render: node.render ?? inherited.render,
+		middleware,
+		middlewareFiles: middleware.flatMap((name) => {
+			const middlewareFile = app.middleware[name];
+			return middlewareFile ? [middlewareFile] : [];
+		}),
+		revalidate: node.revalidate,
+		segments: parseRouteSegments(fullPath)
+	});
+}
+function isResolvedApp(app) {
+	return app.routes.length === 0 || "segments" in app.routes[0];
+}
+function matchRouteSegments(routeSegments, targetSegments) {
+	const params = {};
+	let routeIndex = 0;
+	let targetIndex = 0;
+	while (routeIndex < routeSegments.length) {
+		const currentSegment = routeSegments[routeIndex];
+		if (currentSegment.type === "catchall") {
+			params[currentSegment.name] = targetSegments.slice(targetIndex).join("/");
+			return params;
+		}
+		const targetSegment = targetSegments[targetIndex];
+		if (typeof targetSegment === "undefined") return null;
+		if (currentSegment.type === "static") {
+			if (currentSegment.value !== targetSegment) return null;
+		} else params[currentSegment.name] = decodeURIComponent(targetSegment);
+		routeIndex += 1;
+		targetIndex += 1;
+	}
+	return targetIndex === targetSegments.length ? params : null;
+}
+function parseRouteSegments(path) {
+	return splitPathSegments(path).map((segment) => {
+		if (segment === "*") return {
+			type: "catchall",
+			name: "*"
+		};
+		if (segment.startsWith(":")) return {
+			type: "param",
+			name: segment.slice(1)
+		};
+		return {
+			type: "static",
+			value: segment
+		};
+	});
+}
+function splitPathSegments(path) {
+	return normalizeRoutePath(path).split("/").filter(Boolean);
+}
+function mergeRoutePaths(prefix, path) {
+	if (!path) return normalizeRoutePath(prefix);
+	const normalizedPrefix = normalizeRoutePath(prefix);
+	const normalizedPath = normalizeRoutePath(path);
+	if (normalizedPrefix === "/") return normalizedPath;
+	if (normalizedPath === "/") return normalizedPrefix;
+	return normalizeRoutePath(`${normalizedPrefix}/${normalizedPath.slice(1)}`);
+}
+function normalizeRoutePath(path) {
+	if (!path || path === "/") return "/";
+	const collapsed = (path.startsWith("/") ? path : `/${path}`).replace(/\/{2,}/g, "/");
+	return collapsed.length > 1 && collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+}
+function buildPathFromSegments(segments, params) {
+	return normalizeRoutePath("/" + segments.map((segment) => {
+		if (segment.type === "static") return segment.value;
+		if (segment.type === "param") return encodeURIComponent(params[segment.name] ?? "");
+		return params["*"] ?? "";
+	}).join("/"));
+}
+/**
+* Convert a list of file paths from `import.meta.glob` into resolved API routes.
+*
+* Example: `"/src/api/health.ts"` → path `/api/health`
+*          `"/src/api/users/[id].ts"` → path `/api/users/:id`
+*          `"/src/api/index.ts"` → path `/api`
+*/
+function resolveApiRoutes(files, apiDir = "/src/api") {
+	const normalizedDir = apiDir.replace(/\/$/, "");
+	return files.map((file) => {
+		let relative = file;
+		if (relative.startsWith(normalizedDir)) relative = relative.slice(normalizedDir.length);
+		relative = relative.replace(/\.(ts|tsx|js|jsx)$/, "");
+		if (relative.endsWith("/index")) relative = relative.slice(0, -6) || "/";
+		relative = relative.replace(/\[([^\]]+)\]/g, ":$1");
+		const path = normalizeRoutePath(`/api${relative}`);
+		return {
+			path,
+			file,
+			segments: parseRouteSegments(path)
+		};
+	});
+}
+function matchApiRoute(apiRoutes, pathname) {
+	const normalizedPathname = normalizeRoutePath(pathname);
+	const targetSegments = splitPathSegments(normalizedPathname);
+	for (const route of apiRoutes) {
+		const params = matchRouteSegments(route.segments, targetSegments);
+		if (params) return {
+			route,
+			params,
+			pathname: normalizedPathname
+		};
+	}
+}
+function createRouteId(path) {
+	if (path === "/") return "index";
+	return path.slice(1).split("/").map((segment) => {
+		if (segment === "*") return "splat";
+		return segment.startsWith(":") ? segment.slice(1) : segment;
+	}).join("-").replace(/[^a-zA-Z0-9-]/g, "-");
+}
+//#endregion
+export { matchApiRoute as a, resolveApp as c, group as i, route as l, buildPathFromSegments as n, matchAppRoute as o, defineApp as r, resolveApiRoutes as s, app_exports as t, timeRevalidate as u };

package/dist/error-overlay.d.mts

@@ -0,0 +1,16 @@
+//#region src/error-overlay.d.ts
+/**
+ * Self-contained error overlay for pracht dev mode.
+ *
+ * Returns a standalone HTML document with inline styles and scripts.
+ * Not a Preact component — must render even when Preact itself fails.
+ */
+interface ErrorOverlayOptions {
+  message: string;
+  stack?: string;
+  routeId?: string;
+  file?: string;
+}
+declare function buildErrorOverlayHtml(options: ErrorOverlayOptions): string;
+//#endregion
+export { ErrorOverlayOptions, buildErrorOverlayHtml };

package/dist/error-overlay.mjs

@@ -0,0 +1,112 @@
+//#region src/error-overlay.ts
+function buildErrorOverlayHtml(options) {
+	const { message, stack, routeId, file } = options;
+	const stackHtml = stack ? `<pre class="stack">${escapeHtml(stack)}</pre>` : "";
+	const routeHtml = routeId ? `<div class="meta"><span class="label">Route</span> <span class="value">${escapeHtml(routeId)}</span></div>` : "";
+	const fileHtml = file ? `<div class="meta"><span class="label">File</span> <span class="value">${escapeHtml(file)}</span></div>` : "";
+	return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>pracht error</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: ui-monospace, "Cascadia Code", "Source Code Pro", Menlo, Consolas, monospace;
+      background: #1a1a2e;
+      color: #e0e0e0;
+      padding: 32px;
+      line-height: 1.5;
+    }
+    .overlay {
+      max-width: 900px;
+      margin: 0 auto;
+    }
+    .header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      margin-bottom: 24px;
+      padding-bottom: 16px;
+      border-bottom: 1px solid #333;
+    }
+    .badge {
+      background: #e74c3c;
+      color: #fff;
+      font-size: 11px;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      padding: 4px 10px;
+      border-radius: 4px;
+    }
+    .title {
+      font-size: 14px;
+      color: #888;
+    }
+    .message {
+      font-size: 18px;
+      font-weight: 600;
+      color: #ff6b6b;
+      margin-bottom: 20px;
+      word-break: break-word;
+    }
+    .meta {
+      font-size: 13px;
+      margin-bottom: 6px;
+    }
+    .meta .label {
+      color: #888;
+      margin-right: 8px;
+    }
+    .meta .value {
+      color: #a0c4ff;
+    }
+    .stack {
+      background: #16162a;
+      border: 1px solid #333;
+      border-radius: 8px;
+      padding: 20px;
+      margin-top: 20px;
+      font-size: 13px;
+      line-height: 1.7;
+      overflow-x: auto;
+      white-space: pre-wrap;
+      word-break: break-word;
+      color: #ccc;
+    }
+    .hint {
+      margin-top: 24px;
+      font-size: 12px;
+      color: #666;
+    }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="header">
+      <span class="badge">Error</span>
+      <span class="title">pracht dev</span>
+    </div>
+    <div class="message">${escapeHtml(message)}</div>
+    ${routeHtml}
+    ${fileHtml}
+    ${stackHtml}
+    <div class="hint">Fix the error and save — the page will reload automatically.</div>
+  </div>
+  <script>
+    // Auto-reload when Vite triggers a full reload (e.g. file saved after fix)
+    if (import.meta.hot) {
+      import.meta.hot.on("vite:beforeFullReload", function () {
+        window.location.reload();
+      });
+    }
+  <\/script>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//#endregion
+export { buildErrorOverlayHtml };

package/dist/index.d.mts

@@ -0,0 +1,343 @@
+import { Suspense, lazy } from "preact-suspense";
+import * as _$preact from "preact";
+import { ComponentChildren, FunctionComponent, JSX, h } from "preact";
+
+//#region src/types.d.ts
+/**
+ * Augment this interface to register your app's context type globally.
+ * Once registered, all route args (`BaseRouteArgs`, `LoaderArgs`, etc.)
+ * will use your context type automatically — no per-file generics needed.
+ *
+ * ```ts
+ * // src/env.d.ts
+ * declare module "@pracht/core" {
+ *   interface Register {
+ *     context: { env: Env; executionContext: ExecutionContext };
+ *   }
+ * }
+ * ```
+ */
+interface Register {}
+type RegisteredContext = Register extends {
+  context: infer T;
+} ? T : unknown;
+type RenderMode = "spa" | "ssr" | "ssg" | "isg";
+type RouteParams = Record<string, string>;
+interface TimeRevalidatePolicy {
+  kind: "time";
+  seconds: number;
+}
+type RouteRevalidate = TimeRevalidatePolicy;
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type ApiRouteHandler<TContext = RegisteredContext> = (args: BaseRouteArgs<TContext>) => MaybePromise<Response>;
+interface ApiRouteModule<TContext = any> {
+  GET?: ApiRouteHandler<TContext>;
+  POST?: ApiRouteHandler<TContext>;
+  PUT?: ApiRouteHandler<TContext>;
+  PATCH?: ApiRouteHandler<TContext>;
+  DELETE?: ApiRouteHandler<TContext>;
+  HEAD?: ApiRouteHandler<TContext>;
+  OPTIONS?: ApiRouteHandler<TContext>;
+}
+interface ResolvedApiRoute {
+  path: string;
+  file: string;
+  segments: RouteSegment[];
+}
+interface ApiRouteMatch {
+  route: ResolvedApiRoute;
+  params: RouteParams;
+  pathname: string;
+}
+type PrefetchStrategy = "none" | "hover" | "viewport" | "intent";
+interface RouteMeta {
+  id?: string;
+  shell?: string;
+  render?: RenderMode;
+  middleware?: string[];
+  revalidate?: RouteRevalidate;
+  prefetch?: PrefetchStrategy;
+}
+interface GroupMeta {
+  shell?: string;
+  render?: RenderMode;
+  middleware?: string[];
+  pathPrefix?: string;
+}
+interface ApiConfig {
+  middleware?: string[];
+}
+interface RouteConfig extends RouteMeta {
+  component: string;
+  loader?: string;
+}
+interface RouteDefinition extends RouteMeta {
+  kind: "route";
+  path: string;
+  file: string;
+  loaderFile?: string;
+}
+interface GroupDefinition {
+  kind: "group";
+  meta: GroupMeta;
+  routes: RouteTreeNode[];
+}
+type RouteTreeNode = RouteDefinition | GroupDefinition;
+interface PrachtAppConfig {
+  shells?: Record<string, string>;
+  middleware?: Record<string, string>;
+  api?: ApiConfig;
+  routes: RouteTreeNode[];
+}
+interface PrachtApp {
+  shells: Record<string, string>;
+  middleware: Record<string, string>;
+  api: ApiConfig;
+  routes: RouteTreeNode[];
+}
+interface StaticRouteSegment {
+  type: "static";
+  value: string;
+}
+interface ParamRouteSegment {
+  type: "param";
+  name: string;
+}
+interface CatchAllRouteSegment {
+  type: "catchall";
+  name: "*";
+}
+type RouteSegment = StaticRouteSegment | ParamRouteSegment | CatchAllRouteSegment;
+interface ResolvedRoute extends Omit<RouteMeta, "middleware"> {
+  path: string;
+  file: string;
+  loaderFile?: string;
+  shell?: string;
+  shellFile?: string;
+  middleware: string[];
+  middlewareFiles: string[];
+  segments: RouteSegment[];
+}
+interface ResolvedPrachtApp extends Omit<PrachtApp, "routes"> {
+  routes: ResolvedRoute[];
+  apiRoutes: ResolvedApiRoute[];
+}
+interface RouteMatch {
+  route: ResolvedRoute;
+  params: RouteParams;
+  pathname: string;
+}
+interface BaseRouteArgs<TContext = RegisteredContext> {
+  request: Request;
+  params: RouteParams;
+  context: TContext;
+  signal: AbortSignal;
+  url: URL;
+  route: ResolvedRoute;
+}
+interface LoaderArgs<TContext = RegisteredContext> extends BaseRouteArgs<TContext> {}
+interface MiddlewareArgs<TContext = RegisteredContext> extends BaseRouteArgs<TContext> {}
+interface HeadMetadata {
+  title?: string;
+  lang?: string;
+  meta?: Array<Record<string, string>>;
+  link?: Array<Record<string, string>>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type LoaderLike = ((args: LoaderArgs<any>) => unknown) | undefined;
+type LoaderData<TLoader extends LoaderLike> = TLoader extends ((...args: any[]) => infer TResult) ? Awaited<TResult> : never;
+interface HeadArgs<TLoader extends LoaderLike = undefined, TContext = any> extends BaseRouteArgs<TContext> {
+  data: LoaderData<TLoader>;
+}
+interface RouteComponentProps<TLoader extends LoaderLike = undefined> {
+  data: LoaderData<TLoader>;
+  params: RouteParams;
+}
+interface ErrorBoundaryProps {
+  error: Error;
+}
+interface ShellProps {
+  children: ComponentChildren;
+}
+type LoaderFn<TContext = any, TData = unknown> = (args: LoaderArgs<TContext>) => MaybePromise<TData>;
+interface RouteModule<TContext = any, TLoader extends LoaderLike = undefined> {
+  loader?: LoaderFn<TContext>;
+  head?: (args: HeadArgs<TLoader, TContext>) => MaybePromise<HeadMetadata>;
+  Component: FunctionComponent<RouteComponentProps<TLoader>>;
+  ErrorBoundary?: FunctionComponent<ErrorBoundaryProps>;
+  getStaticPaths?: () => MaybePromise<RouteParams[]>;
+}
+interface ShellModule<TContext = any> {
+  Shell: FunctionComponent<ShellProps>;
+  head?: (args: BaseRouteArgs<TContext>) => MaybePromise<HeadMetadata>;
+}
+type MiddlewareResult<TContext = any> = void | Response | {
+  redirect: string;
+} | {
+  context: Partial<TContext>;
+};
+type MiddlewareFn<TContext = any> = (args: MiddlewareArgs<TContext>) => MaybePromise<MiddlewareResult<TContext>>;
+interface MiddlewareModule<TContext = any> {
+  middleware: MiddlewareFn<TContext>;
+}
+type ModuleImporter<TModule = unknown> = () => Promise<TModule>;
+interface DataModule<TContext = any> {
+  loader?: LoaderFn<TContext>;
+}
+interface ModuleRegistry {
+  routeModules?: Record<string, ModuleImporter<RouteModule>>;
+  shellModules?: Record<string, ModuleImporter<ShellModule>>;
+  middlewareModules?: Record<string, ModuleImporter<MiddlewareModule>>;
+  apiModules?: Record<string, ModuleImporter<ApiRouteModule>>;
+  dataModules?: Record<string, ModuleImporter<DataModule>>;
+}
+declare class PrachtHttpError extends Error {
+  readonly status: number;
+  constructor(status: number, message: string);
+}
+//#endregion
+//#region src/app.d.ts
+declare function timeRevalidate(seconds: number): TimeRevalidatePolicy;
+declare function route(path: string, file: string, meta?: RouteMeta): RouteDefinition;
+declare function route(path: string, config: RouteConfig): RouteDefinition;
+declare function group(meta: GroupMeta, routes: RouteTreeNode[]): GroupDefinition;
+declare function defineApp(config: PrachtAppConfig): PrachtApp;
+declare function resolveApp(app: PrachtApp): ResolvedPrachtApp;
+declare function matchAppRoute(app: PrachtApp | ResolvedPrachtApp, pathname: string): RouteMatch | undefined;
+declare function buildPathFromSegments(segments: RouteSegment[], params: RouteParams): string;
+/**
+ * Convert a list of file paths from `import.meta.glob` into resolved API routes.
+ *
+ * Example: `"/src/api/health.ts"` → path `/api/health`
+ *          `"/src/api/users/[id].ts"` → path `/api/users/:id`
+ *          `"/src/api/index.ts"` → path `/api`
+ */
+declare function resolveApiRoutes(files: string[], apiDir?: string): ResolvedApiRoute[];
+declare function matchApiRoute(apiRoutes: ResolvedApiRoute[], pathname: string): ApiRouteMatch | undefined;
+//#endregion
+//#region src/runtime.d.ts
+interface PrachtHydrationState<TData = unknown> {
+  url: string;
+  routeId: string;
+  data: TData;
+  error?: SerializedRouteError | null;
+}
+interface SerializedRouteError {
+  message: string;
+  name: string;
+  status: number;
+}
+interface StartAppOptions<TData = unknown> {
+  initialData?: TData;
+}
+interface HandlePrachtRequestOptions<TContext = unknown> {
+  app: PrachtApp;
+  request: Request;
+  context?: TContext;
+  registry?: ModuleRegistry;
+  clientEntryUrl?: string;
+  /** Per-source-file CSS map produced by the vite plugin (preferred over cssUrls). */
+  cssManifest?: Record<string, string[]>;
+  /** @deprecated Pass cssManifest instead for per-page CSS resolution. */
+  cssUrls?: string[];
+  /** Per-source-file JS chunk map produced by the vite plugin for modulepreload hints. */
+  jsManifest?: Record<string, string[]>;
+  apiRoutes?: ResolvedApiRoute[];
+}
+interface FormProps extends Omit<JSX.HTMLAttributes<HTMLFormElement>, "action" | "method"> {
+  action?: string;
+  method?: string;
+}
+declare global {
+  interface Window {
+    __PRACHT_STATE__?: PrachtHydrationState;
+    __PRACHT_NAVIGATE__?: (to: string, options?: {
+      replace?: boolean;
+    }) => Promise<void>;
+  }
+}
+interface PrachtRuntimeValue {
+  data: unknown;
+  params: RouteParams;
+  routeId: string;
+  url: string;
+  setData: (data: unknown) => void;
+}
+declare function PrachtRuntimeProvider<TData>({
+  children,
+  data,
+  params,
+  routeId,
+  url
+}: {
+  children: ComponentChildren;
+  data: TData;
+  params?: RouteParams;
+  routeId: string;
+  url: string;
+}): _$preact.VNode<_$preact.Attributes & {
+  value: PrachtRuntimeValue | undefined;
+  children?: ComponentChildren;
+}>;
+declare function startApp<TData = unknown>(options?: StartAppOptions<TData>): TData | undefined;
+declare function readHydrationState<TData = unknown>(): PrachtHydrationState<TData> | undefined;
+declare function useRouteData<TData = unknown>(): TData;
+interface Location {
+  pathname: string;
+}
+declare function useLocation(): Location;
+declare function useParams(): RouteParams;
+declare function useRevalidate(): () => Promise<unknown>;
+/** @deprecated Use useRevalidate instead. */
+declare const useRevalidateRoute: typeof useRevalidate;
+declare function Form(props: FormProps): _$preact.VNode<_$preact.ClassAttributes<HTMLFormElement> & h.JSX.HTMLAttributes<HTMLFormElement>>;
+declare function handlePrachtRequest<TContext>(options: HandlePrachtRequestOptions<TContext>): Promise<Response>;
+declare function applyDefaultSecurityHeaders(headers: Headers): Headers;
+interface PrerenderResult {
+  path: string;
+  html: string;
+}
+interface ISGManifestEntry {
+  revalidate: RouteRevalidate;
+}
+interface PrerenderAppResult {
+  pages: PrerenderResult[];
+  isgManifest: Record<string, ISGManifestEntry>;
+}
+interface PrerenderAppOptions {
+  app: PrachtApp;
+  registry?: ModuleRegistry;
+  clientEntryUrl?: string;
+  /** Per-source-file CSS map produced by the vite plugin (preferred over cssUrls). */
+  cssManifest?: Record<string, string[]>;
+  /** @deprecated Pass cssManifest instead for per-page CSS resolution. */
+  cssUrls?: string[];
+}
+declare function prerenderApp(options: PrerenderAppOptions): Promise<PrerenderResult[]>;
+declare function prerenderApp(options: PrerenderAppOptions & {
+  withISGManifest: true;
+}): Promise<PrerenderAppResult>;
+//#endregion
+//#region src/router.d.ts
+declare global {
+  interface Window {
+    __PRACHT_NAVIGATE__?: NavigateFn;
+    __PRACHT_ROUTER_READY__?: boolean;
+  }
+}
+type ModuleMap = Record<string, () => Promise<any>>;
+type NavigateFn = (to: string, options?: {
+  replace?: boolean;
+}) => Promise<void>;
+declare function useNavigate(): NavigateFn;
+interface InitClientRouterOptions {
+  app: ResolvedPrachtApp;
+  routeModules: ModuleMap;
+  shellModules: ModuleMap;
+  initialState: PrachtHydrationState;
+  root: HTMLElement;
+  findModuleKey: (modules: ModuleMap, file: string) => string | null;
+}
+declare function initClientRouter(options: InitClientRouterOptions): Promise<void>;
+//#endregion
+export { type ApiConfig, type ApiRouteHandler, type ApiRouteMatch, type ApiRouteModule, type BaseRouteArgs, type DataModule, type ErrorBoundaryProps, Form, type FormProps, type GroupDefinition, type GroupMeta, type HandlePrachtRequestOptions, type HeadArgs, type HeadMetadata, type HttpMethod, type ISGManifestEntry, type InitClientRouterOptions, type LoaderArgs, type LoaderData, type LoaderFn, type Location, type MiddlewareArgs, type MiddlewareFn, type MiddlewareModule, type MiddlewareResult, type ModuleImporter, type ModuleRegistry, type NavigateFn, type PrachtApp, type PrachtAppConfig, PrachtHttpError, type PrachtHydrationState, PrachtRuntimeProvider, type PrefetchStrategy, type PrerenderAppOptions, type PrerenderAppResult, type PrerenderResult, type Register, type RenderMode, type ResolvedApiRoute, type ResolvedPrachtApp, type ResolvedRoute, type RouteComponentProps, type RouteConfig, type RouteDefinition, type RouteMatch, type RouteMeta, type RouteModule, type RouteParams, type RouteRevalidate, type RouteTreeNode, type ShellModule, type ShellProps, type StartAppOptions, Suspense, type TimeRevalidatePolicy, applyDefaultSecurityHeaders, buildPathFromSegments, defineApp, group, handlePrachtRequest, initClientRouter, lazy, matchApiRoute, matchAppRoute, prerenderApp, readHydrationState, resolveApiRoutes, resolveApp, route, startApp, timeRevalidate, useLocation, useNavigate, useParams, useRevalidate, useRevalidateRoute, useRouteData };