@pracht/cli 1.5.1 → 1.6.0

package/dist/prerender-module-hooks.mjs

@@ -0,0 +1,46 @@
+//#region src/prerender-module-hooks.ts
+/**
+* Node module hooks that stub `cloudflare:*` platform modules while
+* `pracht build` imports the built server bundle for SSG prerendering.
+*
+* Edge server bundles keep platform-scheme imports external (they only exist
+* inside workerd), so importing the bundle in Node would otherwise fail
+* before the prerender pass can run. Nothing that touches these classes runs
+* during prerendering — SSG only reads the resolved route manifest and
+* renders page components.
+*
+* Registered from the build command via `module.register()`.
+*/
+const STUB_PREFIX = "pracht-cloudflare-stub:";
+const STUB_SOURCES = {
+	"cloudflare:workers": [
+		"export class WorkerEntrypoint {}",
+		"export class DurableObject {}",
+		"export class WorkflowEntrypoint {}",
+		"export class RpcTarget {}",
+		"export const env = {};",
+		""
+	].join("\n"),
+	"cloudflare:email": "export class EmailMessage {}\n",
+	"cloudflare:sockets": "export function connect() { throw new Error(\"cloudflare:sockets is not available during prerendering\"); }\n"
+};
+function resolve(specifier, context, nextResolve) {
+	if (specifier.startsWith("cloudflare:")) {
+		if (!(specifier in STUB_SOURCES)) throw new Error(`pracht build has no prerender stub for "${specifier}". SSG prerendering imports the server bundle in Node, where Cloudflare platform modules do not exist. Please report this so the stub list can be extended.`);
+		return {
+			url: `${STUB_PREFIX}${specifier}`,
+			shortCircuit: true
+		};
+	}
+	return nextResolve(specifier, context);
+}
+function load(url, context, nextLoad) {
+	if (url.startsWith(STUB_PREFIX)) return {
+		format: "module",
+		source: STUB_SOURCES[url.slice(23)] ?? "",
+		shortCircuit: true
+	};
+	return nextLoad(url, context);
+}
+//#endregion
+export { load, resolve };

package/dist/preview-B0-hgVfI.mjs

@@ -0,0 +1,149 @@
+import { runBuild } from "./build-CGzTcST3.mjs";
+import { a as readProjectConfig, v as requirePositiveInteger } from "./project-2EajzTuX.mjs";
+import { defineCommand } from "citty";
+import { existsSync } from "node:fs";
+import { delimiter, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+//#region src/commands/preview.ts
+const SERVER_ENTRY = "dist/server/server.js";
+const WRANGLER_CONFIG_FILES = [
+	"wrangler.jsonc",
+	"wrangler.json",
+	"wrangler.toml"
+];
+const ADAPTER_TARGETS = new Set([
+	"cloudflare",
+	"node",
+	"vercel"
+]);
+var preview_default = defineCommand({
+	meta: {
+		name: "preview",
+		description: "Build and serve the production build locally"
+	},
+	args: {
+		port: {
+			type: "string",
+			description: "Port number (defaults to $PORT or 3000)"
+		},
+		"skip-build": {
+			type: "boolean",
+			description: "Serve the existing build output without rebuilding"
+		}
+	},
+	async run({ args }) {
+		const root = process.cwd();
+		const project = readProjectConfig(root);
+		if (!project.configFile) throw new Error("Missing vite config. `pracht preview` requires a project with pracht configured.");
+		if (!project.hasPrachtPlugin) throw new Error("vite.config does not appear to register the pracht plugin.");
+		const skipBuild = Boolean(args["skip-build"]);
+		let target = skipBuild ? await readBuildTarget(root) : null;
+		target ??= detectAdapterTarget(project);
+		if (target === "vercel") {
+			printVercelGuidance();
+			process.exitCode = 1;
+			return;
+		}
+		const port = requirePositiveInteger(args.port ?? process.env.PORT, "port", 3e3);
+		if (!skipBuild) {
+			const { buildTarget } = await runBuild(root);
+			target = normalizeAdapterTarget(buildTarget) ?? target;
+			if (target === "vercel") {
+				printVercelGuidance();
+				process.exitCode = 1;
+				return;
+			}
+		}
+		const serverEntry = resolve(root, SERVER_ENTRY);
+		if (!existsSync(serverEntry)) throw new Error(`Missing ${SERVER_ENTRY}. Run \`pracht build\` first, or drop --skip-build to build automatically.`);
+		if (target === "cloudflare") {
+			const wranglerBin = resolveWranglerBin(root);
+			if (!wranglerBin) throw new Error(["`pracht preview` needs wrangler to serve Cloudflare builds, but it was not found in node_modules or on your PATH.", "Install it with `npm install --save-dev wrangler` (or `pnpm add -D wrangler`) and re-run `pracht preview`."].join("\n"));
+			if (!findWranglerConfig(root)) throw new Error(["`pracht preview` needs a wrangler config (wrangler.jsonc, wrangler.json, or wrangler.toml) pointing at the built worker.", "Create one with `\"main\": \"dist/server/worker.js\"` — see docs/ADAPTERS.md for a full example."].join("\n"));
+			console.log(`\n  Previewing Cloudflare build with wrangler dev on port ${port}...\n`);
+			spawnPreviewProcess(wranglerBin, [
+				"dev",
+				"--port",
+				String(port)
+			], { cwd: root });
+			return;
+		}
+		console.log(`\n  Previewing production build → http://localhost:${port}\n`);
+		spawnPreviewProcess(process.execPath, [serverEntry], {
+			cwd: root,
+			env: {
+				...process.env,
+				PORT: String(port)
+			}
+		});
+	}
+});
+function detectAdapterTarget(project) {
+	const source = project.rawConfig;
+	if (/\bcloudflareAdapter\s*\(/.test(source) || source.includes("@pracht/adapter-cloudflare")) return "cloudflare";
+	if (/\bvercelAdapter\s*\(/.test(source) || source.includes("@pracht/adapter-vercel")) return "vercel";
+	return "node";
+}
+function normalizeAdapterTarget(value) {
+	return typeof value === "string" && ADAPTER_TARGETS.has(value) ? value : null;
+}
+function resolveWranglerBin(root, env = process.env) {
+	const binNames = process.platform === "win32" ? [
+		"wrangler.cmd",
+		"wrangler.exe",
+		"wrangler"
+	] : ["wrangler"];
+	const searchDirs = [resolve(root, "node_modules/.bin"), ...(env.PATH ?? "").split(delimiter).filter(Boolean)];
+	for (const dir of searchDirs) for (const name of binNames) {
+		const candidate = join(dir, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+async function readBuildTarget(root) {
+	const serverEntry = resolve(root, SERVER_ENTRY);
+	if (!existsSync(serverEntry)) return null;
+	try {
+		return normalizeAdapterTarget((await import(pathToFileURL(serverEntry).href)).buildTarget);
+	} catch {
+		return null;
+	}
+}
+function findWranglerConfig(root) {
+	for (const name of WRANGLER_CONFIG_FILES) {
+		const candidate = resolve(root, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+function printVercelGuidance() {
+	console.log([
+		"",
+		"  The Vercel adapter has no faithful local production runtime, so `pracht preview` does not emulate it.",
+		"",
+		"  To exercise the Vercel build output locally, use Vercel's own tooling:",
+		"",
+		"    vercel build   # reproduce the production build (.vercel/output) with your project settings",
+		"    vercel dev     # run a local Vercel development environment",
+		"",
+		"  To ship the output of `pracht build`, run: vercel deploy --prebuilt",
+		""
+	].join("\n"));
+}
+function spawnPreviewProcess(command, commandArgs, options) {
+	const child = spawn(command, commandArgs, {
+		cwd: options.cwd,
+		env: options.env ?? process.env,
+		stdio: "inherit"
+	});
+	child.on("close", (code) => {
+		process.exitCode = code ?? 0;
+	});
+	child.on("error", (error) => {
+		console.error(`Failed to start preview process: ${error.message}`);
+		process.exitCode = 1;
+	});
+}
+//#endregion
+export { preview_default as default };

package/dist/rolldown-runtime-wcPFST8Q.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/{typegen-Bl4fYQIy.mjs → typegen-KYYNjYDt.mjs}

@@ -1,5 +1,5 @@
-import { f as ensureTrailingNewline, n as displayPath, p as handleCliError } from "./project-voPTS9UC.mjs";
-import { runInspect } from "./inspect-WF08uLOl.mjs";
+import { a as readProjectConfig, c as resolveProjectPath, f as ensureTrailingNewline, n as displayPath, p as handleCliError } from "./project-2EajzTuX.mjs";
+import { n as runInspect } from "./inspect-Bxt-6Lmc.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
@@ -60,11 +60,16 @@ async function runTypegen(options) {
 	const report = await runInspect(options.root, { target: "routes" });
 	const routes = report.routes ?? [];
 	validateRoutes(routes);
+	const project = readProjectConfig(options.root);
 	const declarationPath = resolveOutputPath(options.root, options.declarationOut);
 	const runtimePath = resolveOutputPath(options.root, options.runtimeOut);
 	const outputs = [{
 		path: declarationPath,
-		source: buildDeclarationSource(routes)
+		source: buildDeclarationSource(routes, {
+			appDir: dirname(resolveProjectPath(options.root, project.appFile)),
+			declarationDir: dirname(declarationPath),
+			root: options.root
+		})
 	}, {
 		path: runtimePath,
 		source: buildRuntimeSource(routes)
@@ -96,11 +101,11 @@ function validateRoutes(routes) {
 		inferRouteParams(route.path);
 	}
 }
-function buildDeclarationSource(routes) {
+function buildDeclarationSource(routes, context) {
 	const lines = [
 		"// Generated by `pracht typegen`. Do not edit manually.",
 		"import \"@pracht/core\";",
-		"import type { RouteParamInput, SearchParamsInput } from \"@pracht/core\";",
+		"import type { RouteLoaderData, RouteParamInput, SearchParamsInput } from \"@pracht/core\";",
 		"",
 		"declare module \"@pracht/core\" {",
 		"  interface Register {",
@@ -111,6 +116,7 @@ function buildDeclarationSource(routes) {
 		lines.push(`        path: ${JSON.stringify(route.path)};`);
 		lines.push(`        params: ${formatParamsType(inferRouteParams(route.path))};`);
 		lines.push("        search: SearchParamsInput;");
+		lines.push(`        data: ${formatRouteDataType(route, context)};`);
 		lines.push("      };");
 	}
 	lines.push("    };");
@@ -155,6 +161,20 @@ function inferRouteParams(path) {
 	}
 	return params;
 }
+const IMPORTABLE_MODULE_PATTERN = /\.(ts|tsx|js|jsx)$/;
+function formatRouteDataType(route, context) {
+	const routeModule = formatModuleSpecifier(route.file, context);
+	const loaderModule = route.loaderFile ? formatModuleSpecifier(route.loaderFile, context) : null;
+	if (loaderModule) return routeModule ? `RouteLoaderData<typeof import(${loaderModule}), typeof import(${routeModule})>` : `RouteLoaderData<typeof import(${loaderModule})>`;
+	return routeModule ? `RouteLoaderData<typeof import(${routeModule})>` : "unknown";
+}
+function formatModuleSpecifier(file, context) {
+	if (!IMPORTABLE_MODULE_PATTERN.test(file)) return null;
+	const absolutePath = file.startsWith("/") ? resolveProjectPath(context.root, file) : resolve(context.appDir, file);
+	const relativePath = relative(context.declarationDir, absolutePath).replace(/\\/g, "/").replace(IMPORTABLE_MODULE_PATTERN, "");
+	const specifier = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+	return JSON.stringify(specifier);
+}
 function formatParamsType(params) {
 	if (params.length === 0) return "Record<never, never>";
 	return `{ ${params.map((param) => `${JSON.stringify(param)}: RouteParamInput;`).join(" ")} }`;

package/dist/{verification-CSj-ngqk.mjs → verification-5w_FfRtE.mjs}

@@ -1,5 +1,6 @@
-import { a as readProjectConfig, c as resolveProjectPath, i as listFilesRecursively, n as displayPath, r as hasPagesAppShell } from "./project-voPTS9UC.mjs";
-import { n as extractRegistryEntries, r as extractRelativeModulePaths } from "./manifest-Bs5hp3gA.mjs";
+import { a as formatBytes } from "./bundle-report-DxTtmipa.mjs";
+import { a as readProjectConfig, c as resolveProjectPath, i as listFilesRecursively, n as displayPath, r as hasPagesAppShell } from "./project-2EajzTuX.mjs";
+import { n as extractRegistryEntries, r as extractRelativeModulePaths } from "./manifest-nU7P84qF.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { execFileSync } from "node:child_process";
@@ -230,6 +231,25 @@ function collectApiVerification(project, checks, { changedFiles, scope }) {
 		checks.push(createCheck("ok", `Changed API route ${JSON.stringify(display)} resolves to ${JSON.stringify(resolveApiRoutePath(apiDir, file))}.`));
 	}
 }
+function collectBudgetChecks(project, checks) {
+	const reportPath = resolve(project.root, "dist/server/budget-report.json");
+	if (!existsSync(reportPath)) return;
+	let report;
+	try {
+		report = JSON.parse(readFileSync(reportPath, "utf-8"));
+	} catch {
+		checks.push(createCheck("warning", "dist/server/budget-report.json exists but could not be parsed."));
+		return;
+	}
+	const results = report.results ?? [];
+	if (results.length === 0) return;
+	const failed = results.filter((result) => !result.ok);
+	if (failed.length === 0) {
+		checks.push(createCheck("ok", `All ${results.length} route client JS budget${results.length === 1 ? "" : "s"} pass (from the last \`pracht build\`).`));
+		return;
+	}
+	for (const result of failed) checks.push(createCheck("error", `Route ${JSON.stringify(result.path)} exceeds its client JS budget: ${formatBytes(result.gzipBytes)} gzip > ${formatBytes(result.limitBytes)} (from the last \`pracht build\`).`));
+}
 function collectPackageChecks(project, checks, packageJsonPath) {
 	if (!existsSync(packageJsonPath)) {
 		checks.push(createCheck("warning", "No package.json found in the current app root."));
@@ -365,6 +385,7 @@ function runVerification(root, options = {}) {
 		scope
 	});
 	collectPackageChecks(project, checks, packageJsonPath);
+	collectBudgetChecks(project, checks);
 	if (options.changed && frameworkFiles.length === 0 && !changedInfo.warning) checks.push(createCheck("ok", "No changed framework files were detected in the current project scope."));
 	return {
 		checks,

package/dist/{verify-FwVbdlxh.mjs → verify-B_HUuyEQ.mjs}

@@ -1,4 +1,4 @@
-import { n as runVerification } from "./verification-CSj-ngqk.mjs";
+import { n as runVerification } from "./verification-5w_FfRtE.mjs";
 import { defineCommand } from "citty";
 //#region src/commands/verify.ts
 var verify_default = defineCommand({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pracht/cli",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "CLI for developing, building, validating, inspecting, and scaffolding Pracht apps.",
   "keywords": [
     "pracht",
@@ -38,8 +38,10 @@
     "provenance": true
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "citty": "^0.1.6",
-    "@pracht/core": "0.8.1"
+    "zod": "^4.4.3",
+    "@pracht/core": "0.9.0"
   },
   "scripts": {
     "build": "tsdown"

package/dist/build-B7_6RUBf.mjs

@@ -1,234 +0,0 @@
-import { r as VERSION } from "./index.mjs";
-import { t as readClientBuildAssets } from "./build-metadata-BOChHO8g.mjs";
-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
-var build_default = defineCommand({
-	meta: {
-		name: "build",
-		description: "Production build (client + server)"
-	},
-	async run() {
-		const root = process.cwd();
-		console.log("\n  Building client...\n");
-		await build({
-			root,
-			build: {
-				outDir: "dist",
-				manifest: true,
-				rollupOptions: { input: "virtual:pracht/client" }
-			}
-		});
-		console.log("\n  Building server...\n");
-		await build({
-			root,
-			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 });
-		if (existsSync(serverEntry)) {
-			const serverMod = await import(pathToFileURL(serverEntry).href);
-			const { prerenderApp } = serverMod;
-			const { clientEntryUrl, 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) {
-				console.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");
-					console.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");
-				console.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");
-				console.log("\n  Cloudflare worker → dist/server/server.js\n");
-				console.log("  Deploy with: wrangler deploy\n");
-			}
-			if (serverMod.buildTarget === "vercel") {
-				const outputPath = writeVercelBuildOutput({
-					functionName: serverMod.vercelFunctionName,
-					isgRoutes: Object.keys(isgManifest),
-					headersManifest,
-					regions: serverMod.vercelRegions,
-					root,
-					staticRoutes: pages.map((page) => page.path).filter((path) => !(path in isgManifest))
-				});
-				console.log(`\n  Vercel build output → ${outputPath}\n`);
-			}
-		}
-		console.log("\n  Build complete.\n");
-	}
-});
-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 };

package/dist/dev-BCFe3g38.mjs

@@ -1,25 +0,0 @@
-import { defineCommand } from "citty";
-import { createServer } from "vite";
-//#region src/commands/dev.ts
-var dev_default = defineCommand({
-	meta: {
-		name: "dev",
-		description: "Start development server with HMR"
-	},
-	args: { port: {
-		type: "positional",
-		description: "Port number",
-		required: false
-	} },
-	async run({ args }) {
-		const port = parseInt(process.env.PORT || args.port || "3000", 10);
-		const server = await createServer({
-			root: process.cwd(),
-			server: { port }
-		});
-		await server.listen();
-		server.printUrls();
-	}
-});
-//#endregion
-export { dev_default as default };