@pracht/core 0.6.1 → 0.8.0

package/dist/app-BWriseLj.d.mts

@@ -0,0 +1,298 @@
+import { ComponentChildren, FunctionComponent } 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>;
+type RouteParamInput = string | number | boolean;
+type SearchParamPrimitive = string | number | boolean;
+type SearchParamValue = SearchParamPrimitive | null | undefined | readonly (SearchParamPrimitive | null | undefined)[];
+type SearchParamsInput = string | URLSearchParams | Record<string, SearchParamValue>;
+interface BuildHrefOptions {
+  params?: Record<string, RouteParamInput>;
+  search?: SearchParamsInput;
+  hash?: string;
+}
+interface NavigateOptions {
+  replace?: boolean;
+}
+interface HrefRouteDefinition {
+  id?: string;
+  path: string;
+  segments?: readonly RouteSegment[];
+}
+type RegisteredRouteMap = Register extends {
+  routes: infer TRoutes;
+} ? TRoutes extends Record<string, unknown> ? TRoutes : {} : {};
+type HasRegisteredRoutes = keyof RegisteredRouteMap extends never ? false : true;
+type EmptyRouteParams = Record<never, never>;
+type IsEmptyRouteParams<TParams> = keyof TParams extends never ? true : false;
+type RouteId = HasRegisteredRoutes extends true ? Extract<keyof RegisteredRouteMap, string> : string;
+type RouteParamsFor<TRoute extends RouteId> = HasRegisteredRoutes extends true ? TRoute extends keyof RegisteredRouteMap ? RegisteredRouteMap[TRoute] extends {
+  params: infer TParams;
+} ? TParams extends Record<string, unknown> ? TParams : EmptyRouteParams : EmptyRouteParams : never : Record<string, RouteParamInput>;
+type RouteSearchFor<TRoute extends RouteId> = HasRegisteredRoutes extends true ? TRoute extends keyof RegisteredRouteMap ? RegisteredRouteMap[TRoute] extends {
+  search: infer TSearch;
+} ? TSearch : SearchParamsInput : never : SearchParamsInput;
+type TypedHrefOptions<TRoute extends RouteId> = IsEmptyRouteParams<RouteParamsFor<TRoute>> extends true ? {
+  params?: never;
+  search?: RouteSearchFor<TRoute>;
+  hash?: string;
+} : {
+  params: RouteParamsFor<TRoute>;
+  search?: RouteSearchFor<TRoute>;
+  hash?: string;
+};
+type HrefOptions<TRoute extends RouteId = RouteId> = HasRegisteredRoutes extends true ? TRoute extends RouteId ? TypedHrefOptions<TRoute> : never : BuildHrefOptions;
+type HrefArgs<TRoute extends RouteId = RouteId> = HasRegisteredRoutes extends true ? TRoute extends RouteId ? IsEmptyRouteParams<RouteParamsFor<TRoute>> extends true ? [options?: TypedHrefOptions<TRoute>] : [options: TypedHrefOptions<TRoute>] : never : [options?: BuildHrefOptions];
+type RouteTarget<TRoute extends RouteId = RouteId> = HasRegisteredRoutes extends true ? TRoute extends RouteId ? {
+  route: TRoute;
+} & TypedHrefOptions<TRoute> : never : {
+  route: string;
+} & BuildHrefOptions;
+type HrefFn = <TRoute extends RouteId>(route: TRoute, ...args: HrefArgs<TRoute>) => string;
+/**
+ * A reference to a module file — either a plain string path or a lazy import
+ * function. Using `() => import("./path")` enables IDE click-to-navigate.
+ * The vite plugin transforms import functions back to strings at build time.
+ */
+type ModuleRef = string | (() => Promise<any>);
+interface TimeRevalidatePolicy {
+  kind: "time";
+  seconds: number;
+}
+type RouteRevalidate = TimeRevalidatePolicy;
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type ApiRouteArgs<TContext = RegisteredContext> = Omit<BaseRouteArgs<TContext>, "route"> & {
+  route: ResolvedApiRoute;
+};
+type ApiRouteHandler<TContext = RegisteredContext> = (args: ApiRouteArgs<TContext>) => MaybePromise<Response>;
+interface ApiRouteModule<TContext = any> {
+  default?: ApiRouteHandler<TContext>;
+  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;
+  hasLoader?: boolean;
+}
+interface GroupMeta {
+  shell?: string;
+  render?: RenderMode;
+  middleware?: string[];
+  pathPrefix?: string;
+}
+interface ApiConfig {
+  middleware?: string[];
+  /**
+   * When `true` (the default), state-changing API requests
+   * (POST/PUT/PATCH/DELETE) are rejected unless the browser signals an
+   * exact same-origin fetch (`Sec-Fetch-Site: same-origin`) or the request
+   * Origin/Referer matches the request URL's origin. `same-site` is not
+   * accepted by default because sibling subdomains can be attacker-controlled.
+   * Set to `false` to opt out if you build your own CSRF protection into middleware.
+   */
+  requireSameOrigin?: boolean;
+}
+interface RouteConfig extends RouteMeta {
+  component: ModuleRef;
+  loader?: ModuleRef;
+}
+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, ModuleRef>;
+  middleware?: Record<string, ModuleRef>;
+  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: string;
+}
+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> {}
+type HeadAttributes = Record<string, string | undefined>;
+interface HeadScriptDescriptor extends HeadAttributes {
+  children?: string;
+}
+interface HeadMetadata {
+  title?: string;
+  lang?: string;
+  meta?: HeadAttributes[];
+  link?: HeadAttributes[];
+  script?: HeadScriptDescriptor[];
+}
+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 HeadersArgs<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 & {
+    diagnostics?: unknown;
+    status?: number;
+  };
+}
+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>;
+  headers?: (args: HeadersArgs<TLoader, TContext>) => MaybePromise<HeadersInit>;
+  Component?: FunctionComponent<RouteComponentProps<TLoader>>;
+  default?: FunctionComponent<RouteComponentProps<TLoader>>;
+  ErrorBoundary?: FunctionComponent<ErrorBoundaryProps>;
+  getStaticPaths?: () => MaybePromise<RouteParams[]>;
+  markdown?: string;
+}
+interface ShellModule<TContext = any> {
+  Shell: FunctionComponent<ShellProps>;
+  Loading?: FunctionComponent;
+  ErrorBoundary?: FunctionComponent<ErrorBoundaryProps>;
+  head?: (args: BaseRouteArgs<TContext>) => MaybePromise<HeadMetadata>;
+  headers?: (args: BaseRouteArgs<TContext>) => MaybePromise<HeadersInit>;
+}
+type MiddlewareNext = () => Promise<Response>;
+type MiddlewareFn<TContext = any> = (args: MiddlewareArgs<TContext>, next: MiddlewareNext) => MaybePromise<Response>;
+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: ModuleRef, 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: readonly RouteSegment[], params: RouteParams): string;
+declare function buildHref<TRoute extends RouteId>(routes: readonly HrefRouteDefinition[], routeId: TRoute, ...args: HrefArgs<TRoute>): 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/files/[...path].ts"` → path `/api/files/*`
+ *          `"/src/api/index.ts"` → path `/api`
+ */
+declare function resolveApiRoutes(files: string[], apiDir?: string): ResolvedApiRoute[];
+declare function matchApiRoute(apiRoutes: ResolvedApiRoute[], pathname: string): ApiRouteMatch | undefined;
+//#endregion
+export { RouteComponentProps as $, HrefRouteDefinition as A, ModuleImporter as B, HeadAttributes as C, HrefArgs as D, HeadersArgs as E, LoaderLike as F, PrachtAppConfig as G, ModuleRegistry as H, MiddlewareArgs as I, Register as J, PrachtHttpError as K, MiddlewareFn as L, LoaderArgs as M, LoaderData as N, HrefFn as O, LoaderFn as P, ResolvedRoute as Q, MiddlewareModule as R, HeadArgs as S, HeadScriptDescriptor as T, NavigateOptions as U, ModuleRef as V, PrachtApp as W, ResolvedApiRoute as X, RenderMode as Y, ResolvedPrachtApp as Z, BuildHrefOptions as _, ShellProps as _t, matchApiRoute as a, RouteModule as at, GroupDefinition as b, resolveApp as c, RouteParamsFor as ct, ApiConfig as d, RouteTarget as dt, RouteConfig as et, ApiRouteArgs as f, RouteTreeNode as ft, BaseRouteArgs as g, ShellModule as gt, ApiRouteModule as h, SearchParamsInput as ht, group as i, RouteMeta as it, HttpMethod as j, HrefOptions as k, route as l, RouteRevalidate as lt, ApiRouteMatch as m, SearchParamValue as mt, buildPathFromSegments as n, RouteId as nt, matchAppRoute as o, RouteParamInput as ot, ApiRouteHandler as p, SearchParamPrimitive as pt, PrefetchStrategy as q, defineApp as r, RouteMatch as rt, resolveApiRoutes as s, RouteParams as st, buildHref as t, RouteDefinition as tt, timeRevalidate as u, RouteSearchFor as ut, DataModule as v, TimeRevalidatePolicy as vt, HeadMetadata as w, GroupMeta as x, ErrorBoundaryProps as y, MiddlewareNext as z };

package/dist/app-BvC1uQG5.mjs

@@ -0,0 +1,308 @@
+//#region src/app.ts
+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" || typeof fileOrConfig === "function") return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: resolveModuleRef(fileOrConfig),
+		...meta
+	};
+	const { component, loader, ...routeMeta } = fileOrConfig;
+	return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: resolveModuleRef(component),
+		loaderFile: resolveModuleRef(loader),
+		hasLoader: !!loader,
+		...routeMeta
+	};
+}
+function resolveModuleRef(ref) {
+	if (ref === void 0) return void 0;
+	if (typeof ref === "string") return ref;
+	return "";
+}
+function group(meta, routes) {
+	return {
+		kind: "group",
+		meta,
+		routes
+	};
+}
+function defineApp(config) {
+	return {
+		shells: resolveModuleRefRecord(config.shells ?? {}),
+		middleware: resolveModuleRefRecord(config.middleware ?? {}),
+		api: config.api ?? {},
+		routes: config.routes
+	};
+}
+function resolveModuleRefRecord(record) {
+	const result = {};
+	for (const [key, value] of Object.entries(record)) result[key] = resolveModuleRef(value);
+	return result;
+}
+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,
+		hasLoader: node.loaderFile ? true : node.hasLoader,
+		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") {
+			try {
+				params[currentSegment.name] = targetSegments.slice(targetIndex).map(decodeURIComponent).join("/");
+			} catch {
+				return null;
+			}
+			return params;
+		}
+		const targetSegment = targetSegments[targetIndex];
+		if (typeof targetSegment === "undefined") return null;
+		if (currentSegment.type === "static") {
+			if (currentSegment.value !== targetSegment) return null;
+		} else try {
+			params[currentSegment.name] = decodeURIComponent(targetSegment);
+		} catch {
+			return null;
+		}
+		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(":") && segment.endsWith("*")) return {
+			type: "catchall",
+			name: segment.slice(1, -1) || "*"
+		};
+		if (segment.startsWith(":")) return {
+			type: "param",
+			name: segment.slice(1)
+		};
+		assertSafeStaticRouteSegment(segment);
+		return {
+			type: "static",
+			value: segment
+		};
+	});
+}
+function splitPathSegments(path) {
+	return normalizeRoutePath(path).split("/").filter(Boolean);
+}
+function assertSafeStaticRouteSegment(segment) {
+	if (segment === "." || segment === "..") throw new Error(`Unsafe static route segment "${segment}" is not allowed.`);
+	if (segment.includes("\0") || /[\r\n\\]/.test(segment)) throw new Error(`Unsafe static route segment "${segment}" contains a forbidden character.`);
+}
+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 encodeDynamicPathSegment(params[segment.name] ?? "");
+		return (params[segment.name] ?? params["*"] ?? "").split("/").map((part) => encodeDynamicPathSegment(part)).join("/");
+	}).join("/"));
+}
+function buildHref(routes, routeId, ...args) {
+	return buildHrefUntyped(routes, String(routeId), args[0]);
+}
+function buildHrefUntyped(routes, routeId, options = {}) {
+	const route = routes.find((candidate) => candidate.id === routeId);
+	if (!route) throw new Error(`Unknown pracht route id: ${routeId}.`);
+	const segments = route.segments ?? parseRouteSegments(route.path);
+	return `${buildPathFromSegments(segments, normalizeHrefParams(segments, options.params ?? {}))}${serializeSearch(options.search)}${serializeHash(options.hash)}`;
+}
+function normalizeHrefParams(segments, params) {
+	const expected = new Set(segments.filter((segment) => segment.type === "param" || segment.type === "catchall").map((segment) => segment.name));
+	for (const name of expected) if (params[name] == null) throw new Error(`Missing route param: ${name}.`);
+	for (const name of Object.keys(params)) if (!expected.has(name)) throw new Error(`Unexpected route param: ${name}.`);
+	const normalized = {};
+	for (const name of expected) normalized[name] = String(params[name]);
+	return normalized;
+}
+function serializeSearch(search) {
+	if (search == null) return "";
+	if (typeof search === "string") {
+		if (!search) return "";
+		return search.startsWith("?") ? search : `?${search}`;
+	}
+	const serialized = (search instanceof URLSearchParams ? search : objectToSearchParams(search)).toString();
+	return serialized ? `?${serialized}` : "";
+}
+function objectToSearchParams(search) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(search)) {
+		if (Array.isArray(value)) {
+			for (const item of value) appendSearchValue(params, key, item);
+			continue;
+		}
+		appendSearchValue(params, key, value);
+	}
+	return params;
+}
+function appendSearchValue(params, key, value) {
+	if (value == null) return;
+	params.append(key, String(value));
+}
+function serializeHash(hash) {
+	if (!hash) return "";
+	return hash.startsWith("#") ? hash : `#${hash}`;
+}
+/**
+* Encode one dynamic URL path segment for SSG/ISG output. `encodeURIComponent`
+* leaves unreserved characters (including `.`) intact, and even percent-encoded
+* dot segments are normalized by URL parsers. Reject exact `.` / `..` segments
+* instead of allowing them to reach filesystem output path construction.
+*/
+function encodeDynamicPathSegment(part) {
+	if (part === "." || part === "..") throw new Error(`Unsafe dynamic route param segment "${part}" is not allowed.`);
+	return encodeURIComponent(part);
+}
+/**
+* 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/files/[...path].ts"` → path `/api/files/*`
+*          `"/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, "*");
+		relative = relative.replace(/\[([^\]]+)\]/g, ":$1");
+		const path = normalizeRoutePath(`/api${relative}`);
+		return {
+			path,
+			file,
+			segments: parseRouteSegments(path)
+		};
+	}).sort(compareResolvedApiRoutes);
+}
+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, "-");
+}
+function compareResolvedApiRoutes(left, right) {
+	const length = Math.max(left.segments.length, right.segments.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftSegment = left.segments[index];
+		const rightSegment = right.segments[index];
+		if (!leftSegment) return 1;
+		if (!rightSegment) return -1;
+		const leftScore = getRouteSegmentSpecificity(leftSegment);
+		const rightScore = getRouteSegmentSpecificity(rightSegment);
+		if (leftScore !== rightScore) return rightScore - leftScore;
+	}
+	return left.path.localeCompare(right.path);
+}
+function getRouteSegmentSpecificity(segment) {
+	if (segment.type === "static") return 3;
+	if (segment.type === "param") return 2;
+	return 1;
+}
+//#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, buildHref as t, timeRevalidate as u };

package/dist/browser.d.mts

@@ -0,0 +1,7 @@
+import { $ as RouteComponentProps, A as HrefRouteDefinition, B as ModuleImporter, C as HeadAttributes, D as HrefArgs, E as HeadersArgs, G as PrachtAppConfig, H as ModuleRegistry, I as MiddlewareArgs, J as Register, K as PrachtHttpError, L as MiddlewareFn, M as LoaderArgs, N as LoaderData, O as HrefFn, P as LoaderFn, Q as ResolvedRoute, R as MiddlewareModule, S as HeadArgs, T as HeadScriptDescriptor, U as NavigateOptions, V as ModuleRef, W as PrachtApp, X as ResolvedApiRoute, Y as RenderMode, Z as ResolvedPrachtApp, _ as BuildHrefOptions, _t as ShellProps, at as RouteModule, b as GroupDefinition, c as resolveApp, ct as RouteParamsFor, d as ApiConfig, dt as RouteTarget, et as RouteConfig, f as ApiRouteArgs, ft as RouteTreeNode, g as BaseRouteArgs, gt as ShellModule, h as ApiRouteModule, ht as SearchParamsInput, i as group, it as RouteMeta, j as HttpMethod, k as HrefOptions, l as route, lt as RouteRevalidate, m as ApiRouteMatch, mt as SearchParamValue, n as buildPathFromSegments, nt as RouteId, o as matchAppRoute, ot as RouteParamInput, p as ApiRouteHandler, pt as SearchParamPrimitive, q as PrefetchStrategy, r as defineApp, rt as RouteMatch, st as RouteParams, t as buildHref, tt as RouteDefinition, u as timeRevalidate, ut as RouteSearchFor, v as DataModule, vt as TimeRevalidatePolicy, w as HeadMetadata, x as GroupMeta, y as ErrorBoundaryProps, z as MiddlewareNext } from "./app-BWriseLj.mjs";
+import { a as parseSafeNavigationUrl, c as Link, d as useLocation, f as useParams, h as createHref, i as fetchPrachtRouteState, l as LinkProps, m as useRouteData, n as redirect, o as Form, p as useRevalidate, r as RouteStateResult, s as FormProps, t as RedirectOptions, u as Location } from "./runtime-middleware-aeBdgjYr.mjs";
+import { n as forwardRef, t as useIsHydrated } from "./hydration-M1QzbQ1O.mjs";
+import { a as startApp, c as SerializedRouteError, i as readHydrationState, n as PrachtRuntimeProvider, r as StartAppOptions, t as PrachtHydrationState } from "./runtime-context-ytVd7GmZ.mjs";
+import { i as useNavigate, n as NavigateFn, r as initClientRouter, t as InitClientRouterOptions } from "./router-BcUmg1kB.mjs";
+import { Suspense, lazy } from "preact-suspense";
+export { type ApiConfig, type ApiRouteArgs, type ApiRouteHandler, type ApiRouteMatch, type ApiRouteModule, type BaseRouteArgs, type BuildHrefOptions, type DataModule, type ErrorBoundaryProps, Form, type FormProps, type GroupDefinition, type GroupMeta, type HeadArgs, type HeadAttributes, type HeadMetadata, type HeadScriptDescriptor, type HeadersArgs, type HrefArgs, type HrefFn, type HrefOptions, type HrefRouteDefinition, type HttpMethod, type InitClientRouterOptions, Link, type LinkProps, type LoaderArgs, type LoaderData, type LoaderFn, type Location, type MiddlewareArgs, type MiddlewareFn, type MiddlewareModule, type MiddlewareNext, type ModuleImporter, type ModuleRef, type ModuleRegistry, type NavigateFn, type NavigateOptions, type PrachtApp, type PrachtAppConfig, PrachtHttpError, type PrachtHydrationState, PrachtRuntimeProvider, type PrefetchStrategy, type RedirectOptions, type Register, type RenderMode, type ResolvedApiRoute, type ResolvedPrachtApp, type ResolvedRoute, type RouteComponentProps, type RouteConfig, type RouteDefinition, type RouteId, type RouteMatch, type RouteMeta, type RouteModule, type RouteParamInput, type RouteParams, type RouteParamsFor, type RouteRevalidate, type RouteSearchFor, type RouteStateResult, type RouteTarget, type RouteTreeNode, type SearchParamPrimitive, type SearchParamValue, type SearchParamsInput, type SerializedRouteError, type ShellModule, type ShellProps, type StartAppOptions, Suspense, type TimeRevalidatePolicy, buildHref, buildPathFromSegments, createHref, defineApp, fetchPrachtRouteState, forwardRef, group, initClientRouter, lazy, matchAppRoute, parseSafeNavigationUrl, readHydrationState, redirect, resolveApp, route, startApp, timeRevalidate, useIsHydrated, useLocation, useNavigate, useParams, useRevalidate, useRouteData };

package/dist/browser.mjs

@@ -0,0 +1,8 @@
+import { c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, t as buildHref, u as timeRevalidate } from "./app-BvC1uQG5.mjs";
+import { S as createHref, a as useParams, i as useLocation, n as Form, o as useRevalidate, r as Link, s as useRouteData, t as PrachtHttpError, u as redirect } from "./types-idmK5omD.mjs";
+import { t as forwardRef } from "./forwardRef-grZ6t4GS.mjs";
+import { n as useNavigate, r as useIsHydrated, t as initClientRouter } from "./router-B7J4YYwg.mjs";
+import { l as parseSafeNavigationUrl, s as fetchPrachtRouteState } from "./prefetch-cache-DzP2Bj9H.mjs";
+import { i as startApp, r as readHydrationState, t as PrachtRuntimeProvider } from "./runtime-context-B5pREhcM.mjs";
+import { Suspense, lazy } from "preact-suspense";
+export { Form, Link, PrachtHttpError, PrachtRuntimeProvider, Suspense, buildHref, buildPathFromSegments, createHref, defineApp, fetchPrachtRouteState, forwardRef, group, initClientRouter, lazy, matchAppRoute, parseSafeNavigationUrl, readHydrationState, redirect, resolveApp, route, startApp, timeRevalidate, useIsHydrated, useLocation, useNavigate, useParams, useRevalidate, useRouteData };

package/dist/client.d.mts

@@ -0,0 +1,4 @@
+import { c as resolveApp } from "./app-BWriseLj.mjs";
+import { i as readHydrationState, t as PrachtHydrationState } from "./runtime-context-ytVd7GmZ.mjs";
+import { n as NavigateFn, r as initClientRouter, t as InitClientRouterOptions } from "./router-BcUmg1kB.mjs";
+export { type InitClientRouterOptions, type NavigateFn, type PrachtHydrationState, initClientRouter, readHydrationState, resolveApp };

package/dist/client.mjs

@@ -0,0 +1,4 @@
+import { c as resolveApp } from "./app-BvC1uQG5.mjs";
+import { t as initClientRouter } from "./router-B7J4YYwg.mjs";
+import { r as readHydrationState } from "./runtime-context-B5pREhcM.mjs";
+export { initClientRouter, readHydrationState, resolveApp };

package/dist/forwardRef-grZ6t4GS.mjs

@@ -0,0 +1,27 @@
+import { options } from "preact";
+//#region src/forwardRef.ts
+let oldDiffHook = options.__b;
+options.__b = (vnode) => {
+	if (vnode.type && vnode.type.__f && vnode.ref) {
+		vnode.props.ref = vnode.ref;
+		vnode.ref = null;
+	}
+	if (oldDiffHook) oldDiffHook(vnode);
+};
+/**
+* Pass ref down to a child. This is mainly used in libraries with HOCs that
+* wrap components. Using `forwardRef` there is an easy way to get a reference
+* of the wrapped component instead of one of the wrapper itself.
+*/
+function forwardRef(fn) {
+	function Forwarded(props) {
+		const clone = { ...props };
+		delete clone.ref;
+		return fn(clone, props.ref || null);
+	}
+	Forwarded.__f = true;
+	Forwarded.displayName = "ForwardRef(" + (fn.displayName || fn.name) + ")";
+	return Forwarded;
+}
+//#endregion
+export { forwardRef as t };