@pracht/core 0.6.1 → 0.8.0

package/dist/runtime-middleware-aeBdgjYr.d.mts

@@ -0,0 +1,77 @@
+import { A as HrefRouteDefinition, F as LoaderLike, N as LoaderData, O as HrefFn, dt as RouteTarget, nt as RouteId, st as RouteParams } from "./app-BWriseLj.mjs";
+import { c as SerializedRouteError } from "./runtime-context-ytVd7GmZ.mjs";
+import * as _$preact from "preact";
+import { JSX, h } from "preact";
+
+//#region src/href.d.ts
+declare function createHref(routes: readonly HrefRouteDefinition[]): HrefFn;
+//#endregion
+//#region src/runtime-hooks.d.ts
+interface FormProps extends Omit<JSX.HTMLAttributes<HTMLFormElement>, "action" | "method"> {
+  action?: string;
+  method?: string;
+}
+type LinkProps<TRoute extends RouteId = RouteId> = Omit<JSX.HTMLAttributes<HTMLAnchorElement>, "href"> & RouteTarget<TRoute>;
+interface Location {
+  pathname: string;
+  search: string;
+}
+declare function useRouteData<TLoader extends LoaderLike>(): LoaderData<TLoader>;
+declare function useRouteData<TData = unknown>(): TData;
+declare function useLocation(): Location;
+declare function useParams(): RouteParams;
+declare function useRevalidate(): () => Promise<unknown>;
+declare function Link<TRoute extends RouteId>(props: LinkProps<TRoute>): _$preact.VNode<_$preact.ClassAttributes<HTMLAnchorElement> & h.JSX.HTMLAttributes<HTMLAnchorElement>>;
+declare function Form(props: FormProps): _$preact.VNode<_$preact.ClassAttributes<HTMLFormElement> & h.JSX.HTMLAttributes<HTMLFormElement>>;
+//#endregion
+//#region src/runtime-client-fetch.d.ts
+type RouteStateResult = {
+  type: "data";
+  data: unknown;
+} | {
+  type: "redirect";
+  location: string;
+} | {
+  type: "error";
+  error: SerializedRouteError;
+};
+/**
+ * Parse a possibly-server-supplied redirect target against a base URL and
+ * return it only if it uses a safe navigation scheme (`http:` or `https:`).
+ *
+ * `javascript:`, `data:`, `vbscript:`, `blob:`, `file:` and similar schemes
+ * can execute script or bypass same-origin assumptions when assigned to
+ * `window.location.href` — a server-controlled redirect (from a loader,
+ * middleware, form action response, or API route) must never be able to
+ * trigger them. Returns `null` for unsafe or unparseable inputs.
+ */
+declare function parseSafeNavigationUrl(location: string, base: string | URL): URL | null;
+declare function fetchPrachtRouteState(url: string, options?: {
+  signal?: AbortSignal;
+  useDataParam?: boolean;
+}): Promise<RouteStateResult>;
+//#endregion
+//#region src/runtime-middleware.d.ts
+type RedirectOptions = number | {
+  baseUrl?: string | URL;
+  method?: string;
+  request?: Request;
+  status?: number;
+};
+/**
+ * Convenience helper for middleware (and loaders/handlers) to short-circuit
+ * with a redirect Response. Validates the target's scheme and rejects
+ * CR/LF injection. Pass the current request (or method) when the default
+ * status should follow HTTP method safety: safe methods default to 302,
+ * unsafe methods default to 303.
+ *
+ * ```ts
+ * export const middleware: MiddlewareFn = async ({ request }, next) => {
+ *   if (!hasSession(request)) return redirect("/login", { request });
+ *   return next();
+ * };
+ * ```
+ */
+declare function redirect(target: string, options?: RedirectOptions): Response;
+//#endregion
+export { parseSafeNavigationUrl as a, Link as c, useLocation as d, useParams as f, createHref as h, fetchPrachtRouteState as i, LinkProps as l, useRouteData as m, redirect as n, Form as o, useRevalidate as p, RouteStateResult as r, FormProps as s, RedirectOptions as t, Location as u };

package/dist/server.d.mts

@@ -0,0 +1,5 @@
+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, a as matchApiRoute, 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, s as resolveApiRoutes, 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 { h as createHref, n as redirect, t as RedirectOptions } from "./runtime-middleware-aeBdgjYr.mjs";
+import { c as SerializedRouteError, n as PrachtRuntimeProvider, o as PrachtRuntimeDiagnosticPhase, s as PrachtRuntimeDiagnostics } from "./runtime-context-ytVd7GmZ.mjs";
+import { a as prerenderApp, c as applyDefaultSecurityHeaders, i as PrerenderResult, n as PrerenderAppOptions, o as HandlePrachtRequestOptions, r as PrerenderAppResult, s as handlePrachtRequest, t as ISGManifestEntry } from "./prerender-B8_CqYwd.mjs";
+export { type ApiConfig, type ApiRouteArgs, type ApiRouteHandler, type ApiRouteMatch, type ApiRouteModule, type BaseRouteArgs, type BuildHrefOptions, type DataModule, type ErrorBoundaryProps, type GroupDefinition, type GroupMeta, type HandlePrachtRequestOptions, type HeadArgs, type HeadAttributes, type HeadMetadata, type HeadScriptDescriptor, type HeadersArgs, type HrefArgs, type HrefFn, type HrefOptions, type HrefRouteDefinition, type HttpMethod, type ISGManifestEntry, type LoaderArgs, type LoaderData, type LoaderFn, type MiddlewareArgs, type MiddlewareFn, type MiddlewareModule, type MiddlewareNext, type ModuleImporter, type ModuleRef, type ModuleRegistry, type NavigateOptions, type PrachtApp, type PrachtAppConfig, PrachtHttpError, type PrachtRuntimeDiagnosticPhase, type PrachtRuntimeDiagnostics, PrachtRuntimeProvider, type PrefetchStrategy, type PrerenderAppOptions, type PrerenderAppResult, type PrerenderResult, 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 RouteTarget, type RouteTreeNode, type SearchParamPrimitive, type SearchParamValue, type SearchParamsInput, type SerializedRouteError, type ShellModule, type ShellProps, type TimeRevalidatePolicy, applyDefaultSecurityHeaders, buildHref, buildPathFromSegments, createHref, defineApp, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, timeRevalidate };

package/dist/server.mjs

@@ -0,0 +1,5 @@
+import { a as matchApiRoute, c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, s as resolveApiRoutes, t as buildHref, u as timeRevalidate } from "./app-BvC1uQG5.mjs";
+import { S as createHref, _ as applyDefaultSecurityHeaders, t as PrachtHttpError, u as redirect } from "./types-idmK5omD.mjs";
+import { t as PrachtRuntimeProvider } from "./runtime-context-B5pREhcM.mjs";
+import { n as handlePrachtRequest, t as prerenderApp } from "./prerender-D3E2H96p.mjs";
+export { PrachtHttpError, PrachtRuntimeProvider, applyDefaultSecurityHeaders, buildHref, buildPathFromSegments, createHref, defineApp, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, timeRevalidate };

package/dist/types-idmK5omD.mjs

@@ -0,0 +1,355 @@
+import { t as buildHref } from "./app-BvC1uQG5.mjs";
+import { c as navigateToClientLocation, h as SAFE_METHODS, l as parseSafeNavigationUrl, m as ROUTE_STATE_REQUEST_HEADER, p as ROUTE_STATE_CACHE_CONTROL, r as clearPrefetchCache, s as fetchPrachtRouteState } from "./prefetch-cache-DzP2Bj9H.mjs";
+import { n as RouteDataContext, s as deserializeRouteError } from "./runtime-context-B5pREhcM.mjs";
+import { h } from "preact";
+import { useContext } from "preact/hooks";
+//#region src/href.ts
+function createHref(routes) {
+	return ((routeId, options) => buildHref(routes, routeId, options));
+}
+//#endregion
+//#region src/runtime-headers.ts
+const HEADER_CRLF_RE = /[\r\n]/;
+/**
+* Reject header values containing CR/LF. Some runtimes (Node `undici`
+* Headers) throw on their own, but Web-runtime fetch implementations
+* vary, and a user-supplied `headers()` value is never trusted input.
+* Keeping the check here means response-splitting can't slip through on
+* any adapter.
+*/
+function assertSafeHeaderValue(name, value) {
+	if (HEADER_CRLF_RE.test(value)) throw new Error(`Refused to set header "${name}": value contains CR or LF`);
+}
+function applyHeaders(headers, init) {
+	for (const [key, value] of iterateHeaderInit(init)) assertSafeHeaderValue(key, value);
+	new Headers(init).forEach((value, key) => {
+		headers.set(key, value);
+	});
+}
+function* iterateHeaderInit(init) {
+	if (init instanceof Headers) {
+		for (const entry of init.entries()) yield entry;
+		return;
+	}
+	if (Array.isArray(init)) {
+		for (const entry of init) if (entry && entry.length >= 2) yield [entry[0], entry[1]];
+		return;
+	}
+	for (const [key, value] of Object.entries(init)) yield [key, value];
+}
+function applyDefaultSecurityHeaders(headers) {
+	if (!headers.has("permissions-policy")) headers.set("permissions-policy", "accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()");
+	if (!headers.has("referrer-policy")) headers.set("referrer-policy", "strict-origin-when-cross-origin");
+	if (!headers.has("x-content-type-options")) headers.set("x-content-type-options", "nosniff");
+	if (!headers.has("x-frame-options")) headers.set("x-frame-options", "SAMEORIGIN");
+	return headers;
+}
+function applySecurityAndRouteHeaders(headers, options) {
+	applyDefaultSecurityHeaders(headers);
+	if (options) {
+		appendVaryHeader(headers, ROUTE_STATE_REQUEST_HEADER);
+		if (options.isRouteStateRequest && !headers.has("cache-control")) headers.set("cache-control", ROUTE_STATE_CACHE_CONTROL);
+	}
+	return headers;
+}
+function withDefaultSecurityHeaders(response) {
+	const headers = new Headers(response.headers);
+	applySecurityAndRouteHeaders(headers);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function withRouteResponseHeaders(response, options) {
+	const headers = new Headers(response.headers);
+	applySecurityAndRouteHeaders(headers, options);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function appendVaryHeader(headers, value) {
+	const current = headers.get("vary");
+	if (!current) {
+		headers.set("vary", value);
+		return;
+	}
+	const values = current.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+	if (values.includes("*") || values.includes(value.toLowerCase())) return;
+	headers.set("vary", `${current}, ${value}`);
+}
+//#endregion
+//#region src/runtime-manifest.ts
+/** Strip leading `./` and `/` so all module paths share one canonical form. */
+function normalizeModulePath(path) {
+	return path.replace(/^\.?\//, "");
+}
+function buildSuffixIndex(manifest) {
+	const index = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(manifest)) {
+		const normalized = normalizeModulePath(key);
+		if (!normalized) continue;
+		if (!index.has(normalized)) index.set(normalized, key);
+		for (let i = normalized.indexOf("/"); i !== -1; i = normalized.indexOf("/", i + 1)) {
+			const suffix = normalized.slice(i + 1);
+			if (suffix && !index.has(suffix)) index.set(suffix, key);
+		}
+	}
+	return index;
+}
+const suffixIndexCache = /* @__PURE__ */ new WeakMap();
+function getSuffixIndex(manifest) {
+	let index = suffixIndexCache.get(manifest);
+	if (index) return index;
+	index = buildSuffixIndex(manifest);
+	suffixIndexCache.set(manifest, index);
+	return index;
+}
+function resolveManifestEntries(manifest, file) {
+	if (file in manifest) return manifest[file];
+	const resolved = getSuffixIndex(manifest).get(normalizeModulePath(file));
+	if (resolved) return manifest[resolved];
+}
+function resolvePageUrlsFromManifest(manifest, shellFile, routeFile) {
+	const urls = /* @__PURE__ */ new Set();
+	const add = (file) => {
+		const entries = resolveManifestEntries(manifest, file);
+		if (entries) for (const url of entries) urls.add(url);
+	};
+	if (shellFile) add(shellFile);
+	add(routeFile);
+	return [...urls];
+}
+function resolvePageCssUrls(cssManifest, shellFile, routeFile) {
+	if (!cssManifest) return [];
+	return resolvePageUrlsFromManifest(cssManifest, shellFile, routeFile);
+}
+function resolvePageJsUrls(jsManifest, shellFile, routeFile) {
+	if (!jsManifest) return [];
+	return resolvePageUrlsFromManifest(jsManifest, shellFile, routeFile);
+}
+async function resolveRegistryModule(modules, file) {
+	if (!modules) return void 0;
+	if (file in modules) return modules[file]();
+	const resolved = getSuffixIndex(modules).get(normalizeModulePath(file));
+	if (resolved) return modules[resolved]();
+}
+async function resolveDataFunctions(route, routeModule, registry) {
+	let loader = routeModule?.loader;
+	let loaderFile = routeModule?.loader ? route.file : void 0;
+	if (route.loaderFile) {
+		const dataModule = await resolveRegistryModule(registry.dataModules, route.loaderFile);
+		if (dataModule?.loader) {
+			loader = dataModule.loader;
+			loaderFile = route.loaderFile;
+		}
+	}
+	return {
+		loader,
+		loaderFile
+	};
+}
+//#endregion
+//#region src/runtime-middleware.ts
+const DEFAULT_REDIRECT_STATUS_SAFE = 302;
+const DEFAULT_REDIRECT_STATUS_UNSAFE = 303;
+const REDIRECT_VALIDATION_BASE = "https://invalid.pracht.local/";
+/**
+* Build a safe redirect response from middleware/loader output. Rejects
+* non-http(s) schemes (no `javascript:`/`data:`/etc.) and CR/LF injection
+* against the `Location` header. When status is omitted, non-GET/HEAD
+* requests default to 303 so the browser does not resend the body to the
+* redirect target; safe methods default to 302.
+*
+* The original `target` string is preserved on success (relative paths
+* stay relative) — we only parse it to validate scheme, not to rewrite
+* it. Both the original input and its resolved URL must be CR/LF-free.
+*/
+function buildRedirectResponse(target, options) {
+	if (/[\r\n]/.test(target)) throw new Error("Refused redirect target containing CR/LF");
+	if (!parseSafeNavigationUrl(target, options.baseUrl)) throw new Error("Refused unsafe redirect target");
+	const method = (options.method ?? "GET").toUpperCase();
+	const defaultStatus = SAFE_METHODS.has(method) ? DEFAULT_REDIRECT_STATUS_SAFE : DEFAULT_REDIRECT_STATUS_UNSAFE;
+	const status = options.status ?? defaultStatus;
+	return new Response(null, {
+		status,
+		headers: { location: target }
+	});
+}
+/**
+* Convenience helper for middleware (and loaders/handlers) to short-circuit
+* with a redirect Response. Validates the target's scheme and rejects
+* CR/LF injection. Pass the current request (or method) when the default
+* status should follow HTTP method safety: safe methods default to 302,
+* unsafe methods default to 303.
+*
+* ```ts
+* export const middleware: MiddlewareFn = async ({ request }, next) => {
+*   if (!hasSession(request)) return redirect("/login", { request });
+*   return next();
+* };
+* ```
+*/
+function redirect(target, options = {}) {
+	if (typeof options === "number") return buildRedirectResponse(target, {
+		baseUrl: REDIRECT_VALIDATION_BASE,
+		status: options
+	});
+	return buildRedirectResponse(target, {
+		baseUrl: options.baseUrl ?? options.request?.url ?? REDIRECT_VALIDATION_BASE,
+		method: options.method ?? options.request?.method,
+		status: options.status
+	});
+}
+/**
+* Run the middleware chain wrap-around-style. Each middleware receives
+* `next` and may call it at most once. Calling `next()` invokes the rest
+* of the chain (downstream middleware then `terminal`) and resolves to
+* the final `Response`. A middleware that returns without calling `next()`
+* short-circuits with whatever Response it returned.
+*
+* Module imports are kicked off concurrently up front; execution stays
+* sequential because middleware may mutate `args.context` and ordering
+* is part of the public contract.
+*/
+async function runMiddlewareChain(options) {
+	const { middlewareFiles, terminal } = options;
+	if (middlewareFiles.length === 0) return terminal();
+	const modulePromises = middlewareFiles.map((mwFile) => resolveRegistryModule(options.registry.middlewareModules, mwFile));
+	for (const p of modulePromises) p.catch(() => {});
+	const dispatch = async (i) => {
+		if (i >= middlewareFiles.length) return terminal();
+		const mwModule = await modulePromises[i];
+		if (!mwModule?.middleware) return dispatch(i + 1);
+		let calledNext = false;
+		const next = () => {
+			if (calledNext) throw new Error(`Middleware "${middlewareFiles[i]}" called next() multiple times`);
+			calledNext = true;
+			return dispatch(i + 1);
+		};
+		const args = {
+			request: options.request,
+			params: options.params,
+			context: options.context,
+			signal: options.signal,
+			url: options.url,
+			route: options.route
+		};
+		const response = await mwModule.middleware(args, next);
+		if (!(response instanceof Response)) throw new Error(`Middleware "${middlewareFiles[i]}" did not return a Response. Middleware must return the result of next() or a short-circuit Response.`);
+		return response;
+	};
+	return dispatch(0);
+}
+async function mergeHeadMetadata(shellModule, routeModule, routeArgs, data) {
+	const [shellHead, routeHead] = await Promise.all([shellModule?.head ? shellModule.head(routeArgs) : Promise.resolve({}), routeModule?.head ? routeModule.head({
+		...routeArgs,
+		data
+	}) : Promise.resolve({})]);
+	return {
+		title: routeHead.title ?? shellHead.title,
+		lang: routeHead.lang ?? shellHead.lang,
+		meta: [...shellHead.meta ?? [], ...routeHead.meta ?? []],
+		link: [...shellHead.link ?? [], ...routeHead.link ?? []],
+		script: [...shellHead.script ?? [], ...routeHead.script ?? []]
+	};
+}
+async function mergeDocumentHeaders(shellModule, routeModule, routeArgs, data) {
+	const headers = new Headers();
+	const [shellHeaders, routeHeaders] = await Promise.all([shellModule?.headers ? shellModule.headers(routeArgs) : Promise.resolve(void 0), routeModule?.headers ? routeModule.headers({
+		...routeArgs,
+		data
+	}) : Promise.resolve(void 0)]);
+	if (shellHeaders) applyHeaders(headers, shellHeaders);
+	if (routeHeaders) applyHeaders(headers, routeHeaders);
+	return headers;
+}
+//#endregion
+//#region src/runtime-hooks.ts
+function useRouteData() {
+	return useContext(RouteDataContext)?.data;
+}
+function useLocation() {
+	return parseLocation(useContext(RouteDataContext)?.url ?? (typeof window !== "undefined" ? window.location.pathname + window.location.search : "/"));
+}
+function useParams() {
+	return useContext(RouteDataContext)?.params ?? {};
+}
+function useRevalidate() {
+	const runtime = useContext(RouteDataContext);
+	return async () => {
+		if (typeof window === "undefined") return;
+		const result = await fetchPrachtRouteState(runtime?.url || window.location.pathname + window.location.search);
+		if (result.type === "redirect") {
+			await navigateToClientLocation(result.location);
+			return;
+		}
+		if (result.type === "error") throw deserializeRouteError(result.error);
+		runtime?.setData(result.data);
+		return result.data;
+	};
+}
+function Link(props) {
+	const routes = useContext(RouteDataContext)?.routes ?? globalThis.__PRACHT_ROUTE_DEFINITIONS__;
+	if (!routes) throw new Error("<Link route=...> must render inside a pracht route tree.");
+	const { route, params, search, hash, ...anchorProps } = props;
+	return h("a", {
+		...anchorProps,
+		href: buildHref(routes, route, {
+			params,
+			search,
+			hash
+		})
+	});
+}
+function Form(props) {
+	const { onSubmit, method, ...rest } = props;
+	return h("form", {
+		...rest,
+		method,
+		onSubmit: async (event) => {
+			onSubmit?.(event);
+			if (event.defaultPrevented) return;
+			const form = event.currentTarget;
+			if (!(form instanceof HTMLFormElement)) return;
+			const formMethod = (method ?? form.method ?? "post").toUpperCase();
+			if (SAFE_METHODS.has(formMethod)) return;
+			event.preventDefault();
+			clearPrefetchCache();
+			const response = await fetch(props.action ?? form.action, {
+				method: formMethod,
+				body: new FormData(form),
+				redirect: "manual"
+			});
+			if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+				const location = response.headers.get("location");
+				if (location) {
+					await navigateToClientLocation(location);
+					return;
+				}
+				window.location.href = props.action ?? form.action;
+			}
+		}
+	});
+}
+function parseLocation(value) {
+	const url = new URL(value, "http://pracht.local");
+	return {
+		pathname: url.pathname,
+		search: url.search
+	};
+}
+//#endregion
+//#region src/types.ts
+var PrachtHttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "PrachtHttpError";
+		this.status = status;
+	}
+};
+//#endregion
+export { createHref as S, applyDefaultSecurityHeaders as _, useParams as a, withDefaultSecurityHeaders as b, mergeDocumentHeaders as c, runMiddlewareChain as d, resolveDataFunctions as f, appendVaryHeader as g, resolveRegistryModule as h, useLocation as i, mergeHeadMetadata as l, resolvePageJsUrls as m, Form as n, useRevalidate as o, resolvePageCssUrls as p, Link as r, useRouteData as s, PrachtHttpError as t, redirect as u, applyHeaders as v, withRouteResponseHeaders as x, applySecurityAndRouteHeaders as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pracht/core",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Core runtime for Pracht, a full-stack Preact framework with per-route SSR, SSG, ISG, SPA, loaders, and API routes.",
   "keywords": [
     "pracht",
@@ -31,8 +31,25 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
+      "browser": "./dist/browser.mjs",
       "default": "./dist/index.mjs"
     },
+    "./browser": {
+      "types": "./dist/browser.d.mts",
+      "default": "./dist/browser.mjs"
+    },
+    "./client": {
+      "types": "./dist/client.d.mts",
+      "default": "./dist/client.mjs"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.mts",
+      "default": "./dist/manifest.mjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.mts",
+      "default": "./dist/server.mjs"
+    },
     "./error-overlay": {
       "types": "./dist/error-overlay.d.mts",
       "default": "./dist/error-overlay.mjs"
@@ -42,7 +59,7 @@
     "provenance": true
   },
   "dependencies": {
-    "preact-suspense": "^0.2.0"
+    "preact-suspense": "^0.3.0"
   },
   "peerDependencies": {
     "preact": "^10.0.0",