@pracht/cli 1.5.1 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # @pracht/cli
 
+## 1.6.0
+
+### Minor Changes
+
+- [#179](https://github.com/JoviDeCroock/pracht/pull/179) [`67bc60b`](https://github.com/JoviDeCroock/pracht/commit/67bc60b5a0439beb91fc7332ea6bac9520108d70) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add `pracht build --analyze` and per-route client JS budgets.
+
+  `pracht build --analyze` prints a per-route report of the client JavaScript each route loads: the transitive chunks (route module + shell) with raw and gzip sizes, a total row per route, and the shared entry chunks broken out. `--json` emits the same data as machine-readable JSON. Output respects `NO_COLOR` and routes are sorted by total gzip size, descending.
+
+  The pracht plugin accepts a new `budgets` option (e.g. `budgets: { "*": "120kb", "/dashboard": "200kb" }`) declaring per-route gzip client-JS ceilings; `"*"` applies to every route and explicit route paths override it. `pracht build` evaluates budgets after every build, prints pass/fail per route, writes `dist/server/budget-report.json`, and exits non-zero on exceeded budgets unless `--no-budget-fail` is passed. `pracht verify` and `pracht doctor` surface the last build's budget results when the report file is present.
+
+- [#183](https://github.com/JoviDeCroock/pracht/pull/183) [`9db0a58`](https://github.com/JoviDeCroock/pracht/commit/9db0a5897216eb049cc99f0d53adb5dad34314b9) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - `pracht build` for the Cloudflare target now writes a thin deploy entry at
+  `dist/server/worker.js` that re-exports only the default handler and the
+  `workerExportsFrom` entrypoint classes. workerd validates every named export
+  of the deployed entry module and rejects the build metadata (`buildTarget`,
+  asset manifests, `resolvedApp`, ...) that `dist/server/server.js` exports for
+  the SSG prerender pass, so pointing `wrangler.jsonc`'s `main` at `server.js`
+  failed to boot with `Incorrect type for map entry 'buildTarget'`. Point `main`
+  at `dist/server/worker.js` instead. The generated server entry now also
+  exports `cloudflareWorkerEntrypointNames` so the CLI knows which classes to
+  re-export.
+
+- [#178](https://github.com/JoviDeCroock/pracht/pull/178) [`d27b96a`](https://github.com/JoviDeCroock/pracht/commit/d27b96a68354b69d06cdfdd9667956631283ce1a) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add a dev-server startup banner and a rich dev-only 404 page.
+
+  `pracht dev` now prints a route table on startup — every page route with its
+  render mode, shell, and middleware, plus API routes with their HTTP methods —
+  alongside the local URL. The banner reuses the resolved-app-graph logic shared
+  with `pracht inspect` and respects `NO_COLOR`.
+
+  In dev mode, document navigations that match no page route and no API route now
+  render a styled standalone 404 page (new `@pracht/core/dev-404` entry, same
+  self-contained approach as the error overlay) listing all registered routes
+  with render modes and links plus the requested path. The module is only loaded
+  by the dev middleware; production 404 behavior is unchanged.
+
+- [#173](https://github.com/JoviDeCroock/pracht/pull/173) [`004e429`](https://github.com/JoviDeCroock/pracht/commit/004e4295db64bea56a283848db352b3c29909a45) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add `pracht mcp`, a stdio Model Context Protocol server built into the CLI. It exposes the existing command internals as native MCP tools for coding agents: `inspect_routes`, `inspect_api`, `inspect_build`, `doctor`, `verify` (with optional `changed` scope), and `generate_route` / `generate_shell` / `generate_middleware` / `generate_api`. Every tool accepts an optional `cwd`, returns the same JSON payloads as the corresponding `--json` CLI flags, and surfaces failures as `isError` results instead of crashing the server. See docs/MCP.md for registration instructions and the tool reference.
+
+- [#175](https://github.com/JoviDeCroock/pracht/pull/175) [`439bc22`](https://github.com/JoviDeCroock/pracht/commit/439bc22a7a92baf2e450ecf6c9fa9b6e0d43b22d) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add `pracht preview` to serve the production build locally with one command. It runs `pracht build` first (skippable with `--skip-build`) and then serves the output for the configured adapter: Node targets run `dist/server/server.js` as a child process (`--port <n>`, `$PORT`, default 3000), Cloudflare targets delegate to `wrangler dev` against the built worker (with an actionable error when wrangler or its config is missing), and Vercel targets print guidance towards `vercel build`/`vercel dev` since there is no faithful local production runtime. Scaffolded Node and Cloudflare starters now include a `preview` script.
+
+- [#177](https://github.com/JoviDeCroock/pracht/pull/177) [`c1b22c4`](https://github.com/JoviDeCroock/pracht/commit/c1b22c4e786a485c969143de48cd2be7f5f03fe8) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add zero-generic typed loader data keyed by route id.
+
+  `pracht typegen` now registers each route's loader data type on
+  `Register["routes"]` in the generated `src/pracht-routes.d.ts`, pointing at the
+  route module (or the separate loader module wired via the manifest, which wins
+  over an inline loader like at runtime). `@pracht/core` gains a
+  `RouteLoaderData<TModule, TFallbackModule?>` utility type, a
+  `RouteDataFor<TRouteId>` helper, and a new `useRouteData(routeId)` overload
+  that returns the mapped loader data with route-id autocomplete — no generic
+  needed. The existing `useRouteData<typeof loader>()` form keeps working as the
+  fallback for projects that do not run typegen. In development, passing a route
+  id that is not the active route logs a warning.
+
+### Patch Changes
+
+- [#185](https://github.com/JoviDeCroock/pracht/pull/185) [`b83f5b7`](https://github.com/JoviDeCroock/pracht/commit/b83f5b7d6d92f22c982bad4fb62a9be00dd56a97) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - `pracht build` now stubs `cloudflare:*` platform modules (via Node module
+  hooks) while importing the built server bundle for SSG prerendering. Edge
+  server bundles keep these imports external because they only exist inside
+  workerd, so any app whose worker graph imports `cloudflare:workers` or
+  `cloudflare:email` previously failed the prerender pass with
+  `ERR_UNSUPPORTED_ESM_URL_SCHEME`.
+
+- [#180](https://github.com/JoviDeCroock/pracht/pull/180) [`ab693d5`](https://github.com/JoviDeCroock/pracht/commit/ab693d5ac04a1c7b3815c70396ab2e9a3a258072) Thanks [@JoviDeCroock](https://github.com/JoviDeCroock)! - Add a dev-only `/_pracht` devtools page and `Server-Timing` phase headers.
+
+  - The dev server now serves a self-contained devtools page at `/_pracht` listing every page route (pattern, render mode, shell, middleware chain, source file) and API route (path, methods, source file), with the same data available as JSON at `/_pracht.json`. The path is reserved in dev only — a colliding user route logs a warning in dev and still wins in production.
+  - Dev SSR responses now carry a standards-compliant `Server-Timing` header (e.g. `mw;dur=1.2, loader;dur=14.8, render;dur=3.1`) so middleware/loader/render phase durations show up in the browser Network panel. The runtime only records timings when the new `HandlePrachtRequestOptions.timings` collector is passed; production requests skip all timing work.
+  - `@pracht/core` gains a shared app-graph module (`buildAppGraph`, `serializeAppRoutes`, `serializeApiRoutes`, `detectApiMethods`, and a new `@pracht/core/devtools` entry) that both `pracht inspect` and the devtools page use, so the CLI and the page report the same graph.
+
+- Updated dependencies [[`d27b96a`](https://github.com/JoviDeCroock/pracht/commit/d27b96a68354b69d06cdfdd9667956631283ce1a), [`ab693d5`](https://github.com/JoviDeCroock/pracht/commit/ab693d5ac04a1c7b3815c70396ab2e9a3a258072), [`54b1070`](https://github.com/JoviDeCroock/pracht/commit/54b1070e3c73075689ae7d40ceb7716da412e077), [`a6b120b`](https://github.com/JoviDeCroock/pracht/commit/a6b120b8b79082adbdb54dbeb1920ba3703079c8), [`8862f51`](https://github.com/JoviDeCroock/pracht/commit/8862f51505bdbba8afd7ebf8570d461b233d66f9), [`c1b22c4`](https://github.com/JoviDeCroock/pracht/commit/c1b22c4e786a485c969143de48cd2be7f5f03fe8)]:
+  - @pracht/core@0.9.0
+
 ## 1.5.1
 
 ### Patch Changes

package/README.md

@@ -18,17 +18,53 @@ Start the local development server with SSR and HMR.
 
 Create a production build with client/server output and SSG/ISG prerendering.
 
+```bash
+pracht build
+pracht build --analyze          # per-route client JS report (gzip + raw)
+pracht build --json             # same report as JSON (agent-friendly)
+pracht build --no-budget-fail   # report exceeded budgets without failing
+```
+
+`--analyze` prints, per route (pattern + render mode), the transitive client
+chunks it loads with raw and gzip sizes, a total row, and the shared entry
+chunks broken out. Output respects `NO_COLOR`.
+
+When the pracht plugin config declares `budgets` (e.g.
+`budgets: { "*": "120kb", "/dashboard": "200kb" }`), every build evaluates the
+per-route gzip client-JS ceilings, writes `dist/server/budget-report.json`, and
+exits non-zero on exceeded budgets unless `--no-budget-fail` is passed. See
+[docs/PERFORMANCE.md](https://github.com/JoviDeCroock/pracht/blob/main/docs/PERFORMANCE.md).
+
 For Node.js targets, run the built server with:
 
 ```bash
 node dist/server/server.js
 ```
 
+### `pracht preview`
+
+Serve the production build locally. Runs `pracht build` first (skip with
+`--skip-build`), then serves the output for the configured adapter:
+
+- **Node**: runs `dist/server/server.js` on `--port` (or `$PORT`, default 3000).
+- **Cloudflare**: delegates to `wrangler dev` against the built worker; requires
+  wrangler in `node_modules` or on your PATH plus a wrangler config.
+- **Vercel**: there is no faithful local production runtime — the command points
+  you at `vercel build` / `vercel dev` instead.
+
+```bash
+pracht preview
+pracht preview --port 4000
+pracht preview --skip-build
+```
+
 ### `pracht verify`
 
 Run fast framework-aware verification checks without paying for a full build or
 test loop. Use `--changed` to focus on changed manifest-managed files and
-`--json` for machine-readable output.
+`--json` for machine-readable output. When `dist/server/budget-report.json`
+exists (written by `pracht build` when budgets are configured), the last
+build's client JS budget results are surfaced as checks.
 
 ```bash
 pracht verify
@@ -99,3 +135,14 @@ machine-readable output.
 pracht doctor
 pracht doctor --json
 ```
+
+### `pracht mcp`
+
+Start a Model Context Protocol server on stdio that exposes inspect, doctor,
+verify, and generate as native tools for coding agents. See
+[docs/MCP.md](https://github.com/JoviDeCroock/pracht/blob/main/docs/MCP.md)
+for client registration and the tool reference.
+
+```bash
+pracht mcp
+```

package/dist/build-CGzTcST3.mjs

@@ -0,0 +1,324 @@
+import { r as VERSION } from "./index.mjs";
+import { t as readClientBuildAssets } from "./build-metadata-DyMzBVtV.mjs";
+import { a as formatBytes, i as formatBundleReport, n as evaluateBudgets, o as shouldUseColor, r as formatBudgetResults, t as collectBundleReport } from "./bundle-report-DxTtmipa.mjs";
+import { register } from "node:module";
+import { defineCommand } from "citty";
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { build } from "vite";
+//#region src/build-shared.ts
+const ROUTE_STATE_REQUEST_HEADER = "x-pracht-route-state-request";
+function writeVercelBuildOutput({ functionName, headersManifest = {}, isgRoutes, regions, root, staticRoutes }) {
+	const outputDir = join(root, ".vercel/output");
+	const staticDir = join(outputDir, "static");
+	const functionDir = join(outputDir, "functions", `${functionName || "render"}.func`);
+	rmSync(outputDir, {
+		force: true,
+		recursive: true
+	});
+	mkdirSync(outputDir, { recursive: true });
+	cpSync(join(root, "dist/client"), staticDir, { recursive: true });
+	cpSync(join(root, "dist/server"), functionDir, { recursive: true });
+	writeFileSync(join(outputDir, "config.json"), `${JSON.stringify(createVercelOutputConfig({
+		functionName,
+		headersManifest,
+		staticRoutes,
+		isgRoutes
+	}), null, 2)}\n`, "utf-8");
+	writeFileSync(join(functionDir, ".vc-config.json"), `${JSON.stringify(createVercelFunctionConfig({ regions }), null, 2)}\n`, "utf-8");
+	return ".vercel/output";
+}
+function createVercelOutputConfig({ functionName, headersManifest, staticRoutes, isgRoutes }) {
+	const target = `/${functionName || "render"}`;
+	const routes = [{
+		dest: target,
+		has: [{
+			type: "header",
+			key: ROUTE_STATE_REQUEST_HEADER,
+			value: "1"
+		}],
+		src: "/(.*)"
+	}, {
+		dest: target,
+		has: [{
+			type: "query",
+			key: "_data",
+			value: "1"
+		}],
+		src: "/(.*)"
+	}];
+	for (const route of sortStaticRoutes(staticRoutes)) routes.push({
+		dest: routeToStaticHtmlPath(route),
+		src: routeToRouteExpression(route)
+	});
+	for (const route of isgRoutes) routes.push({
+		dest: target,
+		src: routeToRouteExpression(route)
+	});
+	routes.push({ handle: "filesystem" });
+	routes.push({
+		dest: target,
+		src: "/(.*)"
+	});
+	const headers = [{
+		headers: [
+			{
+				key: "permissions-policy",
+				value: "accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()"
+			},
+			{
+				key: "referrer-policy",
+				value: "strict-origin-when-cross-origin"
+			},
+			{
+				key: "x-content-type-options",
+				value: "nosniff"
+			},
+			{
+				key: "x-frame-options",
+				value: "SAMEORIGIN"
+			}
+		],
+		source: "/(.*)"
+	}];
+	for (const route of sortStaticRoutes(staticRoutes)) {
+		const routeHeaders = headersManifest[route];
+		if (!routeHeaders) continue;
+		headers.push({
+			headers: Object.entries(routeHeaders).map(([key, value]) => ({
+				key,
+				value
+			})),
+			source: routeToHeaderSource(route)
+		});
+	}
+	return {
+		headers,
+		framework: { version: VERSION },
+		routes,
+		version: 3
+	};
+}
+function createVercelFunctionConfig({ regions }) {
+	const config = {
+		entrypoint: "server.js",
+		runtime: "edge"
+	};
+	if (regions) config.regions = regions;
+	return config;
+}
+function sortStaticRoutes(routes) {
+	return [...new Set(routes)].sort((left, right) => right.length - left.length);
+}
+function routeToRouteExpression(route) {
+	if (route === "/") return "^/$";
+	return `^${escapeRegex(route)}/?$`;
+}
+function routeToStaticHtmlPath(route) {
+	if (route === "/") return "/index.html";
+	return `${route}/index.html`;
+}
+function routeToHeaderSource(route) {
+	return route === "/" ? "/" : route;
+}
+function escapeRegex(value) {
+	return value.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
+}
+//#endregion
+//#region src/commands/build.ts
+let prerenderHooksRegistered = false;
+function registerPrerenderModuleHooks() {
+	if (prerenderHooksRegistered) return;
+	prerenderHooksRegistered = true;
+	try {
+		register("./prerender-module-hooks.mjs", import.meta.url);
+	} catch {
+		register("../prerender-module-hooks.ts", import.meta.url);
+	}
+}
+var build_default = defineCommand({
+	meta: {
+		name: "build",
+		description: "Production build (client + server)"
+	},
+	args: {
+		analyze: {
+			type: "boolean",
+			description: "Print a per-route client JavaScript report after the build"
+		},
+		json: {
+			type: "boolean",
+			description: "Output the analyze report as JSON (implies --analyze)"
+		},
+		"budget-fail": {
+			type: "boolean",
+			default: true,
+			description: "Fail the build when a client JS budget is exceeded (--no-budget-fail to disable)"
+		}
+	},
+	async run({ args }) {
+		await runBuild(process.cwd(), {
+			analyze: Boolean(args.analyze),
+			analyzeJson: Boolean(args.json),
+			budgetFail: Boolean(args["budget-fail"])
+		});
+	}
+});
+function indentBlock(block) {
+	return block.split("\n").map((line) => line ? `  ${line}` : line).join("\n");
+}
+async function runBuild(root, options = {}) {
+	const analyzeJson = Boolean(options.analyzeJson);
+	const analyze = Boolean(options.analyze) || analyzeJson;
+	const budgetFail = options.budgetFail ?? true;
+	const logLevel = analyzeJson ? "silent" : void 0;
+	const log = (message) => {
+		if (!analyzeJson) console.log(message);
+	};
+	log("\n  Building client...\n");
+	await build({
+		root,
+		logLevel,
+		build: {
+			outDir: "dist",
+			manifest: true,
+			rollupOptions: { input: "virtual:pracht/client" }
+		}
+	});
+	log("\n  Building server...\n");
+	await build({
+		root,
+		logLevel,
+		build: {
+			outDir: "dist/server",
+			rollupOptions: { input: "virtual:pracht/server" },
+			ssr: true
+		}
+	});
+	const serverEntry = resolve(root, "dist/server/server.js");
+	let clientDir;
+	if (existsSync(resolve(root, "dist/client/.vite/manifest.json"))) clientDir = resolve(root, "dist/client");
+	else {
+		clientDir = resolve(root, "dist/client");
+		const distRoot = resolve(root, "dist");
+		mkdirSync(clientDir, { recursive: true });
+		for (const entry of readdirSync(distRoot)) {
+			if (entry === "server" || entry === "client") continue;
+			const sourcePath = join(distRoot, entry);
+			cpSync(sourcePath, join(clientDir, entry), { recursive: true });
+			rmSync(sourcePath, {
+				force: true,
+				recursive: true
+			});
+		}
+	}
+	const publicDir = resolve(root, "public");
+	if (existsSync(publicDir)) cpSync(publicDir, clientDir, { recursive: true });
+	let buildTarget = null;
+	if (existsSync(serverEntry)) {
+		registerPrerenderModuleHooks();
+		const serverMod = await import(pathToFileURL(serverEntry).href);
+		buildTarget = typeof serverMod.buildTarget === "string" ? serverMod.buildTarget : null;
+		const { prerenderApp } = serverMod;
+		const { clientEntryUrl, clientEntryJs, cssManifest, jsManifest } = readClientBuildAssets(root);
+		const { pages, isgManifest } = await prerenderApp({
+			app: serverMod.resolvedApp,
+			clientEntryUrl: clientEntryUrl ?? void 0,
+			cssManifest,
+			jsManifest,
+			registry: serverMod.registry,
+			withISGManifest: true,
+			concurrency: serverMod.prerenderConcurrency
+		});
+		const headersManifest = Object.fromEntries(pages.map((page) => [page.path, page.headers ?? {}]));
+		if (pages.length > 0) {
+			log(`\n  Prerendering ${pages.length} SSG/ISG route(s)...\n`);
+			for (const page of pages) {
+				const filePath = resolvePrerenderOutputPath(clientDir, page.path);
+				mkdirSync(dirname(filePath), { recursive: true });
+				writeFileSync(filePath, page.html, "utf-8");
+				log(`    ${page.path} → ${filePath.replace(root + "/", "")}`);
+			}
+		}
+		if (Object.keys(headersManifest).length > 0) {
+			const headersManifestJson = `${JSON.stringify(headersManifest, null, 2)}\n`;
+			writeFileSync(resolve(root, "dist/server/headers-manifest.json"), headersManifestJson, "utf-8");
+			mkdirSync(resolve(clientDir, "_pracht"), { recursive: true });
+			writeFileSync(resolve(clientDir, "_pracht/headers.json"), headersManifestJson, "utf-8");
+		}
+		if (Object.keys(isgManifest).length > 0) {
+			writeFileSync(resolve(root, "dist/server/isg-manifest.json"), JSON.stringify(isgManifest, null, 2), "utf-8");
+			log(`\n  ISG manifest → dist/server/isg-manifest.json (${Object.keys(isgManifest).length} route(s))\n`);
+		}
+		if (serverMod.buildTarget === "cloudflare") {
+			if (Object.keys(isgManifest).length > 0) console.warn("\n  Warning: Cloudflare adapter currently serves prerendered ISG HTML as static assets and does not perform runtime revalidation. Use SSR/SSG on Cloudflare, or deploy ISG routes to Node until Cloudflare ISG support is added.\n");
+			const entrypointNames = Array.isArray(serverMod.cloudflareWorkerEntrypointNames) ? serverMod.cloudflareWorkerEntrypointNames : [];
+			const deployEntryLines = [
+				...entrypointNames.length > 0 ? [`export { ${entrypointNames.join(", ")} } from "./server.js";`] : [],
+				"export { default } from \"./server.js\";",
+				""
+			];
+			writeFileSync(resolve(root, "dist/server/worker.js"), deployEntryLines.join("\n"), "utf-8");
+			log("\n  Cloudflare worker → dist/server/worker.js\n");
+			log("  Deploy with: wrangler deploy\n");
+		}
+		if (serverMod.buildTarget === "vercel") log(`\n  Vercel build output → ${writeVercelBuildOutput({
+			functionName: serverMod.vercelFunctionName,
+			isgRoutes: Object.keys(isgManifest),
+			headersManifest,
+			regions: serverMod.vercelRegions,
+			root,
+			staticRoutes: pages.map((page) => page.path).filter((path) => !(path in isgManifest))
+		})}\n`);
+		const budgets = serverMod.budgets ?? {};
+		const hasBudgets = Object.keys(budgets).length > 0;
+		if (analyze || hasBudgets) {
+			const report = collectBundleReport({
+				routes: serverMod.resolvedApp?.routes ?? [],
+				jsManifest,
+				clientEntryJs,
+				clientDir
+			});
+			const evaluation = hasBudgets ? evaluateBudgets(report, budgets) : null;
+			const color = shouldUseColor();
+			if (analyzeJson) console.log(JSON.stringify({
+				shared: report.shared,
+				routes: report.routes,
+				...evaluation ? { budgets: evaluation } : {}
+			}, null, 2));
+			else if (analyze) console.log(`\n${indentBlock(formatBundleReport(report, { color }))}\n`);
+			if (evaluation) {
+				writeFileSync(resolve(root, "dist/server/budget-report.json"), `${JSON.stringify({
+					generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					budgets,
+					results: evaluation.results,
+					unmatched: evaluation.unmatched,
+					ok: evaluation.ok
+				}, null, 2)}\n`, "utf-8");
+				if (!analyzeJson) console.log(`\n${indentBlock(formatBudgetResults(evaluation, { color }))}\n`);
+				if (!evaluation.ok) {
+					const summary = evaluation.results.filter((result) => !result.ok).map((result) => `${result.path} (${formatBytes(result.gzipBytes)} gzip > ${formatBytes(result.limitBytes)})`).join(", ");
+					if (budgetFail) {
+						console.error(`\n  Build failed: client JS budget exceeded for ${summary}.\n`);
+						process.exitCode = 1;
+						return { buildTarget };
+					}
+					if (!analyzeJson) console.warn(`\n  Warning: client JS budget exceeded for ${summary} (--no-budget-fail).\n`);
+				}
+			}
+		}
+	}
+	log("\n  Build complete.\n");
+	return { buildTarget };
+}
+function resolvePrerenderOutputPath(clientDir, routePath) {
+	if (routePath.includes("\0")) throw new Error(`Refusing to write prerendered route "${routePath}" with a NUL byte.`);
+	const root = resolve(clientDir);
+	const filePath = routePath === "/" ? resolve(root, "index.html") : resolve(root, `.${routePath}`, "index.html");
+	const relativePath = relative(root, filePath);
+	if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) throw new Error(`Refusing to write prerendered route "${routePath}" outside dist/client (${filePath}).`);
+	return filePath;
+}
+//#endregion
+export { build_default as default, runBuild };

package/dist/{build-metadata-BOChHO8g.mjs → build-metadata-DyMzBVtV.mjs}

@@ -7,6 +7,7 @@ function readClientBuildAssets(root = process.cwd()) {
 	const manifestPath = MANIFEST_PATHS.map((candidate) => resolve(root, candidate)).find((path) => existsSync(path));
 	if (!manifestPath) return {
 		clientEntryUrl: null,
+		clientEntryJs: [],
 		cssManifest: {},
 		jsManifest: {}
 	};
@@ -43,6 +44,7 @@ function readClientBuildAssets(root = process.cwd()) {
 	}
 	return {
 		clientEntryUrl: clientEntry ? `/${clientEntry.file}` : null,
+		clientEntryJs: clientEntry ? collectTransitiveDeps("virtual:pracht/client").js.map((file) => `/${file}`) : [],
 		cssManifest,
 		jsManifest
 	};