@k8ordo/framework 0.1.0 → 1.1.0

package/README.md

@@ -33,12 +33,13 @@ dependencies in either mode: the build bundles what the application runs.
 
 <!-- peers -->
 
-| Package          | Version | Required | Needed for                                 |
-| ---------------- | ------- | -------- | ------------------------------------------ |
-| `@k8ordo/router` | ^1.0.0  | yes      | routing, re-exported by the framework      |
-| `react`          | ≥19.3.0 | yes      | rendering                                  |
-| `react-dom`      | ≥19.3.0 | yes      | rendering                                  |
-| `vite`           | ≥8.0.0  | yes      | the build (`framework()` is a Vite plugin) |
+| Package               | Version  | Required | Needed for                                 |
+| --------------------- | -------- | -------- | ------------------------------------------ |
+| `@k8ordo/router`      | ^1.1.0   | yes      | routing, re-exported by the framework      |
+| `react`               | ≥19.3.0  | yes      | rendering                                  |
+| `react-dom`           | ≥19.3.0  | yes      | rendering                                  |
+| `vite`                | ≥8.0.0   | yes      | the build (`framework()` is a Vite plugin) |
+| `oxc-transform-react` | ^0.152.0 | optional | `reactCompiler: true` (React Compiler)     |
 
 <!-- /peers -->
 
@@ -134,7 +135,9 @@ A value `paths` does not list — a product added after the build — is
 answered by a `fallback.tsx` beside the page: the build writes it once as a
 shell, the layouts in HTML, and the browser draws the page from the URL.
 The build also writes the `_redirects` through which Netlify and Cloudflare
-reach the shell, and `vercel()` the same rewrites for Vercel.
+reach the shell, and `vercel()` the same rewrites for Vercel — around them,
+routes of your own: headers on every page, redirects, a rewrite decided by
+`Accept`, a proxy to another origin.
 
 ## AI Agent Documentation
 
@@ -154,7 +157,10 @@ error.tsx, loading.tsx, fallback.tsx, redirect.ts, guard.ts and route.ts;
 components go in `src/components/` and every other module (Server Actions,
 schemas, state definitions, data, helpers) in `src/lib/`, since a
 `_`-prefixed directory there is a URL segment, not a private one. Never
-edit `.k8ordo/` — it is generated. Import from `@k8ordo/framework` (never
+edit `.k8ordo/` — it is generated, with the `Register` augmentations: the
+route table's, and `@k8ordo/i18n`'s when `src/i18n.ts` exports the locale
+set by the name `locales` (write that one by hand only when the set lives
+elsewhere). Import from `@k8ordo/framework` (never
 `@k8ordo/router`), and the request API from `@k8ordo/framework/server`,
 which `mode: 'static'` refuses. Build links with `href()`; search params
 are `@k8ordo/state`'s.

package/dist/generated.mjs

@@ -1,2 +1 @@
-import { defineRoutes } from "@k8ordo/router";
-export { defineRoutes };
+export { defineRoutes } from "@k8ordo/router";

package/dist/index.mjs

@@ -1,2 +1 @@
-import { bindParams, href, isNotFound, matchPath, navigateTo, normalizePathname, notFound, useMatch, usePathname, usePendingPathname, withBase } from "@k8ordo/router";
-export { bindParams, href, isNotFound, matchPath, navigateTo, normalizePathname, notFound, useMatch, usePathname, usePendingPathname, withBase };
+export { bindParams, href, isNotFound, matchPath, navigateTo, normalizePathname, notFound, useMatch, usePathname, usePendingPathname, withBase } from "@k8ordo/router";

package/dist/runtime/app-router.d.mts

@@ -1,6 +1,10 @@
+import { Payload } from "./payload.mjs";
 import { ReactNode } from "react";
 //#region src/runtime/app-router.d.ts
 export declare const setDocumentClient: (client: string) => void;
+/** What a Server Action's answer does to the document, once it is read. */
+export declare const answerAction: (payload: Payload) => Promise<unknown>;
+export declare const setPayloadReader: (read: (stream: ReadableStream<Uint8Array>) => Promise<Payload>) => void;
 /**
  * The client half under the framework: the tree comes from the server, so
  * there is no route table in the browser at all — only navigation. The

package/dist/runtime/app-router.mjs

@@ -1,21 +1,19 @@
 "use client";
-import { ACTION_ID_HEADER } from "./payload.mjs";
 import { payloadPathFor } from "./payload-path.mjs";
 import { ShowNotFound } from "./fallback-boundary.mjs";
 import { isPayload } from "./is-payload.mjs";
 import { createPrefetchCache, prefetchTargetOf } from "./prefetch.mjs";
 import { Recover, markNavigated, reloadInstead } from "./recover.mjs";
 import { NavigationGeneration, PathnameProvider, useInterceptedNavigation, withoutBase } from "@k8ordo/router";
-import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { startTransition, useDeferredValue, useEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/runtime/app-router.tsx
 /**
 * Where a Server Action's answer lands. The callback has to be registered
 * before any client component can call one, which is earlier than a component
-* can offer its own setter — so the wiring is here and the mounted router
-* lends it a way to apply what comes back, and to drop the pages it fetched
-* ahead, which the action may have changed.
+* can offer its own setter — so `answerAction` is module-level and the
+* mounted router lends it a way to apply what comes back, and to drop the
+* pages it fetched ahead, which the action may have changed.
 */
 let mounted = null;
 /**
@@ -36,13 +34,8 @@ const setDocumentClient = (client) => {
 * document load brings the script that can.
 */
 const canRender = (payload) => payload.client === documentClient;
-setServerCallback(async (id, args) => {
-	const temporaryReferences = createTemporaryReferenceSet();
-	const payload = await createFromFetch(fetch(location.href, {
-		method: "POST",
-		headers: { [ACTION_ID_HEADER]: id },
-		body: await encodeReply(args, { temporaryReferences })
-	}), { temporaryReferences });
+/** What a Server Action's answer does to the document, once it is read. */
+const answerAction = async (payload) => {
 	mounted?.forgetPrefetched();
 	if (payload.redirect !== void 0) {
 		await navigation.navigate(payload.redirect).finished;
@@ -51,7 +44,11 @@ setServerCallback(async (id, args) => {
 	if (!canRender(payload)) return reloadInstead();
 	mounted?.apply(payload);
 	return payload.returnValue;
-});
+};
+let readPayload = () => Promise.reject(/* @__PURE__ */ new Error("k8ordo: payloads are read in the browser only"));
+const setPayloadReader = (read) => {
+	readPayload = read;
+};
 /**
 * The request each fetched payload is still streaming in on. A payload
 * resolves once its top arrives, and a page that awaits its data arrives
@@ -77,7 +74,7 @@ const fetchPage = async (payloadPath, signal) => {
 	signal.addEventListener("abort", cancel, { once: true });
 	const response = await fetch(payloadPath, { signal: request.signal });
 	if (!isPayload(response)) return null;
-	const payload = await createFromReadableStream(response.body);
+	const payload = await readPayload(response.body);
 	streams.set(payload, {
 		cancel: () => {
 			request.abort();
@@ -272,4 +269,4 @@ function AppRouter({ pathname, search, tree, notFound }) {
 	});
 }
 //#endregion
-export { AppRouter, setDocumentClient };
+export { AppRouter, answerAction, setDocumentClient, setPayloadReader };

package/dist/runtime/browser-payloads.d.mts

@@ -0,0 +1,8 @@
+//#region src/runtime/browser-payloads.d.ts
+/**
+ * Hands app-router the browser's Flight client: how a fetched payload is
+ * read, and where a Server Action is sent. Called by the browser entry
+ * before anything renders.
+ */
+export declare const connectAppRouter: () => void;
+//#endregion

package/dist/runtime/browser-payloads.mjs

@@ -0,0 +1,23 @@
+import { ACTION_ID_HEADER } from "./payload.mjs";
+import { answerAction, setPayloadReader } from "./app-router.mjs";
+import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
+//#region src/runtime/browser-payloads.ts
+/**
+* Hands app-router the browser's Flight client: how a fetched payload is
+* read, and where a Server Action is sent. Called by the browser entry
+* before anything renders.
+*/
+const connectAppRouter = () => {
+	setPayloadReader((stream) => createFromReadableStream(stream));
+	setServerCallback(async (id, args) => {
+		const temporaryReferences = createTemporaryReferenceSet();
+		const payload = await createFromFetch(fetch(location.href, {
+			method: "POST",
+			headers: { [ACTION_ID_HEADER]: id },
+			body: await encodeReply(args, { temporaryReferences })
+		}), { temporaryReferences });
+		return answerAction(payload);
+	});
+};
+//#endregion
+export { connectAppRouter };

package/dist/runtime/entry.browser.mjs

@@ -1,11 +1,13 @@
 import { AppRouter, setDocumentClient } from "./app-router.mjs";
+import { connectAppRouter } from "./browser-payloads.mjs";
 import { mount } from "./mount.mjs";
 import { reportCaught } from "./page-boundary.mjs";
 import { whenRevealed } from "./revealed.mjs";
-import { createFromReadableStream } from "@vitejs/plugin-rsc/browser";
 import { jsx } from "react/jsx-runtime";
+import { createFromReadableStream } from "@vitejs/plugin-rsc/browser";
 import { rscStream } from "rsc-html-stream/client";
 //#region src/runtime/entry.browser.tsx
+connectAppRouter();
 const payload = await createFromReadableStream(rscStream);
 setDocumentClient(payload.client);
 await whenRevealed();

package/dist/runtime/fallback-boundary.d.mts

@@ -39,4 +39,5 @@ export declare class FallbackCatch extends Component<CatchProps, CatchState> {
 export declare const FallbackBoundary: ({ children }: {
   children: ReactNode;
 }) => ReactNode;
-//#endregion
+//#endregion
+export {};

package/dist/runtime/guard.d.mts

@@ -26,4 +26,5 @@ type AnyGuard = (context: {
  * inner guard assume what an outer one checked.
  */
 export declare const runGuards: (guards: readonly AnyGuard[], context: Parameters<AnyGuard>[0]) => Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/runtime/page-boundary.d.mts

@@ -36,4 +36,5 @@ export declare class PageBoundary extends Component<{
   componentDidCatch(error: unknown): void;
   render(): ReactNode;
 }
-//#endregion
+//#endregion
+export {};

package/dist/runtime/params.d.mts

@@ -46,4 +46,5 @@ export declare const parseParams: (schemas: readonly ParamsSchema[], raw: Readon
  * says.
  */
 export declare const parseCatchAllParams: (schemas: readonly ParamsSchema[], raw: Readonly<Record<string, string>>) => ParsedParams;
-//#endregion
+//#endregion
+export {};

package/dist/runtime/redirect-file.d.mts

@@ -18,4 +18,5 @@ type ResolvedRedirect = {
  * the table normalizes it, so `/old/` is `/old` here too.
  */
 export declare const resolveRedirects: (declared: Readonly<Record<string, RedirectTarget>>) => ((pattern: string, pathname: string) => ResolvedRedirect | null);
-//#endregion
+//#endregion
+export {};

package/dist/runtime/redirect.d.mts

@@ -25,4 +25,5 @@ export declare class Redirect extends Error {
  */
 export declare const redirect: (to: string) => never;
 export declare const isRedirect: (value: unknown) => value is Redirect;
-//#endregion
+//#endregion
+export {};

package/dist/runtime/route.d.mts

@@ -32,4 +32,5 @@ export declare const methodNotAllowed: (module: AnyRouteModule) => Response;
  * answers the request as much as a guard does.
  */
 export declare const runRoute: ({ handler, headOnly }: RouteAnswer, context: RouteContext) => Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/serve.mjs

@@ -120,7 +120,7 @@ const sendAnswer = async (incoming, response, result) => {
 	const encoding = compressible ? negotiateEncoding(incoming.headers["accept-encoding"], ENCODINGS) : null;
 	if (compressible) {
 		const vary = result.headers.get("vary");
-		headers["vary"] = vary === null ? "Accept-Encoding" : `${vary}, Accept-Encoding`;
+		headers.vary = vary === null ? "Accept-Encoding" : `${vary}, Accept-Encoding`;
 	}
 	if (encoding !== null) {
 		headers["content-encoding"] = encoding;

package/dist/static-BaGdAVF1.d.mts

@@ -0,0 +1,66 @@
+import { Plugin, PluginOption } from "vite";
+import "react";
+//#region ../framework-engine/dist/host.d.mts
+/** What `framework()` takes whatever the mode. */
+type EngineOptions = {
+  /** Where the route files live, relative to the project root. */
+  readonly routesDir?: string;
+  /**
+   * Compiles the client components with React Compiler — the Rust one,
+   * through `@vitejs/plugin-react`'s `compiler`, which needs
+   * `oxc-transform-react` installed. Server components are left as they are.
+   */
+  readonly reactCompiler?: boolean;
+};
+//#endregion
+//#region src/documents.d.ts
+/**
+ * The `Content-Security-Policy` an application wants on every page, as
+ * directives and their sources. The build writes it into each page's
+ * `<meta>`, with the hashes of that page's signed inline scripts added.
+ */
+type ContentSecurityPolicy = Readonly<Record<string, readonly string[]>>;
+//#endregion
+//#region src/static.d.ts
+type StaticOptions = EngineOptions & {
+  /**
+   * Every route rendered at build time and written to files; no server at
+   * run time, so nothing that answers a request (Server Actions, guards, the
+   * request API) builds.
+   */
+  readonly mode: 'static';
+  /**
+   * Pathnames for routes with parameters, in the table's terms — without
+   * Vite's `base`. Static rendering cannot invent them, and a build that
+   * quietly skipped half the site would be worse than one that refuses.
+   *
+   * The patterns that need covering are handed in, so a site whose parameter
+   * takes the same values everywhere — a locale segment, say — expands them
+   * rather than listing every page twice.
+   *
+   * For a page with a `fallback.tsx` beside it, a pathname that still holds
+   * a parameter (`/ja/posts/:id`) is where its shell stands: the values the
+   * build did not write are answered there. Without one, the bare pattern
+   * is the shell's location.
+   */
+  readonly paths?: (patterns: readonly string[]) => readonly string[] | Promise<readonly string[]>;
+  /**
+   * The origin the site is served from — `https://example.com`. With it the
+   * build also writes `sitemap.xml`, listing every page it rendered at its
+   * URL, Vite's `base` included; without it, no sitemap, because a sitemap of
+   * relative URLs is not one.
+   */
+  readonly site?: string;
+  /**
+   * The `Content-Security-Policy` every page carries, as directives and
+   * their sources. The framework decides no policy: it writes this one into
+   * each page's `<meta>`, adding to `script-src` the hashes of its own inline
+   * scripts on that page — the payload and React's. An inline script of the
+   * application's is allowed by its hash here, as
+   * `colorSchemeScriptHash()` gives `@k8ordo/color-scheme`'s. Without it, no
+   * policy is written.
+   */
+  readonly csp?: ContentSecurityPolicy;
+};
+//#endregion
+export { ContentSecurityPolicy as n, EngineOptions as r, StaticOptions as t };

package/dist/vercel.d.mts

@@ -1,4 +1,46 @@
+import "./static-BaGdAVF1.mjs";
 import { Plugin } from "vite";
+//#region src/vercel-output.d.ts
+/**
+ * A route as Vercel's Build Output API (v3) reads it, written to
+ * `.vercel/output/config.json` as given — the fields an application needs.
+ */
+type VercelRoute = {
+  /**
+   * A regular expression Vercel matches against the whole pathname, the
+   * query left out — `^/posts/` does not match `/posts/first`, `^/posts/.+$`
+   * does — regardless of case unless `caseSensitive`.
+   */
+  readonly src: string;
+  /** A path in the deployment, or a URL elsewhere. */
+  readonly dest?: string;
+  readonly status?: number;
+  readonly headers?: Readonly<Record<string, string>>;
+  /** Keep matching the routes after this one: a route that only adds headers. */
+  readonly continue?: boolean;
+  /**
+   * Look for `dest` among the files; when none is there, go on with `dest`
+   * as the pathname.
+   */
+  readonly check?: boolean;
+  readonly caseSensitive?: boolean;
+  readonly has?: ReadonlyArray<{
+    readonly type: 'header';
+    /** Lowercase, as Vercel compares it. */
+    readonly key: string;
+    readonly value?: string;
+  }>;
+};
+type VercelOptions = {
+  /** Under `mode: 'static'`, routes tried before any file. */
+  readonly beforeFiles?: readonly VercelRoute[];
+  /**
+   * Under `mode: 'static'`, routes tried once neither a file nor a shell
+   * answered, before `404.html`.
+   */
+  readonly beforeNotFound?: readonly VercelRoute[];
+};
+//#endregion
 //#region src/vercel.d.ts
 /**
  * Deploys the application to Vercel: after `vite build`, the build is also
@@ -9,7 +51,11 @@ import { Plugin } from "vite";
  * nothing but its own directory, which is all the handler needs: server mode
  * builds it with every dependency bundled in. Under `mode: 'static'` there is
  * no function, only the rewrites that answer a value the build did not write
- * with its shell — Vercel never reads `_redirects`.
+ * with its shell — Vercel never reads `_redirects` — and the application's
+ * own routes around them, written as given: `beforeFiles` ahead of every
+ * file, `beforeNotFound` ahead of `404.html`. A file a `route.ts` wrote is
+ * served with the `Content-Type` its `GET` answered.
  */
-export declare const vercel: () => Plugin;
-//#endregion
+export declare const vercel: (options?: VercelOptions) => Plugin;
+//#endregion
+export type { VercelOptions, VercelRoute };

package/dist/vercel.mjs

@@ -7,12 +7,17 @@ import path from "node:path";
 const FUNCTION = "handler";
 /**
 * The hashed assets are marked immutable in the `hit` phase — only once a
-* file answered — so a missing one is never cached for a year.
+* file answered — so a missing one is never cached for a year. `src` spells
+* out the rest of the path, since Vercel matches it against the whole path
+* and a prefix alone matches no file; `important`, as `@vercel/next` marks
+* its own hashed files, keeps another route's `Cache-Control` from taking
+* its place.
 */
 const immutableAssets = (base) => ({
-	src: `^${RegExp.escape(`${base}assets/`)}`,
+	src: `^${RegExp.escape(`${base}assets/`)}.+$`,
 	headers: { "cache-control": "public, max-age=31536000, immutable" },
-	continue: true
+	continue: true,
+	important: true
 });
 /** Files first, and whatever names none goes to the handler. */
 const configFor = (base) => ({
@@ -57,15 +62,21 @@ const routeOf = (rule) => {
 	};
 };
 /**
-* Files first; only what names none is rewritten — a value the build did
-* not write to its shell, the payload URL of a built URL that is not a page
-* to HTML — and what nothing rewrote is the build's `404.html`.
+* The application's `beforeFiles`, then the files; only what names none is
+* rewritten — a value the build did not write to its shell, the payload URL
+* of a built URL that is not a page to HTML — and what nothing rewrote goes
+* through the application's `beforeNotFound` to the build's `404.html`. A
+* file a route.ts wrote is served with the type its `GET` answered, even
+* where the extension says the same, so no file is left to the types Vercel
+* gives an extension.
 */
-const staticConfigFor = ({ base, rewrites, notFound }) => ({
+const staticConfigFor = ({ base, rewrites, notFound, types }, { beforeFiles = [], beforeNotFound = [] }) => ({
 	version: 3,
 	routes: [
+		...beforeFiles,
 		{ handle: "filesystem" },
 		...rewrites.map((rule) => routeOf(rule)),
+		...beforeNotFound,
 		...notFound ? [{
 			src: "^/.*$",
 			dest: withBase("/404.html", base),
@@ -73,7 +84,8 @@ const staticConfigFor = ({ base, rewrites, notFound }) => ({
 		}] : [],
 		{ handle: "hit" },
 		immutableAssets(base)
-	]
+	],
+	...types.size === 0 ? {} : { overrides: Object.fromEntries([...types].toSorted(([a], [b]) => a < b ? -1 : 1).map(([file, contentType]) => [withBase(`/${file}`, base).slice(1), { contentType }])) }
 });
 /**
 * A Node.js function that hands Vercel the handler as it is: the launcher
@@ -129,10 +141,11 @@ const writeVercelOutput = async (root, dirs, base) => {
 /**
 * A static build laid out as Vercel's Build Output API (v3) reads it: the
 * client build as static files at Vite's `base`, and the rewrites a host
-* applies once no file answered as routes — no function. `_redirects` stays
-* behind: Vercel never reads it, and would serve it as a file.
+* applies once no file answered as routes, around them the application's
+* own — no function. `_redirects` stays behind: Vercel never reads it, and
+* would serve it as a file.
 */
-const writeStaticVercelOutput = async (output) => {
+const writeStaticVercelOutput = async (output, routes = {}) => {
 	const dir = path.join(output.root, ".vercel", "output");
 	await rm(dir, {
 		recursive: true,
@@ -143,7 +156,7 @@ const writeStaticVercelOutput = async (output) => {
 		recursive: true,
 		filter: (source) => source !== redirects
 	});
-	await writeFile(path.join(dir, "config.json"), json(staticConfigFor(output)));
+	await writeFile(path.join(dir, "config.json"), json(staticConfigFor(output, routes)));
 };
 //#endregion
 //#region src/vercel.ts
@@ -156,9 +169,14 @@ const writeStaticVercelOutput = async (output) => {
 * nothing but its own directory, which is all the handler needs: server mode
 * builds it with every dependency bundled in. Under `mode: 'static'` there is
 * no function, only the rewrites that answer a value the build did not write
-* with its shell — Vercel never reads `_redirects`.
+* with its shell — Vercel never reads `_redirects` — and the application's
+* own routes around them, written as given: `beforeFiles` ahead of every
+* file, `beforeNotFound` ahead of `404.html`. A file a `route.ts` wrote is
+* served with the `Content-Type` its `GET` answered.
 */
-const vercel = () => {
+const vercel = (options = {}) => {
+	const { beforeFiles, beforeNotFound } = options;
+	for (const route of [...beforeFiles ?? [], ...beforeNotFound ?? []]) for (const { key } of route.has ?? []) if (key !== key.toLowerCase()) throw new Error(`vercel() route ${route.src} has the header key "${key}" — write it lowercase ("${key.toLowerCase()}"), as Vercel compares it`);
 	let isStatic = false;
 	let logger;
 	return {
@@ -167,9 +185,10 @@ const vercel = () => {
 		configResolved(config) {
 			isStatic = config.plugins.some((plugin) => plugin.name === "k8ordo:static");
 			({logger} = config);
+			if (!isStatic && (beforeFiles !== void 0 || beforeNotFound !== void 0)) throw new Error("vercel() takes beforeFiles and beforeNotFound under mode: 'static' only — under mode: 'server' the handler answers every URL no file names");
 		},
 		api: { async writeStatic(output) {
-			await writeStaticVercelOutput(output);
+			await writeStaticVercelOutput(output, options);
 			logger?.info("k8ordo: wrote .vercel/output");
 		} },
 		buildApp: {

package/dist/vite.d.mts

@@ -1,62 +1,5 @@
-import { Plugin, PluginOption } from "vite";
-import "react";
-//#region ../framework-engine/dist/host.d.mts
-/** What `framework()` takes whatever the mode. */
-type EngineOptions = {
-  /** Where the route files live, relative to the project root. */
-  readonly routesDir?: string;
-};
-//#endregion
-//#region src/documents.d.ts
-/**
- * The `Content-Security-Policy` an application wants on every page, as
- * directives and their sources. The build writes it into each page's
- * `<meta>`, with the hashes of that page's signed inline scripts added.
- */
-type ContentSecurityPolicy = Readonly<Record<string, readonly string[]>>;
-//#endregion
-//#region src/static.d.ts
-type StaticOptions = EngineOptions & {
-  /**
-   * Every route rendered at build time and written to files; no server at
-   * run time, so nothing that answers a request (Server Actions, guards, the
-   * request API) builds.
-   */
-  readonly mode: 'static';
-  /**
-   * Pathnames for routes with parameters, in the table's terms — without
-   * Vite's `base`. Static rendering cannot invent them, and a build that
-   * quietly skipped half the site would be worse than one that refuses.
-   *
-   * The patterns that need covering are handed in, so a site whose parameter
-   * takes the same values everywhere — a locale segment, say — expands them
-   * rather than listing every page twice.
-   *
-   * For a page with a `fallback.tsx` beside it, a pathname that still holds
-   * a parameter (`/ja/posts/:id`) is where its shell stands: the values the
-   * build did not write are answered there. Without one, the bare pattern
-   * is the shell's location.
-   */
-  readonly paths?: (patterns: readonly string[]) => readonly string[] | Promise<readonly string[]>;
-  /**
-   * The origin the site is served from — `https://example.com`. With it the
-   * build also writes `sitemap.xml`, listing every page it rendered at its
-   * URL, Vite's `base` included; without it, no sitemap, because a sitemap of
-   * relative URLs is not one.
-   */
-  readonly site?: string;
-  /**
-   * The `Content-Security-Policy` every page carries, as directives and
-   * their sources. The framework decides no policy: it writes this one into
-   * each page's `<meta>`, adding to `script-src` the hashes of its own inline
-   * scripts on that page — the payload and React's. An inline script of the
-   * application's is allowed by its hash here, as
-   * `colorSchemeScriptHash()` gives `@k8ordo/color-scheme`'s. Without it, no
-   * policy is written.
-   */
-  readonly csp?: ContentSecurityPolicy;
-};
-//#endregion
+import { n as ContentSecurityPolicy, r as EngineOptions, t as StaticOptions } from "./static-BaGdAVF1.mjs";
+import { PluginOption } from "vite";
 //#region src/vite.d.ts
 export type ServerOptions = EngineOptions & {
   /**