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

package/build/route-css.js

@@ -0,0 +1,216 @@
+// Per-route stylesheets: the CSS a route's layouts and page can render (their chunks' static
+// import closure), outer → inner, so SSR links exactly the route's CSS in the head.
+import { createHash } from "node:crypto";
+import { brotliCompressSync, constants } from "node:zlib";
+import { resolve } from "node:path";
+/** Client build asset: route id → stylesheet URLs (written only when some route has CSS). */
+export const ROUTE_CSS = ".vite/rivet-route-css.json";
+/** An app entry (router `styles`, CSR app), not a compiler resume chunk. */
+const isStylesEntry = (chunk) => chunk.isEntry && !chunk.facadeModuleId?.includes("rivet-resume-chunk:");
+const routeFiles = (table, routesDir, id) => {
+    const route = table.routes.find((r) => r.id === id);
+    if (!route?.page)
+        return [];
+    return [...route.layouts.flatMap((l) => (l.page ? [l.page] : [])), route.page].map((file) => resolve(routesDir, file));
+};
+/** Stylesheet URLs per route id from a client bundle (empty when no route module imports CSS). */
+export function bundleRouteCSS(bundle, table, routesDir, base) {
+    const chunks = Object.values(bundle).filter((o) => o.type === "chunk");
+    const byFile = new Map(chunks.map((c) => [c.fileName, c]));
+    const owner = new Map();
+    for (const chunk of chunks)
+        for (const id of chunk.moduleIds)
+            owner.set(id.split("?")[0], chunk);
+    // Entry CSS (router `styles`) is linked on every page already. Resume chunks are entries too (compiler inputs,
+    // `\0rivet-resume-chunk:`) but their CSS is a component's: it stays per route.
+    const global = new Set(chunks.filter(isStylesEntry).flatMap((c) => [...(c.viteMetadata?.importedCss ?? [])]));
+    const out = {};
+    for (const id of new Set(table.routes.map((r) => r.id))) {
+        const css = [];
+        const seen = new Set();
+        // Post-order: a chunk's static imports' CSS precedes its own.
+        const visit = (chunk) => {
+            if (seen.has(chunk.fileName))
+                return;
+            seen.add(chunk.fileName);
+            for (const file of chunk.imports) {
+                const imported = byFile.get(file);
+                if (imported)
+                    visit(imported);
+            }
+            for (const file of chunk.viteMetadata?.importedCss ?? [])
+                if (!global.has(file) && !css.includes(base + file))
+                    css.push(base + file);
+        };
+        for (const file of routeFiles(table, routesDir, id)) {
+            const chunk = owner.get(file);
+            if (chunk)
+                visit(chunk);
+        }
+        if (css.length)
+            out[id] = css;
+    }
+    return out;
+}
+/**
+ * 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 function mergeRouteCSS(bundle, css, base, prefix = "route") {
+    const assets = new Map();
+    const routes = {};
+    for (const [id, list] of Object.entries(css)) {
+        const sources = list.map((href) => bundle[href.slice(base.length)]);
+        if (list.length < 2 || sources.some((asset) => asset?.type !== "asset")) {
+            routes[id] = list;
+            continue;
+        }
+        const source = dedupeTopLevel(sources.map((asset) => unmarked(String(asset.source))).join("\n"));
+        const fileName = `assets/${prefix}-${createHash("sha256").update(source).digest("base64url").slice(0, 8)}.css`;
+        assets.set(fileName, source + "\n");
+        routes[id] = [base + fileName];
+    }
+    return { routes, assets: [...assets].map(([fileName, source]) => ({ fileName, source })) };
+}
+// Vite's CSS chunk marker (`/*$vite$:1*/`): still in the bundle's CSS assets during `generateBundle` (Vite drops it when
+// it writes its own assets, not from sources copied elsewhere).
+const unmarked = (css) => css.replace(/\/\*\$vite\$:\d+\*\/\n?/g, "").trim();
+/** Client build asset: the stylesheets the handler may write inline (`InlineStyleManifest`; written only when some are). */
+export const INLINE_CSS = ".vite/rivet-inline-css.json";
+/** `auto`: all of a page's sheets inline when their brotli sizes add up to at most this. */
+export const MAX_TOTAL_BROTLI = 6144;
+// A `url()` / `@import` the document would resolve against its own URL instead of the sheet's: `./` / `../` / bare
+// paths (Vite writes base-absolute URLs unless `base` is relative). Site-absolute, scheme, protocol-relative, `data:`
+// and fragment-only references resolve the same from both.
+const RELATIVE_REFERENCE = /(?:url\(\s*|@import\s+)(["']?)(?![a-z][\w+.-]*:|\/|#|["')\s])/i;
+/**
+ * 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 function inlineCSS(bundle, extra, base, mode, limit) {
+    if (mode === "never")
+        return undefined;
+    const always = mode === "always";
+    const maxTotalBrotli = typeof mode === "object" ? (mode.maxTotalBrotli ?? MAX_TOTAL_BROTLI) : MAX_TOTAL_BROTLI;
+    const sheets = {};
+    const all = [
+        ...Object.values(bundle).flatMap((o) => (o.type === "asset" && o.fileName.endsWith(".css") ? [{ fileName: o.fileName, source: String(o.source) }] : [])),
+        ...extra,
+    ];
+    for (const { fileName, source } of all) {
+        const css = unmarked(source);
+        if (!css || RELATIVE_REFERENCE.test(css))
+            continue;
+        const bytes = Buffer.byteLength(css);
+        const br = brotliCompressSync(css, { params: { [constants.BROTLI_PARAM_QUALITY]: 11, [constants.BROTLI_PARAM_SIZE_HINT]: bytes } }).length;
+        if (always || br <= maxTotalBrotli || bytes <= limit)
+            sheets[base + fileName] = { css, bytes, br };
+    }
+    return Object.keys(sheets).length ? { mode: always ? "always" : "auto", maxTotalBrotli, limit, sheets } : 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 function dedupeTopLevel(css) {
+    const seen = new Set();
+    let out = "";
+    let depth = 0;
+    for (let i = 0; i < css.length;) {
+        const ch = css[i];
+        if (ch === '"' || ch === "'") {
+            let j = i + 1;
+            while (j < css.length && css[j] !== ch)
+                j += css[j] === "\\" ? 2 : 1;
+            out += css.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (ch === "/" && css[i + 1] === "*") {
+            const j = css.indexOf("*/", i + 2);
+            const end = j < 0 ? css.length : j + 2;
+            out += css.slice(i, end);
+            i = end;
+        }
+        else if (depth === 0 && ch === "@" && /^@(property|keyframes|-webkit-keyframes|layer)\b/.test(css.slice(i, i + 20))) {
+            const end = blockEnd(css, i);
+            const block = css.slice(i, end);
+            const isStatement = block.endsWith(";");
+            if (!(/^@layer/.test(block) && !isStatement) && seen.has(block)) {
+                i = end;
+                continue;
+            }
+            if (!/^@layer/.test(block) || isStatement)
+                seen.add(block);
+            if (/^@layer/.test(block) && !isStatement) {
+                // A layer block: keep its head, scan its body (nested rules are not deduplicated).
+                out += ch;
+                i++;
+                continue;
+            }
+            out += block;
+            i = end;
+        }
+        else {
+            if (ch === "{")
+                depth++;
+            else if (ch === "}")
+                depth--;
+            out += ch;
+            i++;
+        }
+    }
+    return out;
+}
+/** End (exclusive) of the at-rule starting at `at`: after its `;` (statement) or its balanced `{…}` block. */
+function blockEnd(css, at) {
+    let depth = 0;
+    for (let i = at; i < css.length; i++) {
+        const ch = css[i];
+        if (ch === '"' || ch === "'") {
+            for (i++; i < css.length && css[i] !== ch; i += css[i] === "\\" ? 2 : 1)
+                ;
+        }
+        else if (ch === ";" && depth === 0)
+            return i + 1;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}" && --depth === 0)
+            return i + 1;
+    }
+    return css.length;
+}
+const CSS_REQUEST = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const NOT_LINKED = /[?&](?:inline|url|raw)\b/;
+/**
+ * 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 async function devRouteCSS(server, table, routesDir, id, exclude) {
+    const environment = server.environments.ssr;
+    const css = [];
+    const seen = new Set();
+    const visit = (node) => {
+        if (!node?.id || seen.has(node.id))
+            return;
+        seen.add(node.id);
+        for (const imported of node.importedModules)
+            visit(imported);
+        if (CSS_REQUEST.test(node.url) && !NOT_LINKED.test(node.url) && !exclude.has(node.url.split("?")[0])) {
+            const href = node.url + (node.url.includes("?") ? "&" : "?") + "direct";
+            if (!css.includes(href))
+                css.push(href);
+        }
+    };
+    for (const file of routeFiles(table, routesDir, id)) {
+        await server.ssrLoadModule(file);
+        visit(environment.moduleGraph.getModuleById(file));
+    }
+    return css;
+}

package/build/routes.d.ts

@@ -0,0 +1,50 @@
+/** A layout or special page found along a route's folder chain. */
+export interface RouteModule {
+    /** Universal module (component), relative to the routes directory, posix separators. */
+    readonly page?: string;
+    /**
+     * Server-only module: a sibling `*.server.ts` (guard, load, entries, actions, headers, request
+     * handlers), or an endpoint-only plain `x.ts` exporting request handlers.
+     */
+    readonly server?: string;
+    /** The page module itself declares server exports (`serverLoad`, `onGet`, `prerender`…). */
+    readonly inline?: boolean;
+    /** Page module with `export const live = true`: its `data` prop is an accessor revalidated in place. */
+    readonly live?: boolean;
+}
+/** One matchable route. Optional segments expand into several entries sharing an `id`. */
+export interface RouteEntry extends RouteModule {
+    /** Stable id: the file path without extension, e.g. `blog/[slug]`. */
+    readonly id: string;
+    /** Router pattern for `compileRoutes`, e.g. `/blog/:slug`, `/docs/*rest`. */
+    readonly pattern: string;
+    /** Parameter names in pattern order. */
+    readonly params: readonly string[];
+    /** Layouts from the outermost folder inward. */
+    readonly layouts: readonly RouteModule[];
+    /** Nearest `_404` / `_error` page modules. */
+    readonly notFound?: string;
+    readonly error?: string;
+}
+export interface RouteTable {
+    /** Ordered: the first matching entry wins. */
+    readonly routes: readonly RouteEntry[];
+    /** Root-level `_404` / `_error` for URLs that match no route. */
+    readonly notFound?: string;
+    readonly error?: string;
+    /** `_404` pages under static folders for unmatched URLs, longest URL prefix first (root excluded). */
+    readonly notFounds?: readonly {
+        readonly prefix: string;
+        readonly page: string;
+    }[];
+}
+/**
+ * Build the route table from file paths relative to the routes directory (posix separators).
+ * `exports`: server export names per module file (`scanRoutes` reads them; pages/layouts with any are
+ * `inline`, plain `.ts` files with request handlers are endpoint routes).
+ */
+export declare function routeTable(files: readonly string[], exports?: ReadonlyMap<string, readonly string[]>): RouteTable;
+/** Scan a routes directory and build its table (reads modules for their server exports). */
+export declare function scanRoutes(dir: string): Promise<RouteTable>;
+/** Server export names of route modules (pages, layouts, plain `.ts` files), by file; live pages also list `live`. */
+export declare function _serverExportsOf(dir: string, files: readonly string[]): Promise<Map<string, string[]>>;

package/build/routes.js

@@ -0,0 +1,202 @@
+// File-based route table: maps `src/routes/**` files to router patterns, layouts and special pages.
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+const PAGE = /\.(tsx|jsx)$/;
+const SERVER = /\.server\.(ts|js)$/;
+/** Plain `.ts`/`.js` route files: endpoint-only routes when they export request handlers. */
+const PLAIN = /\.(ts|js)$/;
+const HANDLER = /^on(Request|Get|Post|Put|Patch|Delete|Options)$/;
+const IGNORED = /(^|\/)[.]|\.(test|spec)\.[^/]+$|\.d\.ts$/;
+const SPECIAL = new Set(["_layout", "_404", "_error"]);
+/** Parse one path segment of a route file name; null for a path-less `(group)`. */
+function segment(part, file) {
+    if (/^\([^()/]+\)$/.test(part))
+        return null;
+    let match = /^\[\[([A-Za-z_$][\w$]*)\]\]$/.exec(part);
+    if (match)
+        return { kind: "optional", name: match[1] };
+    match = /^\[\.\.\.([A-Za-z_$][\w$]*)\]$/.exec(part);
+    if (match)
+        return { kind: "splat", name: match[1] };
+    match = /^\[([A-Za-z_$][\w$]*)\]$/.exec(part);
+    if (match)
+        return { kind: "param", name: match[1] };
+    if (/[[\]()*:?#\\]/.test(part))
+        throw new Error(`Invalid route segment "${part}" in ${file}`);
+    return { kind: "static", text: part };
+}
+// Rank per segment: static before param before splat; a route that ends sorts before a splat at
+// the same depth (both match the shorter URL), never against static/param (different lengths).
+const rank = (s) => (s === undefined ? 1.5 : s.kind === "static" ? 0 : s.kind === "splat" ? 2 : 1);
+function compare(a, b) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const d = rank(a[i]) - rank(b[i]);
+        if (d)
+            return d;
+        const x = a[i], y = b[i];
+        if (x?.kind === "static" && y?.kind === "static" && x.text !== y.text)
+            return x.text < y.text ? -1 : 1;
+    }
+    return 0;
+}
+const shape = (segments) => "/" + segments.map((s) => (s.kind === "static" ? s.text : s.kind === "splat" ? "*" : ":")).join("/");
+const pattern = (segments) => "/" + segments.map((s) => (s.kind === "static" ? encodeURIComponent(s.text) : (s.kind === "splat" ? "*" : ":") + s.name)).join("/");
+/**
+ * Build the route table from file paths relative to the routes directory (posix separators).
+ * `exports`: server export names per module file (`scanRoutes` reads them; pages/layouts with any are
+ * `inline`, plain `.ts` files with request handlers are endpoint routes).
+ */
+export function routeTable(files, exports = new Map()) {
+    const set = new Set(files.filter((file) => !IGNORED.test(file)));
+    const servers = new Map(); // module path without extension → server file
+    for (const file of set)
+        if (SERVER.test(file))
+            servers.set(file.replace(SERVER, ""), file);
+    for (const file of set) {
+        if (SERVER.test(file) || !PLAIN.test(file) || !exports.get(file)?.some((name) => HANDLER.test(name)))
+            continue;
+        const base = file.replace(PLAIN, "");
+        const other = servers.get(base);
+        if (other)
+            throw new Error(`${file} and ${other} are both server modules of ${base}; keep one`);
+        servers.set(base, file);
+    }
+    // `live` (a page flag `_serverExportsOf` reports with them) is not a server export.
+    const isInline = (page) => (page ? (exports.get(page)?.some((name) => name !== "live") ?? false) : false);
+    const isLive = (page) => exports.get(page)?.includes("live") ?? false;
+    const special = (folder, name) => {
+        const base = (folder ? folder + "/" : "") + name;
+        const page = [...set].find((file) => PAGE.test(file) && file.replace(PAGE, "") === base);
+        const server = servers.get(base);
+        return page || server ? { ...(page ? { page } : {}), ...(server ? { server } : {}), ...(isInline(page) ? { inline: true } : {}) } : undefined;
+    };
+    const nearest = (folders, name) => {
+        for (let i = folders.length - 1; i >= 0; i--) {
+            const found = special(folders[i], name)?.page;
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+    const modules = new Map();
+    for (const file of set) {
+        const page = PAGE.test(file), server = SERVER.test(file) || (PLAIN.test(file) && servers.get(file.replace(PLAIN, "")) === file);
+        if (!page && !server)
+            continue;
+        const base = file.replace(server ? (SERVER.test(file) ? SERVER : PLAIN) : PAGE, "");
+        const name = base.slice(base.lastIndexOf("/") + 1);
+        if (name.startsWith("_")) {
+            if (!SPECIAL.has(name))
+                continue;
+            if (server && name !== "_layout")
+                throw new Error(`${file}: only _layout may have a server module`);
+            continue;
+        }
+        if (base.split("/").some((part) => part.startsWith("_")))
+            continue;
+        const entry = modules.get(base) ?? {};
+        modules.set(base, server ? { ...entry, server: file } : { ...entry, page: file, ...(isInline(file) ? { inline: true } : {}), ...(isLive(file) ? { live: true } : {}) });
+    }
+    const drafts = [];
+    const seen = new Map();
+    for (const [base, module] of [...modules].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+        const parts = base.split("/");
+        const folders = [""];
+        for (let i = 0; i < parts.length - 1; i++)
+            folders.push(parts.slice(0, i + 1).join("/"));
+        const parsed = [];
+        for (const [i, part] of parts.entries()) {
+            if (i === parts.length - 1 && part === "index")
+                break;
+            const s = segment(part, base);
+            if (s)
+                parsed.push(s);
+        }
+        const splat = parsed.findIndex((s) => s.kind === "splat");
+        if (splat !== -1 && splat !== parsed.length - 1)
+            throw new Error(`${base}: [...${parsed[splat].name}] must be the last segment`);
+        const names = parsed.flatMap((s) => (s.kind === "static" ? [] : [s.name]));
+        if (new Set(names).size !== names.length)
+            throw new Error(`${base}: duplicate parameter name`);
+        // Each optional segment doubles the variants: with it (longer) and without.
+        let variants = [[]];
+        for (const s of parsed)
+            variants = s.kind === "optional" ? variants.flatMap((v) => [[...v, { kind: "param", name: s.name }], v]) : variants.map((v) => [...v, s]);
+        for (const segments of variants) {
+            const key = shape(segments);
+            const previous = seen.get(key);
+            if (previous !== undefined && previous !== base)
+                throw new Error(`Route conflict: ${previous} and ${base} both match ${key}`);
+            if (previous === base)
+                continue;
+            seen.set(key, base);
+            drafts.push({ id: base, segments, module, folders });
+        }
+    }
+    drafts.sort((a, b) => compare(a.segments, b.segments));
+    const routes = drafts.map(({ id, segments, module, folders }) => {
+        const layouts = folders.map((folder) => special(folder, "_layout")).filter((m) => m !== undefined);
+        const notFound = nearest(folders, "_404"), error = nearest(folders, "_error");
+        return {
+            id,
+            pattern: pattern(segments),
+            params: segments.flatMap((s) => (s.kind === "static" ? [] : [s.name])),
+            ...module,
+            layouts,
+            ...(notFound ? { notFound } : {}),
+            ...(error ? { error } : {}),
+        };
+    });
+    const notFound = special("", "_404")?.page, error = special("", "_error")?.page;
+    // Unmatched URLs: nearest `_404` by folder, for folders without parameters (groups add no segment).
+    const notFounds = [];
+    for (const file of set) {
+        if (!PAGE.test(file) || !file.endsWith("/_404" + file.slice(file.lastIndexOf("."))))
+            continue;
+        const parts = file.split("/").slice(0, -1);
+        if (parts.some((part) => part.startsWith("[")))
+            continue;
+        const prefix = "/" +
+            parts
+                .filter((part) => !/^\(.+\)$/.test(part))
+                .map(encodeURIComponent)
+                .join("/");
+        if (prefix !== "/")
+            notFounds.push({ prefix, page: file });
+    }
+    notFounds.sort((a, b) => b.prefix.length - a.prefix.length || (a.prefix < b.prefix ? -1 : 1));
+    return { routes, ...(notFound ? { notFound } : {}), ...(error ? { error } : {}), ...(notFounds.length ? { notFounds } : {}) };
+}
+/** Scan a routes directory and build its table (reads modules for their server exports). */
+export async function scanRoutes(dir) {
+    const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile()).map((entry) => relative(dir, join(entry.parentPath, entry.name)).split(sep).join("/"));
+    return routeTable(files, await _serverExportsOf(dir, files));
+}
+// `export const prerender` alone also makes a page carry server exports (a plain flag).
+const PRERENDER = /^\s*export\s+(?:const|let|var)\s+prerender\b/m;
+// `export const live = true`: a live page (reported as `live`, not a server export; universal, kept in the browser).
+const LIVE = /^\s*export\s+const\s+live\s*=\s*true\b/m;
+/** Server export names of route modules (pages, layouts, plain `.ts` files), by file; live pages also list `live`. */
+export async function _serverExportsOf(dir, files) {
+    const { moduleFacts } = await import("@rivetjs/compiler");
+    const out = new Map();
+    for (const file of files) {
+        if (IGNORED.test(file) || SERVER.test(file) || !(PAGE.test(file) || PLAIN.test(file)))
+            continue;
+        const source = await readFile(join(dir, file), "utf8");
+        const live = PAGE.test(file) && LIVE.test(source);
+        // Cheap prefilter: no candidate export name, no parse.
+        const candidates = /\b(server[A-Z]\w*|on(Request|Get|Post|Put|Patch|Delete|Options)|prerender)\b/.test(source);
+        if (!candidates && !live)
+            continue;
+        const names = candidates ? [...(moduleFacts(source, file, { serverExports: true }).serverExports ?? [])] : [];
+        if (PAGE.test(file) && PRERENDER.test(source))
+            names.push("prerender");
+        if (live)
+            names.push("live");
+        if (names.length)
+            out.set(file, names);
+    }
+    return out;
+}

package/build/sync.d.ts

@@ -0,0 +1,20 @@
+export interface SyncOptions {
+    /** App root (default the current directory). */
+    root?: string;
+    /** Vite config file (default: Vite's lookup in `root`). */
+    configFile?: string;
+    /** Vite mode (default `production`). */
+    mode?: string;
+}
+export interface SyncResult {
+    root: string;
+    /** Vite config file used (undefined: none found, nothing generated). */
+    configFile: string | undefined;
+    /** The written editor manifest, or null when no Rivet plugin ran. */
+    manifest: {
+        resumeModules?: string[];
+        routesDir?: string;
+        routes?: unknown[];
+    } | null;
+}
+export declare function sync({ root, configFile, mode }?: SyncOptions): Promise<SyncResult>;

package/build/sync.js

@@ -0,0 +1,16 @@
+// `rivet sync`: write an app's generated `.rivet/` files (route types, generated app, editor
+// manifest) without starting Vite. Resolves the app's own Vite config, so every plugin option
+// (routes dir, resume modules, base, i18n…) applies exactly as in `vite` / `vite build`: the router
+// plugin's `config` hook regenerates `.rivet/`, the compiler plugin's `configResolved` hook writes
+// `.rivet/editor.json`. Run it before `tsc` / `rivet-check` on a fresh clone (`.rivet/` is gitignored).
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export async function sync({ root = process.cwd(), configFile, mode = "production" } = {}) {
+    const { resolveConfig } = await import("vite");
+    const appRoot = resolve(root);
+    const config = await resolveConfig({ root: appRoot, mode, logLevel: "warn", ...(configFile ? { configFile: resolve(appRoot, configFile) } : {}) }, "build", mode);
+    const manifest = await readFile(resolve(config.root, ".rivet/editor.json"), "utf8")
+        .then((text) => JSON.parse(text))
+        .catch(() => null);
+    return { root: config.root, configFile: config.configFile, manifest };
+}