@rivetjs/router 0.0.0-stage → 0.1.0-alpha.0

package/build/dev-errors.d.ts

@@ -0,0 +1,19 @@
+import type { ViteDevServer } from "vite";
+import type { DevSymbolInfo } from "@rivetjs/compiler/vite";
+import type { RouteTable } from "./routes.js";
+import type { AppHandler, ErrorInfo } from "../server/handler.js";
+/** A resume symbol the compiler plugin compiled for dev SSR (`DevResume.describe`). */
+type Describe = (id: string) => DevSymbolInfo | undefined;
+/**
+ * Dev `onError`: source-map the stack, log it, send it to Vite's overlay (open pages, e.g. during
+ * client navigation) and remember it for the request's dev error page.
+ */
+export declare function devReport(server: ViteDevServer, table: () => RouteTable, routesPath: string, describe?: Describe): (error: unknown, _request: Request, info?: ErrorInfo) => void;
+/** Browser errors forwarded by the dev entry (`import.meta.hot.send("rivet:client-error")`) open that page's overlay. */
+export declare function listenClientErrors(server: ViteDevServer): void;
+/**
+ * Wrap the dev app handler: a reported 5xx page gets the dev error page (no `_error` view) or the
+ * overlay over the app's `_error` view; an unmatched URL without a `_404` lists the routes.
+ */
+export declare function devHandler(handler: AppHandler, server: ViteDevServer, table: () => RouteTable): AppHandler;
+export {};

package/build/dev-errors.js

@@ -0,0 +1,236 @@
+// Dev server error surfaces (`vite serve` only; never part of a build): server failures reach Vite's
+// error overlay and a dev error page with the source-mapped stack, unmatched URLs list the route
+// table, and browser errors the dev entry forwards (`rivet:client-error`) open the overlay too.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { join } from "node:path";
+import { compileRoutes } from "@rivetjs/runtime/router/server";
+import { escapeAttribute, escapeText } from "@rivetjs/runtime/escape";
+import { escapeJSON } from "@rivetjs/runtime/resume-format";
+const failures = new AsyncLocalStorage();
+/** JSON for an inline `<script>` (no `</script>` / `<!--`, no raw U+2028/U+2029), as resume state. */
+const scriptJSON = (value) => escapeJSON(JSON.stringify(value));
+const overlayOn = (server) => {
+    const hmr = server.config.server.hmr;
+    return !(hmr === false || (typeof hmr === "object" && hmr.overlay === false));
+};
+/** Diagnostic code (`RV1001`…) of an error that carries one, as an overlay message prefix. */
+const codeOf = (error) => {
+    const code = error?.code;
+    return typeof code === "string" && /^RV\d{4}$/.test(code) ? `[${code}] ` : "";
+};
+/**
+ * Dev `onError`: source-map the stack, log it, send it to Vite's overlay (open pages, e.g. during
+ * client navigation) and remember it for the request's dev error page.
+ */
+export function devReport(server, table, routesPath, describe) {
+    return (error, _request, info) => {
+        if (error instanceof Error)
+            server.ssrFixStacktrace(error);
+        // Without info: a render failure reported by a custom renderer (app renders report `phase: "render"`).
+        const phase = info?.phase ?? "render";
+        const route = info?.route;
+        const file = route === undefined ? undefined : table().routes.find((entry) => entry.id === route)?.page;
+        const text = error instanceof Error ? error.message : String(error);
+        const symbol = describe && resumeSymbol(text, describe);
+        const id = symbol?.file ?? (file ? join(routesPath, file) : undefined);
+        const note = symbol ? symbolNote(text, symbol) : describe ? missingNote(text) : "";
+        const message = codeOf(error) + text + note;
+        const stack = error instanceof Error ? (error.stack ?? "") : "";
+        server.config.logger.error(`[rivet] ${phase} failed${route === undefined ? "" : ` (route "${route}")`}: ${note ? message + "\n" : ""}${stack || message}`);
+        const failure = { message, stack, phase, route, id, ...(symbol ? { loc: { file: symbol.file, line: symbol.line, column: symbol.column } } : {}) };
+        failures.getStore()?.push(failure);
+        if (overlayOn(server))
+            server.ws.send({ type: "error", err: overlayError(failure) });
+    };
+}
+const overlayError = (failure) => ({
+    message: `${failure.phase} failed${failure.route === undefined ? "" : ` in route "${failure.route}"`}: ${failure.message}`,
+    stack: failure.stack,
+    plugin: "rivet",
+    ...(failure.id ? { id: failure.id } : {}),
+    ...(failure.loc ? { loc: failure.loc } : {}),
+});
+// Symbol ids in resume recorder errors: `Cannot resume <id>: capture `<name>` …` (dev; `#<n>` without names), `… no chunk for <id>`.
+const SYMBOL_ID = /(?:^|[\s(])((?:[\w.@-]+\/)*[\w.@-]+\.[cm]?[jt]sx?#[\w$]+)/;
+/** The resume symbol a recorder error names, when the dev server compiled it. */
+function resumeSymbol(message, describe) {
+    const id = SYMBOL_ID.exec(message)?.[1];
+    return id === undefined ? undefined : describe(id);
+}
+const KINDS = {
+    event: "event handler",
+    attr: "attribute binding",
+    bind: "text binding",
+    region: "child region",
+    model: "model:",
+    effect: "clientEffect",
+    clientEvent: "clientEvent",
+    computed: "computed",
+    equals: "equals comparator",
+    fn: "function",
+    slot: "slot",
+    spread: "spread",
+};
+/** `in <Component> (file:line:col), <kind>; capture `name` (file:line:col)` for an error naming a symbol. */
+function symbolNote(message, symbol) {
+    const where = (line, column) => `${symbol.module}:${line}:${column}`;
+    let note = `\n  in <${symbol.component === "default" ? "default export" : symbol.component}> (${where(symbol.line, symbol.column)}), ${KINDS[symbol.kind] ?? symbol.kind} ${symbol.id}`;
+    // `capture `name`` (dev manifest names, Function Bridge T19) or `capture #<n>` (no names).
+    const named = /capture `([^`]+)`/.exec(message)?.[1];
+    const index = named === undefined ? /capture #(\d+)/.exec(message)?.[1] : undefined;
+    const capture = named !== undefined ? symbol.captures.find((c) => c.name === named) : index === undefined ? undefined : symbol.captures[Number(index)];
+    if (capture)
+        note += `\n  capture \`${capture.name}\` (${where(capture.line, capture.column)})`;
+    return note;
+}
+/** Dev note for a symbol the dev manifest has no chunk for (no SSR compile defined it). */
+const missingNote = (message) => {
+    const id = /no chunk for (\S+)/.exec(message)?.[1];
+    return id === undefined
+        ? ""
+        : `\n  dev: no module the dev server compiled in resume mode defines ${id.replace(/[.,;]$/, "")} (is ${id.slice(0, id.indexOf("#"))} in resume.modules?)`;
+};
+/** Browser errors forwarded by the dev entry (`import.meta.hot.send("rivet:client-error")`) open that page's overlay. */
+export function listenClientErrors(server) {
+    server.ws.on("rivet:client-error", (data, client) => {
+        const message = String(data?.message ?? "Unknown error");
+        // Benign ResizeObserver loop notice (older dev clients still forward it): no overlay, no error log.
+        if (/^ResizeObserver loop (completed with undelivered notifications|limit exceeded)/.test(message))
+            return;
+        const stack = typeof data?.stack === "string" ? data.stack : "";
+        server.config.logger.error(`[rivet] browser error: ${stack || message}`);
+        if (overlayOn(server))
+            client.send({ type: "error", err: { message: "Browser error: " + message, stack, plugin: "rivet" } });
+    });
+}
+let matcher;
+const matches = (table, url) => {
+    if (matcher?.table !== table)
+        matcher = { table, match: compileRoutes(table.routes.map((route) => ({ path: route.pattern, render: () => route }))) };
+    return matcher.match(url) != null;
+};
+/** The `_404` an unmatched URL renders (longest folder prefix, else the root one). */
+const notFoundFor = (table, path) => table.notFounds?.find(({ prefix }) => path === prefix || path.startsWith(prefix + "/"))?.page ?? table.notFound;
+/** Route patterns, once each, in table order: `[pattern, endpoint-only]`. */
+const patterns = (table) => {
+    const seen = new Map();
+    for (const route of table.routes)
+        if (!seen.has(route.pattern))
+            seen.set(route.pattern, !route.page);
+    return [...seen];
+};
+const nonceOf = (response) => /'nonce-([^']+)'/.exec(response.headers.get("content-security-policy") ?? "")?.[1];
+const nonceAttr = (nonce) => (nonce === undefined ? "" : ` nonce="${escapeAttribute(nonce)}"`);
+const html = (response, body) => {
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.set("content-type", "text/html; charset=utf-8");
+    return new Response(body, { status: response.status, headers });
+};
+/** Insert markup before the document's last `</body>` (else append). */
+const inject = (page, markup) => {
+    const at = page.lastIndexOf("</body>");
+    return at < 0 ? page + markup : page.slice(0, at) + markup + page.slice(at);
+};
+/** Inline module script opening Vite's overlay on this page (the request's ws message reached only pages already open). */
+const overlayScript = (server, failure, nonce) => `<script type="module"${nonceAttr(nonce)}>import { ErrorOverlay } from ${scriptJSON(server.config.base + "@vite/client")};` +
+    `document.body.appendChild(new ErrorOverlay(${scriptJSON(overlayError(failure))}));</script>`;
+const STYLE = "body{margin:0;font:15px/1.5 system-ui,sans-serif;background:#fff;color:#1b1b1f}main{max-width:72rem;margin:0 auto;padding:2rem 1rem}" +
+    "h1{font-size:1.4rem;margin:0 0 .5rem}code,pre{font-family:ui-monospace,SFMono-Regular,Menlo,monospace}pre{overflow:auto;padding:1rem;border-radius:6px;background:#f4f4f6;white-space:pre-wrap}" +
+    ".message{color:#b00020;font-weight:600}ul{padding-left:1.2rem}li{margin:.15rem 0}small{color:#6b6b76}" +
+    "@media (prefers-color-scheme:dark){body{background:#151518;color:#e8e8ec}pre{background:#222228}.message{color:#ff8a8a}small{color:#9a9aa6}a{color:#8ab4ff}}";
+const devPage = (title, body, scripts) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">` +
+    `<title>${escapeText(title)}</title><style>${STYLE}</style></head><body><main>${body}</main>${scripts}</body></html>`;
+/** Vite's client (HMR, overlay) plus a reload when server code changes (`rivet:data`) or the route table does. */
+const devClient = (server, nonce) => `<script type="module"${nonceAttr(nonce)}>import { createHotContext } from ${scriptJSON(server.config.base + "@vite/client")};` +
+    `createHotContext("/@rivet/dev-page").on("rivet:data", () => location.reload());</script>`;
+/** Route list markup: static patterns link to their page. */
+const routeList = (server, table) => {
+    const items = patterns(table).map(([pattern, endpoint]) => {
+        const label = `<code>${escapeText(pattern)}</code>`;
+        const link = !endpoint && !/[:*]/.test(pattern) ? `<a href="${escapeAttribute(server.config.base + pattern.slice(1))}">${label}</a>` : label;
+        return `<li>${link}${endpoint ? " <small>endpoint</small>" : ""}</li>`;
+    });
+    return items.length ? `<ul id="rivet-dev-routes">${items.join("")}</ul>` : "<p>No routes yet: add a page under the routes directory.</p>";
+};
+/** HTML comment (`--` cannot appear inside one). */
+const comment = (text) => `<!-- ${text.replace(/--/g, "- -")} -->`;
+/**
+ * Wrap the dev app handler: a reported 5xx page gets the dev error page (no `_error` view) or the
+ * overlay over the app's `_error` view; an unmatched URL without a `_404` lists the routes.
+ */
+export function devHandler(handler, server, table) {
+    return async (request, context) => {
+        const seen = [];
+        const response = await failures.run(seen, () => handler(request, context));
+        if (!(response.headers.get("content-type") ?? "").startsWith("text/html"))
+            return response;
+        const nonce = nonceOf(response);
+        const routes = table();
+        const failure = seen[0];
+        if (failure && response.status >= 500) {
+            const own = failure.route === undefined ? undefined : routes.routes.find((entry) => entry.id === failure.route);
+            const overlay = overlayOn(server) ? overlayScript(server, failure, nonce) : "";
+            const where = comment(`rivet dev: ${failure.phase} failed${failure.route === undefined ? "" : ` in route "${failure.route}"`}: ${failure.message}`);
+            // The app's `_error` view renders as in production; the overlay shows the details over it.
+            if (own?.error ?? routes.error)
+                return html(response, inject(await response.text(), where + overlay));
+            const body = `<h1>Server error</h1><p id="rivet-dev-where">${failure.route === undefined ? "" : `Route <code>${escapeText(failure.route)}</code>, `}phase <code>${escapeText(failure.phase)}</code></p>` +
+                `<pre class="message">${escapeText(failure.message)}</pre>${failure.stack ? `<pre class="stack">${escapeText(failure.stack)}</pre>` : ""}` +
+                "<p><small>Development only: production answers with a generic message and a digest. Add an <code>_error</code> page to render your own.</small></p>";
+            return html(response, devPage(`${response.status} · ${failure.message}`, body, devClient(server, nonce) + overlay));
+        }
+        if (response.status === 404 && request.method === "GET" && !matches(routes, new URL(request.url))) {
+            const path = new URL(request.url).pathname;
+            const list = patterns(routes)
+                .map(([pattern]) => pattern)
+                .join(" ");
+            if (notFoundFor(routes, path))
+                return html(response, inject(await response.text(), comment(`rivet dev: no route matches ${path}. Routes: ${list}`)));
+            const body = `<h1>No route matches <code>${escapeText(path)}</code></h1><p>Routes:</p>${routeList(server, routes)}` +
+                "<p><small>Development only: add a <code>_404</code> page to render your own.</small></p>";
+            return html(response, devPage("404 · " + path, body, devClient(server, nonce)));
+        }
+        return response.body ? lateFailures(response, seen, server, nonce) : response;
+    };
+}
+/**
+ * A render that fails after the response started (status sent; e.g. the resume state, encoded at the
+ * end of the shell) ends the document early (failure marker, or an errored body): the page then ends
+ * with the hint comment and opens the overlay itself (the ws message only reaches pages already
+ * open), and reloads on the next update.
+ */
+function lateFailures(response, seen, server, nonce) {
+    const reader = response.body.getReader();
+    const encoder = new TextEncoder();
+    const before = seen.length;
+    const hint = (failure) => {
+        const where = comment(`rivet dev: ${failure.phase} failed${failure.route === undefined ? "" : ` in route "${failure.route}"`}: ${failure.message}`);
+        const reload = `<script type="module"${nonceAttr(nonce)}>import { createHotContext } from ${scriptJSON(server.config.base + "@vite/client")};` +
+            `const hot = createHotContext("/@rivet/dev-page");hot.on("rivet:data", () => location.reload());hot.on("vite:beforeUpdate", () => location.reload());</script>`;
+        return encoder.encode(where + (overlayOn(server) ? overlayScript(server, failure, nonce) : "") + reload);
+    };
+    const body = new ReadableStream({
+        async pull(controller) {
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch (error) {
+                const failure = seen[0];
+                if (!failure)
+                    return controller.error(error);
+                controller.enqueue(hint(failure));
+                return controller.close();
+            }
+            if (!chunk.done)
+                return controller.enqueue(chunk.value);
+            // A failure reported while the body streamed (the document closed with its failure marker).
+            if (seen.length > before)
+                controller.enqueue(hint(seen[before]));
+            controller.close();
+        },
+        cancel: (reason) => reader.cancel(reason),
+    });
+    return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+}

package/build/migrate.d.ts

@@ -0,0 +1,15 @@
+export declare const RENAMES: Readonly<Record<string, string>>;
+export interface MigrateReport {
+    /** Changed files (absolute) → new contents. */
+    readonly changes: ReadonlyMap<string, string>;
+    /** `file: old → new` per renamed export. */
+    readonly renamed: readonly string[];
+    /** Exports left alone, with the reason. */
+    readonly skipped: readonly string[];
+}
+/**
+ * Compute the migration for `*.server.ts` modules under `routesDir`; references are searched in every
+ * source module under `projectDir`. Nothing is written (see `writeMigration`).
+ */
+export declare function migrateServerExports(projectDir: string, routesDir: string): Promise<MigrateReport>;
+export declare function writeMigration(report: MigrateReport): Promise<void>;

package/build/migrate.js

@@ -0,0 +1,146 @@
+// `rivet migrate server-exports`: rename the old sibling `*.server.ts` export names (`load`, `guard`,
+// `actions`, `entries`, `headers`, `GET`…) to the in-file names (`serverLoad`…, `onGet`…). Renames are
+// scope-aware (TypeScript language service): references in other modules (`typeof import(…).load`)
+// follow; unrelated locals of the same name do not.
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+export const RENAMES = {
+    load: "serverLoad",
+    guard: "serverGuard",
+    actions: "serverActions",
+    entries: "serverEntries",
+    headers: "serverHeaders",
+    GET: "onGet",
+    POST: "onPost",
+    PUT: "onPut",
+    PATCH: "onPatch",
+    DELETE: "onDelete",
+};
+const SOURCE = /\.(m|c)?[jt]sx?$/;
+const SERVER = /\.server\.(m|c)?[jt]s$/;
+const IGNORED = /(^|[/\\])(node_modules|dist|\.rivet|\.[^/\\]+)([/\\]|$)/;
+async function sources(dir) {
+    const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((e) => e.isFile() && SOURCE.test(e.name) && !e.name.endsWith(".d.ts"))
+        .map((e) => join(e.parentPath, e.name))
+        .filter((file) => !IGNORED.test(relative(dir, file)));
+}
+/**
+ * Compute the migration for `*.server.ts` modules under `routesDir`; references are searched in every
+ * source module under `projectDir`. Nothing is written (see `writeMigration`).
+ */
+export async function migrateServerExports(projectDir, routesDir) {
+    const ts = (await import("typescript")).default;
+    const files = await sources(resolve(projectDir));
+    const texts = new Map();
+    for (const file of files)
+        texts.set(file, await readFile(file, "utf8"));
+    const routesRoot = resolve(projectDir, routesDir) + sep;
+    const targets = files.filter((file) => file.startsWith(routesRoot) && SERVER.test(file));
+    const options = {
+        allowJs: true,
+        jsx: ts.JsxEmit.Preserve,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        target: ts.ScriptTarget.ES2022,
+        allowImportingTsExtensions: true,
+        noEmit: true,
+    };
+    const host = {
+        getScriptFileNames: () => files,
+        getScriptVersion: () => "1",
+        getScriptSnapshot: (file) => {
+            const text = texts.get(file) ?? ts.sys.readFile(file);
+            return text === undefined ? undefined : ts.ScriptSnapshot.fromString(text);
+        },
+        getCurrentDirectory: () => resolve(projectDir),
+        getCompilationSettings: () => options,
+        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+        fileExists: (file) => texts.has(file) || ts.sys.fileExists(file),
+        readFile: (file) => texts.get(file) ?? ts.sys.readFile(file),
+        readDirectory: ts.sys.readDirectory,
+        directoryExists: ts.sys.directoryExists,
+        getDirectories: ts.sys.getDirectories,
+    };
+    const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+    const edits = new Map();
+    const renamed = [];
+    const skipped = [];
+    const edit = (file, start, end, text) => {
+        let list = edits.get(file);
+        if (!list)
+            edits.set(file, (list = []));
+        if (!list.some((e) => e.start === start))
+            list.push({ start, end, text });
+    };
+    for (const file of targets) {
+        const program = service.getProgram();
+        const source = program.getSourceFile(file);
+        const name = relative(projectDir, file).split(sep).join("/");
+        // Top-level names (declared or exported) decide collisions.
+        const locals = new Set();
+        const exported = [];
+        for (const statement of source.statements) {
+            const isExport = ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+            const names = [];
+            if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name)
+                names.push(statement.name);
+            if (ts.isVariableStatement(statement))
+                for (const d of statement.declarationList.declarations)
+                    if (ts.isIdentifier(d.name))
+                        names.push(d.name);
+            for (const id of names) {
+                locals.add(id.text);
+                if (isExport && id.text in RENAMES)
+                    exported.push({ old: id.text, node: id });
+            }
+            if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause))
+                for (const specifier of statement.exportClause.elements) {
+                    locals.add(specifier.name.text);
+                    if (specifier.name.text in RENAMES)
+                        exported.push({ old: specifier.name.text, node: specifier.name, specifier });
+                }
+            if (ts.isImportDeclaration(statement) && statement.importClause) {
+                const clause = statement.importClause;
+                if (clause.name)
+                    locals.add(clause.name.text);
+                const bindings = clause.namedBindings;
+                if (bindings && ts.isNamedImports(bindings))
+                    for (const s of bindings.elements)
+                        locals.add(s.name.text);
+                if (bindings && ts.isNamespaceImport(bindings))
+                    locals.add(bindings.name.text);
+            }
+        }
+        for (const { old, node, specifier } of exported) {
+            const next = RENAMES[old];
+            if (locals.has(next)) {
+                skipped.push(`${name}: ${old} (\`${next}\` already exists)`);
+                continue;
+            }
+            if (specifier && specifier.propertyName) {
+                // `export { x as load }`: only the exported name changes.
+                edit(file, specifier.name.getStart(source), specifier.name.getEnd(), next);
+            }
+            else {
+                const locations = service.findRenameLocations(file, node.getStart(source), false, false, { providePrefixAndSuffixTextForRename: true }) ?? [];
+                for (const location of locations)
+                    edit(location.fileName, location.textSpan.start, location.textSpan.start + location.textSpan.length, (location.prefixText ?? "") + next + (location.suffixText ?? ""));
+            }
+            renamed.push(`${name}: ${old} → ${next}`);
+        }
+    }
+    const changes = new Map();
+    for (const [file, list] of edits) {
+        let text = texts.get(file) ?? (await readFile(file, "utf8"));
+        for (const e of list.sort((a, b) => b.start - a.start))
+            text = text.slice(0, e.start) + e.text + text.slice(e.end);
+        changes.set(file, text);
+    }
+    return { changes, renamed, skipped };
+}
+export async function writeMigration(report) {
+    for (const [file, text] of report.changes)
+        await writeFile(file, text);
+}

package/build/route-css.d.ts

@@ -0,0 +1,54 @@
+import type { InlineStyleManifest } from "../server/inline-styles.js";
+import type { Rollup, ViteDevServer } from "vite";
+import type { RouteTable } from "./routes.js";
+/** Client build asset: route id → stylesheet URLs (written only when some route has CSS). */
+export declare const ROUTE_CSS = ".vite/rivet-route-css.json";
+/** Stylesheet URLs per route id from a client bundle (empty when no route module imports CSS). */
+export declare function bundleRouteCSS(bundle: Rollup.OutputBundle, table: RouteTable, routesDir: string, base: string): Record<string, string[]>;
+/**
+ * One stylesheet per route: a route whose modules import several stylesheets (per-component CSS, `@rivetjs/ui`)
+ * links them as one merged asset (`assets/route-<hash>.css`, the files joined in link order; routes with the same
+ * list share it), so a page has one render-blocking route sheet next to the global styles. Lists of one file stay.
+ * Returns the merged assets to emit and the route map pointing at them. `prefix` names the asset (docs-kit example
+ * frames: `frame`).
+ */
+export declare function mergeRouteCSS(bundle: Rollup.OutputBundle, css: Record<string, string[]>, base: string, prefix?: string): {
+    routes: Record<string, string[]>;
+    assets: {
+        fileName: string;
+        source: string;
+    }[];
+};
+/** Client build asset: the stylesheets the handler may write inline (`InlineStyleManifest`; written only when some are). */
+export declare const INLINE_CSS = ".vite/rivet-inline-css.json";
+/**
+ * `rivetRouter({ inlineStylesheets })` (Astro's `build.inlineStylesheets` model, decided per page on compressed bytes):
+ * `"auto"` (default) / `{ maxTotalBrotli }`, `"always"`, `"never"`.
+ */
+export type InlineStylesheets = "auto" | "always" | "never" | {
+    readonly maxTotalBrotli?: number;
+};
+/** `auto`: all of a page's sheets inline when their brotli sizes add up to at most this. */
+export declare const MAX_TOTAL_BROTLI = 6144;
+/**
+ * The inline stylesheet manifest (`.vite/rivet-inline-css.json`, `server/inline-styles.ts` decides per page), or
+ * `undefined` when no sheet qualifies (`"never"`, nothing listed). Listed: every client CSS asset and merged route sheet
+ * (keys = the URLs the handler links, `base` + file name) without relative `url()` / `@import` references (they resolve
+ * against the sheet's URL) that could ever go inline — `"always"`: all; `"auto"`: brotli size ≤ `maxTotalBrotli` (the
+ * per-page total) or raw size ≤ `limit` (Vite `build.assetsInlineLimit`, the per-sheet fallback). Brotli at quality 11.
+ */
+export declare function inlineCSS(bundle: Rollup.OutputBundle, extra: readonly {
+    fileName: string;
+    source: string;
+}[], base: string, mode: InlineStylesheets, limit: number): InlineStyleManifest | undefined;
+/**
+ * Drops repeated top-level `@property` / `@keyframes` blocks and `@layer a, b;` statements that are byte-identical to an
+ * earlier one (each per-component stylesheet carries the ones it uses; a repeat changes nothing). Strings and comments
+ * are skipped; anything else is kept as is.
+ */
+export declare function dedupeTopLevel(css: string): string;
+/**
+ * Dev: stylesheets in the SSR module graph of a route's modules (loaded first), as `?direct` links
+ * (no flash before the client graph injects its `<style>`s; `entry.dev.tsx` then removes them).
+ */
+export declare function devRouteCSS(server: ViteDevServer, table: RouteTable, routesDir: string, id: string, exclude: ReadonlySet<string>): Promise<string[]>;