@junejs/server 0.1.0-dev.4 → 0.1.0-dev.7

package/dist/build.js

@@ -0,0 +1,582 @@
+import { deno, staticSite, vercel, workers } from "./adapter.js";
+import { findMiddlewareFile } from "./router.js";
+import { resolveBoundary } from "./segment.js";
+import { buildModuleCss, registerCssModules, rolldownCssModulesPlugin } from "./css-modules.js";
+import { jsxTransform } from "./tsconfig-jsx.js";
+import { CLIENT_SCRIPT_URL, bundleClientToFile, findClientEntry } from "./client-bundle.js";
+import { generateIslandRegistry } from "./island-registry.js";
+import { STYLES_URL, cssTargets, findGlobalCss, globalCssUsesTailwind, minifyCss, processCss } from "./css.js";
+import { RESERVED_PREFIX } from "./static-files.js";
+import { findJuneConfigPath, loadJuneConfig } from "./config-loader.js";
+import { generateContentModule } from "./content.js";
+import { createWorker } from "./worker.js";
+import { buildRsc, findRscRoutes } from "./rsc-build.js";
+import { existsSync, lstatSync } from "node:fs";
+import { copyFile, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { routeFromModule } from "@junejs/core/route";
+import { resolveAgent, resolveClientRouter, resolveSpeculationRules } from "@junejs/core/config";
+import { buildLinkHeader } from "@junejs/core/discovery";
+import { localeHref } from "@junejs/core/i18n";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+//#region src/build.ts
+const PAGE_BASENAMES = /* @__PURE__ */ new Set(["page", "index"]);
+const ROUTE_EXTS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+const isRouteGroup = (name) => /^\(.+\)$/.test(name);
+const isBunSpecifier = (id) => id === "bun" || id.startsWith("bun:");
+function resolveDeployAdapter(deploy) {
+	if (deploy?.adapter) return deploy.adapter;
+	switch (deploy?.target) {
+		case "static": return staticSite();
+		case "vercel": return vercel();
+		case "deno": return deno();
+		default: return workers({
+			name: deploy?.name,
+			domain: deploy?.domain
+		});
+	}
+}
+function segmentFile(dir, base) {
+	return ROUTE_EXTS.map((e) => join(dir, `${base}${e}`)).find(existsSync);
+}
+async function scanRoutes(appDir, dir = appDir, layouts = [], out = [], loading) {
+	const ownLayout = segmentFile(dir, "layout");
+	const chain = ownLayout ? [...layouts, ownLayout] : layouts;
+	const nearestLoading = segmentFile(dir, "loading") ?? loading;
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	for (const e of entries) {
+		if (e.name.startsWith("_") || e.name.startsWith(".")) continue;
+		const full = join(dir, e.name);
+		if (e.isDirectory()) {
+			await scanRoutes(appDir, full, chain, out, nearestLoading);
+			continue;
+		}
+		const ext = e.name.match(/\.[^.]+$/)?.[0] ?? "";
+		if (!ROUTE_EXTS.includes(ext)) continue;
+		const base = basename(e.name, ext);
+		const resource = base === "route";
+		if (!PAGE_BASENAMES.has(base) && !resource) continue;
+		const relDir = relative(appDir, dir);
+		const path = "/" + (relDir === "" ? [] : relDir.split(sep).filter((s) => !isRouteGroup(s))).join("/");
+		out.push({
+			path: path === "/" ? "/" : path,
+			file: full,
+			dynamic: /\[.+\]/.test(path),
+			resource,
+			layouts: chain,
+			loading: nearestLoading
+		});
+	}
+	return out;
+}
+async function generateContent(appRoot) {
+	const contentDir = join(appRoot, "content");
+	await mkdir(join(appRoot, "app"), { recursive: true });
+	const emit = async (sources, knownLocales) => {
+		const { code, names } = generateContentModule(contentDir, knownLocales, sources);
+		await writeFile(join(appRoot, "app", "_content.ts"), code);
+		return names;
+	};
+	const resolveSources = (sources) => sources.map((s) => ({
+		...s,
+		dir: resolve(appRoot, s.dir)
+	}));
+	const declaredLocales = (config) => config.i18n ? [.../* @__PURE__ */ new Set([config.i18n.defaultLocale, ...Object.keys(config.i18n.locales)])] : [];
+	let config = null;
+	try {
+		config = await loadJuneConfig(appRoot);
+	} catch {}
+	if (config) return emit(resolveSources(config.content?.sources ?? []), declaredLocales(config));
+	const names = await emit([], void 0);
+	await seedContentImports(appRoot);
+	const probed = probeConfigFresh(appRoot);
+	if (probed === null) {
+		console.warn("[june gen] june.config.ts failed to load — content.sources/i18n locales (if any) not applied");
+		return names;
+	}
+	return emit(resolveSources(probed.sources), probed.locales);
+}
+async function seedContentImports(appRoot) {
+	const cfgPath = findJuneConfigPath(appRoot);
+	if (!cfgPath) return;
+	const contentFile = join(appRoot, "app", "_content.ts");
+	const current = existsSync(contentFile) ? await readFile(contentFile, "utf8") : "";
+	const cfgSrc = await readFile(cfgPath, "utf8");
+	const isIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
+	const seen = /* @__PURE__ */ new Set();
+	const stubs = [];
+	for (const m of cfgSrc.matchAll(/import\s*(?:type\s+)?\{([^}]*)\}\s*from\s*["'][^"']*app\/_content(?:\.\w+)?["']/g)) {
+		const inner = (m[1] ?? "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+		for (const part of inner.split(",")) {
+			const name = part.replace(/\btype\b/g, "").split(/\s+as\s+/).pop()?.trim();
+			if (!name || !isIdent(name) || seen.has(name)) continue;
+			seen.add(name);
+			const reName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			if (!new RegExp(`export (?:const|function|type) ${reName}\\b`).test(current)) stubs.push(`export const ${name}: ContentEntry[] = [];`);
+		}
+	}
+	if (stubs.length) await writeFile(contentFile, current + stubs.join("\n") + "\n");
+}
+function probeConfigFresh(appRoot) {
+	const path = findJuneConfigPath(appRoot);
+	if (!path) return {
+		sources: [],
+		locales: []
+	};
+	const code = `import(${JSON.stringify(pathToFileURL(path).href)}).then((m) => { const c = m.default ?? {}; process.stdout.write("\\n__JUNE_CONTENT__" + JSON.stringify({ sources: c.content?.sources ?? [], locales: c.i18n ? [...new Set([c.i18n.defaultLocale, ...Object.keys(c.i18n.locales ?? {})])] : [] }) + "__END__"); }, () => process.exit(42));`;
+	try {
+		const m = execFileSync(process.execPath, [
+			...process.execArgv,
+			"-e",
+			code
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).match(/__JUNE_CONTENT__(.*?)__END__/s);
+		return m ? JSON.parse(m[1]) : null;
+	} catch {
+		return null;
+	}
+}
+async function freezeConfig(appRoot) {
+	const cfg = await loadJuneConfig(appRoot);
+	const hasClient = findClientEntry(join(appRoot, "app")) !== void 0 || findClientEntry(join(appRoot, ".june", "routes")) !== void 0;
+	const hasCss = findGlobalCss(join(appRoot, "app")) !== null;
+	return {
+		document: {
+			site: cfg.site ?? {},
+			speculationRules: resolveSpeculationRules(cfg.speculation ?? void 0),
+			speculationDelivery: "inline",
+			viewTransitions: cfg.viewTransitions ?? true,
+			cssReset: cfg.cssReset ?? !globalCssUsesTailwind(join(appRoot, "app")),
+			clientRouter: resolveClientRouter(cfg.clientRouter),
+			clientScript: hasClient ? CLIENT_SCRIPT_URL : null,
+			styles: hasCss ? STYLES_URL : null,
+			basePath: normalizeBase(cfg.basePath)
+		},
+		agent: resolveAgent(cfg.agent),
+		i18n: cfg.i18n,
+		earlyHints: cfg.earlyHints ?? [],
+		buildExternal: cfg.build?.external ?? []
+	};
+}
+function normalizeBase(base) {
+	if (!base) return "";
+	const b = base.startsWith("/") ? base : `/${base}`;
+	return b.endsWith("/") ? b.slice(0, -1) : b;
+}
+async function importLayout(file) {
+	const mod = await import(pathToFileURL(file).href);
+	return typeof mod.default === "function" ? {
+		component: mod.default,
+		boundary: mod.segmentBoundary === true
+	} : null;
+}
+function workerName(raw) {
+	return raw.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+async function buildManifest(appRoot) {
+	const appDir = join(appRoot, "app");
+	const juneRoutesDir = join(appRoot, ".june", "routes");
+	const frozen = await freezeConfig(appRoot);
+	const appRoutes = await scanRoutes(appDir);
+	const frameworkRoutes = existsSync(juneRoutesDir) ? await scanRoutes(juneRoutesDir) : [];
+	const appPaths = new Set(appRoutes.map((r) => r.path));
+	const scanned = [...appRoutes, ...frameworkRoutes.filter((r) => !appPaths.has(r.path))].sort((a, b) => a.path.localeCompare(b.path));
+	const layoutCache = /* @__PURE__ */ new Map();
+	const loadCached = async (f) => {
+		if (!layoutCache.has(f)) layoutCache.set(f, await importLayout(f));
+		return layoutCache.get(f) ?? null;
+	};
+	const componentsFor = async (files) => {
+		const items = [];
+		for (const f of files) {
+			const c = await loadCached(f);
+			items.push({
+				file: f,
+				entry: c?.component ?? null,
+				boundary: !!c?.boundary
+			});
+		}
+		return resolveBoundary(items);
+	};
+	const loadingCache = /* @__PURE__ */ new Map();
+	const loadingFor = async (file) => {
+		if (!file) return void 0;
+		if (!loadingCache.has(file)) {
+			const loaded = await importLayout(file);
+			loadingCache.set(file, loaded ? loaded.component : null);
+		}
+		return loadingCache.get(file) ?? void 0;
+	};
+	const routes = {};
+	const dynamicRoutes = [];
+	const resourceRoutes = [];
+	const layoutChains = {};
+	const layoutBoundaries = {};
+	const loadings = {};
+	for (const r of scanned) {
+		const mod = await import(pathToFileURL(r.file).href);
+		if (r.resource) {
+			const handler = mod.default;
+			if (typeof handler === "function") resourceRoutes.push({
+				pattern: r.path,
+				handler
+			});
+			continue;
+		}
+		const def = routeFromModule(mod);
+		if (!def) continue;
+		const { chain, boundaryIndex, key } = await componentsFor(r.layouts);
+		const loading = await loadingFor(r.loading);
+		if (r.dynamic) {
+			dynamicRoutes.push({
+				pattern: r.path,
+				def
+			});
+			layoutChains[r.path] = chain;
+		} else {
+			routes[r.path] = def;
+			layoutChains[r.path] = chain;
+		}
+		if (boundaryIndex !== null && key !== null) layoutBoundaries[r.path] = {
+			index: boundaryIndex,
+			key
+		};
+		if (loading) loadings[r.path] = loading;
+	}
+	let extra;
+	const extraFile = findMiddlewareFile(appDir);
+	if (extraFile) {
+		const mod = await import(pathToFileURL(extraFile).href);
+		if (typeof mod.default === "function") extra = mod.default;
+	}
+	return {
+		routes,
+		dynamicRoutes,
+		resourceRoutes,
+		layoutChains,
+		layoutBoundaries,
+		loadings,
+		document: frozen.document,
+		agent: frozen.agent,
+		i18n: frozen.i18n,
+		earlyHints: frozen.earlyHints,
+		extra
+	};
+}
+function importPath(fromDir, file) {
+	const p = relative(fromDir, file).split(sep).join("/").replace(/\.[^.]+$/, "");
+	return p.startsWith(".") ? p : `./${p}`;
+}
+async function collectFiles(dir, base = dir) {
+	const out = [];
+	for (const entry of await readdir(dir, { withFileTypes: true })) {
+		const abs = join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...await collectFiles(abs, base));
+		else if (entry.isFile()) out.push(relative(base, abs).split(sep).join("/"));
+	}
+	return out;
+}
+async function juneBuild(appRoot, options = {}) {
+	const appDir = join(appRoot, "app");
+	if (!existsSync(appDir)) throw new Error(`no app/ directory in ${appRoot} — is this a June app?`);
+	const genDir = join(appRoot, ".june");
+	const outDir = options.outDir ?? join(appRoot, "dist");
+	await mkdir(genDir, { recursive: true });
+	await rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	const contentCollections = await generateContent(appRoot);
+	const juneRoutesDir2 = join(appRoot, ".june", "routes");
+	const appRoutes2 = await scanRoutes(appDir);
+	const frameworkRoutes2 = existsSync(juneRoutesDir2) ? await scanRoutes(juneRoutesDir2) : [];
+	const appPaths2 = new Set(appRoutes2.map((r) => r.path));
+	const routes = [...appRoutes2, ...frameworkRoutes2.filter((r) => !appPaths2.has(r.path))].sort((a, b) => a.path.localeCompare(b.path));
+	if (routes.length === 0) throw new Error(`no page.* routes found under ${appDir} or .june/routes/`);
+	const frozen = await freezeConfig(appRoot);
+	if (frozen.i18n?.resolveLocale) console.warn("[june build] i18n.resolveLocale is not yet wired into the built worker (URL-pinned + built-in negotiation work; the hook runs in dev only).");
+	const fullConfig = await loadJuneConfig(appRoot);
+	const adapter = resolveDeployAdapter(fullConfig.deploy);
+	adapter.validate?.({
+		plan: { db: fullConfig.resources?.db ? {
+			binding: "DB",
+			databaseName: ""
+		} : void 0 },
+		config: fullConfig
+	});
+	const cssOut = await processCss(appDir, { minify: true });
+	let cssAsset = null;
+	if (cssOut !== null) {
+		cssAsset = `_june/global.${createHash("sha256").update(cssOut).digest("hex").slice(0, 8)}.css`;
+		frozen.document.styles = `/${cssAsset}`;
+	}
+	const { maps: cssModuleMaps, css: rawModuleCss } = await buildModuleCss(appDir, appRoot);
+	const moduleCss = rawModuleCss === null ? null : await minifyCss(rawModuleCss, "modules.css", await cssTargets(appDir));
+	let moduleCssAsset = null;
+	if (moduleCss !== null) {
+		moduleCssAsset = `_june/modules.${createHash("sha256").update(moduleCss).digest("hex").slice(0, 8)}.css`;
+		frozen.document.moduleStyles = `/${moduleCssAsset}`;
+	}
+	const assetsDir = join(outDir, "assets");
+	const clientEntry = findClientEntry(appDir) ?? findClientEntry(join(appRoot, ".june", "routes"));
+	let clientAsset = null;
+	if (clientEntry) {
+		await generateIslandRegistry(appDir);
+		clientAsset = await bundleClientToFile(clientEntry, appRoot, assetsDir, cssModuleMaps);
+		frozen.document.clientScript = `/${clientAsset}`;
+	}
+	if (findRscRoutes(appDir).length > 0) await buildRsc(appRoot, outDir, frozen.document);
+	const resourcesCfg = fullConfig.resources;
+	const hasResources = !!(resourcesCfg?.db || resourcesCfg?.kv || resourcesCfg?.blob);
+	const imports = [`import { createWorker } from "@junejs/server/worker";`, `import { routeFromModule } from "@junejs/core/route";`];
+	const statics = [];
+	const dynamics = [];
+	const layoutIds = /* @__PURE__ */ new Map();
+	const layoutId = (file) => {
+		let id = layoutIds.get(file);
+		if (!id) {
+			id = `L${layoutIds.size}`;
+			layoutIds.set(file, id);
+			imports.push(`import ${id} from ${JSON.stringify(importPath(genDir, file))};`);
+		}
+		return id;
+	};
+	const loadingIds = /* @__PURE__ */ new Map();
+	const loadingId = (file) => {
+		let id = loadingIds.get(file);
+		if (!id) {
+			id = `Ld${loadingIds.size}`;
+			loadingIds.set(file, id);
+			imports.push(`import ${id} from ${JSON.stringify(importPath(genDir, file))};`);
+		}
+		return id;
+	};
+	const layoutInfo = /* @__PURE__ */ new Map();
+	for (const f of new Set(routes.flatMap((r) => r.resource ? [] : r.layouts))) layoutInfo.set(f, await importLayout(f));
+	const chains = [];
+	const boundaries = [];
+	const loadings = [];
+	const resources = [];
+	routes.forEach((r, i) => {
+		if (r.resource) {
+			imports.push(`import h${i} from ${JSON.stringify(importPath(genDir, r.file))};`);
+			resources.push(`    { pattern: ${JSON.stringify(r.path)}, handler: h${i} },`);
+			return;
+		}
+		imports.push(`import * as r${i} from ${JSON.stringify(importPath(genDir, r.file))};`);
+		if (r.dynamic) dynamics.push(`    { pattern: ${JSON.stringify(r.path)}, def: routeFromModule(r${i}) },`);
+		else statics.push(`    ${JSON.stringify(r.path)}: routeFromModule(r${i}),`);
+		const { chain, boundaryIndex, key } = resolveBoundary(r.layouts.map((f) => {
+			const info = layoutInfo.get(f) ?? null;
+			return {
+				file: f,
+				entry: info ? layoutId(f) : null,
+				boundary: !!info?.boundary
+			};
+		}));
+		chains.push(`    ${JSON.stringify(r.path)}: [${chain.join(", ")}],`);
+		if (boundaryIndex !== null && key !== null) boundaries.push(`    ${JSON.stringify(r.path)}: { index: ${boundaryIndex}, key: ${JSON.stringify(key)} },`);
+		if (r.loading) loadings.push(`    ${JSON.stringify(r.path)}: ${loadingId(r.loading)},`);
+	});
+	const resourceRoutesField = resources.length ? `\n  resourceRoutes: [\n${resources.join("\n")}\n  ],` : "";
+	const layoutBoundariesField = boundaries.length ? `\n  layoutBoundaries: {\n${boundaries.join("\n")}\n  },` : "";
+	const builtExtraFile = findMiddlewareFile(appDir);
+	if (builtExtraFile) imports.push(`import extra from ${JSON.stringify(importPath(genDir, builtExtraFile))};`);
+	const linkHeader = buildLinkHeader(frozen.agent);
+	const adapterEntry = adapter.entry({ linkHeader });
+	const resourceFlags = {
+		db: !!resourcesCfg?.db,
+		kv: !!resourcesCfg?.kv,
+		blob: !!resourcesCfg?.blob
+	};
+	const tursoDb = resourcesCfg?.db?.kind === "turso";
+	if (tursoDb) {
+		imports.push(`import { turso } from "@junejs/server/db";`);
+		imports.push(`import { memoizeResources } from "@junejs/server/resources";`);
+	} else if (hasResources) imports.push(`import { bindWorkerResources } from "@junejs/server/resources";`);
+	const resourcesField = tursoDb ? `\n  resources: memoizeResources({ db: turso() }),` : hasResources ? `\n  resources: bindWorkerResources(${JSON.stringify(resourceFlags)}),` : "";
+	const dataLayerModule = fullConfig.dataLayer?.module;
+	if (dataLayerModule) imports.push(`import { installDataLayer } from ${JSON.stringify(dataLayerModule)};`);
+	const dataLayerBoot = dataLayerModule ? "\ninstallDataLayer();\n" : "";
+	const entry = `// AUTO-GENERATED by \`june build\` — do not edit. Regenerate: june build .
+${adapterEntry.imports.join("\n")}
+${imports.join("\n")}
+${dataLayerBoot}
+const pipeline = createWorker({
+  routes: {
+${statics.join("\n")}
+  },
+  dynamicRoutes: [
+${dynamics.join("\n")}
+  ],${resourceRoutesField}
+  layoutChains: {
+${chains.join("\n")}
+  },${layoutBoundariesField}
+  loadings: {
+${loadings.join("\n")}
+  },
+  document: ${JSON.stringify(frozen.document, null, 2).replace(/\n/g, "\n  ")},
+  agent: ${JSON.stringify(frozen.agent)},${frozen.i18n ? `\n  i18n: ${JSON.stringify(frozen.i18n)},` : ""}
+  earlyHints: ${JSON.stringify(frozen.earlyHints)},${builtExtraFile ? "\n  extra," : ""}${resourcesField}
+});
+
+${adapterEntry.wrap("pipeline")}
+`;
+	const entryFile = join(genDir, "worker-entry.tsx");
+	await writeFile(entryFile, entry);
+	const { rolldown } = await import("rolldown");
+	const bundle = await rolldown({
+		input: entryFile,
+		cwd: appRoot,
+		platform: "browser",
+		transform: {
+			define: { "process.env.NODE_ENV": JSON.stringify("production") },
+			jsx: await jsxTransform(appRoot)
+		},
+		plugins: [rolldownCssModulesPlugin(cssModuleMaps)],
+		external: (id) => {
+			if (isBunSpecifier(id)) return true;
+			if (/\.(wasm|ttf|otf|woff2?|png|jpe?g|avif|webp)$/.test(id)) return true;
+			return [...adapter.buildExternal ?? [], ...options.external ?? frozen.buildExternal].some((e) => id === e || id.startsWith(`${e}/`));
+		},
+		resolve: { conditionNames: adapter.conditions }
+	});
+	const result = await bundle.write({
+		dir: outDir,
+		format: "esm",
+		entryFileNames: "worker.js"
+	});
+	await bundle.close();
+	const outFile = join(outDir, result.output.find((o) => o.type === "chunk" && o.isEntry)?.fileName ?? "worker.js");
+	const prerendered = [];
+	await registerCssModules(cssModuleMaps);
+	const manifest = await buildManifest(appRoot);
+	if (cssAsset) manifest.document.styles = `/${cssAsset}`;
+	if (clientAsset) manifest.document.clientScript = `/${clientAsset}`;
+	if (moduleCssAsset) manifest.document.moduleStyles = `/${moduleCssAsset}`;
+	const worker = createWorker(manifest);
+	let hasAssets = false;
+	const publicDir = join(appRoot, "public");
+	const publicFiles = [];
+	let publicIsDir = false;
+	try {
+		publicIsDir = lstatSync(publicDir).isDirectory();
+	} catch {}
+	if (existsSync(publicDir) && !publicIsDir) console.warn(`[june] public/ is not a real directory (symlink?) — skipped`);
+	if (publicIsDir) {
+		for (const rel of await collectFiles(publicDir)) {
+			if (rel.split("/")[0] === "_june") {
+				console.warn(`[june] public/${rel} ignored — ${RESERVED_PREFIX}/ is reserved for framework assets`);
+				continue;
+			}
+			const dest = join(assetsDir, rel);
+			await mkdir(dirname(dest), { recursive: true });
+			await copyFile(join(publicDir, ...rel.split("/")), dest);
+			publicFiles.push(rel);
+		}
+		if (publicFiles.length) hasAssets = true;
+	}
+	const isStatic = adapter.capabilities.runtime === "static";
+	const i18n = frozen.i18n;
+	const prerenderOne = async (reqPath, def) => {
+		const stem = reqPath === "/" ? "index" : reqPath.slice(1);
+		const htmlFile = isStatic ? reqPath === "/" ? "index.html" : `${stem}/index.html` : `${stem}.html`;
+		const isHome = reqPath === "/" || i18n != null && Object.keys(i18n.locales).some((l) => localeHref(i18n, "/", l) === reqPath);
+		const mdReq = reqPath === "/" ? "/index.md" : isHome ? `${reqPath}/index.md` : `${reqPath}.md`;
+		const jsonReq = reqPath === "/" ? "/index.json" : isHome ? `${reqPath}/index.json` : `${reqPath}.json`;
+		const mdFile = reqPath === "/" ? "index.md" : isHome ? `${stem}/index.md` : `${stem}.md`;
+		const jsonFile = reqPath === "/" ? "index.json" : isHome ? `${stem}/index.json` : `${stem}.json`;
+		const targets = [[reqPath, htmlFile]];
+		if (def.md !== false) targets.push([mdReq, mdFile]);
+		if (typeof def.json === "function") targets.push([jsonReq, jsonFile]);
+		for (const [rp, file] of targets) {
+			const res = await worker.fetch(new Request(`https://prerender.june${rp}`));
+			if (!res.ok) throw new Error(`prerender ${rp} → ${res.status}`);
+			const dest = join(assetsDir, file);
+			await mkdir(dirname(dest), { recursive: true });
+			await writeFile(dest, Buffer.from(await res.arrayBuffer()));
+		}
+		prerendered.push(reqPath);
+		hasAssets = true;
+	};
+	const localeVariants = (path) => isStatic && i18n ? [...new Set(Object.keys(i18n.locales).map((l) => localeHref(i18n, path, l)))] : [path];
+	for (const r of routes.filter((x) => !x.dynamic)) {
+		const def = manifest.routes[r.path];
+		if (!def) continue;
+		if (!isStatic && !def.prerender) continue;
+		for (const p of localeVariants(r.path)) await prerenderOne(p, def);
+	}
+	if (isStatic) {
+		for (const dyn of manifest.dynamicRoutes ?? []) {
+			const sp = dyn.def.staticPaths;
+			if (!sp) continue;
+			const paths = typeof sp === "function" ? await sp() : sp;
+			for (const p of paths) await prerenderOne(p, dyn.def);
+		}
+		for (const [reqPath, file] of [
+			["/favicon.svg", "favicon.svg"],
+			["/llms.txt", "llms.txt"],
+			["/sitemap.xml", "sitemap.xml"]
+		]) {
+			const res = await worker.fetch(new Request(`https://prerender.june${reqPath}`));
+			if (!res.ok) continue;
+			await writeFile(join(assetsDir, file), Buffer.from(await res.arrayBuffer()));
+			hasAssets = true;
+		}
+		const nf = await worker.fetch(new Request("https://prerender.june/__june_not_found__"));
+		await writeFile(join(assetsDir, "404.html"), Buffer.from(await nf.arrayBuffer()));
+		hasAssets = true;
+	}
+	if (clientAsset) hasAssets = true;
+	if (cssOut !== null && cssAsset) {
+		const dest = join(assetsDir, cssAsset);
+		await mkdir(dirname(dest), { recursive: true });
+		await writeFile(dest, cssOut);
+		hasAssets = true;
+	}
+	if (moduleCss !== null && moduleCssAsset) {
+		const dest = join(assetsDir, moduleCssAsset);
+		await mkdir(dirname(dest), { recursive: true });
+		await writeFile(dest, moduleCss);
+		hasAssets = true;
+	}
+	const pkgPath = join(appRoot, "package.json");
+	const defaultName = workerName((existsSync(pkgPath) ? JSON.parse(await Bun.file(pkgPath).text()).name : void 0) ?? basename(appRoot));
+	const plan = resourcesCfg?.db && resourcesCfg.db.kind !== "turso" ? { db: {
+		binding: "DB",
+		databaseName: `${defaultName}-db`
+	} } : {};
+	await adapter.emit({
+		appRoot,
+		outDir,
+		hasAssets,
+		linkHeader,
+		config: fullConfig,
+		plan,
+		defaultName,
+		publicFiles
+	});
+	if (plan.db) console.log(`  ↳ d1 binding "${plan.db.binding}" emitted — set database_id in wrangler.jsonc (wrangler d1 create ${plan.db.databaseName})`);
+	return {
+		outFile,
+		routes: routes.filter((r) => !r.dynamic).map((r) => r.path),
+		dynamicRoutes: routes.filter((r) => r.dynamic).map((r) => r.path),
+		contentCollections,
+		prerendered
+	};
+}
+//#endregion
+export { buildManifest, freezeConfig, generateContent, isBunSpecifier, juneBuild, normalizeBase, resolveDeployAdapter, scanRoutes, workerName };

package/dist/client-bundle.d.ts

@@ -0,0 +1,15 @@
+import { ModuleMaps } from "./css-modules.js";
+//#region src/client-bundle.d.ts
+declare const CLIENT_SCRIPT_URL = "/_june/client.js";
+declare function findClientEntry(appDir: string): string | undefined;
+type BundleMode = "development" | "production";
+declare function isExpectedClientLog(log: {
+  code?: string;
+  exporter?: string;
+}): boolean;
+type ClientChunks = Map<string, string>;
+declare function bundleClientSplit(entryFile: string, cwd: string, mode: BundleMode, maps?: ModuleMaps): Promise<ClientChunks>;
+declare function bundleClientToString(entryFile: string, cwd: string, maps?: ModuleMaps): Promise<string>;
+declare function bundleClientToFile(entryFile: string, cwd: string, destDir: string, maps?: ModuleMaps): Promise<string>;
+//#endregion
+export { CLIENT_SCRIPT_URL, ClientChunks, bundleClientSplit, bundleClientToFile, bundleClientToString, findClientEntry, isExpectedClientLog };

package/dist/client-bundle.js

@@ -0,0 +1,91 @@
+import { rolldownCssModulesPlugin } from "./css-modules.js";
+import { jsxTransform } from "./tsconfig-jsx.js";
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+//#region src/client-bundle.ts
+const CLIENT_SCRIPT_URL = "/_june/client.js";
+const CLIENT_BASENAME = "_client";
+const CLIENT_EXTS = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js"
+];
+function findClientEntry(appDir) {
+	for (const ext of CLIENT_EXTS) {
+		const file = join(appDir, CLIENT_BASENAME + ext);
+		if (existsSync(file)) return file;
+	}
+}
+function isExpectedClientLog(log) {
+	return log.code === "UNRESOLVED_IMPORT" && (log.exporter ?? "").startsWith("react-server-dom-webpack");
+}
+async function bundleClient(entryFile, cwd, mode, maps = {}) {
+	const { rolldown } = await import("rolldown");
+	return await rolldown({
+		input: entryFile,
+		cwd,
+		platform: "browser",
+		plugins: [rolldownCssModulesPlugin(maps)],
+		transform: {
+			define: { "process.env.NODE_ENV": JSON.stringify(mode) },
+			jsx: await jsxTransform(cwd)
+		},
+		resolve: { conditionNames: [
+			"source",
+			"browser",
+			"import",
+			"default"
+		] },
+		onLog(level, log, handler) {
+			if (isExpectedClientLog(log)) return;
+			handler(level, log);
+		}
+	});
+}
+async function bundleClientSplit(entryFile, cwd, mode, maps = {}) {
+	const bundle = await bundleClient(entryFile, cwd, mode, maps);
+	const { output } = await bundle.generate({
+		format: "esm",
+		entryFileNames: "client.js",
+		chunkFileNames: "[name].js"
+	});
+	await bundle.close();
+	const chunks = /* @__PURE__ */ new Map();
+	for (const o of output) if (o.type === "chunk") chunks.set(o.fileName, o.code);
+	return chunks;
+}
+async function bundleClientToString(entryFile, cwd, maps = {}) {
+	const bundle = await bundleClient(entryFile, cwd, "development", maps);
+	const { output } = await bundle.generate({
+		format: "esm",
+		entryFileNames: "client.js"
+	});
+	await bundle.close();
+	const entry = output.find((o) => o.type === "chunk" && o.isEntry);
+	return entry && entry.type === "chunk" ? entry.code : "";
+}
+async function bundleClientToFile(entryFile, cwd, destDir, maps = {}) {
+	const bundle = await bundleClient(entryFile, cwd, "production", maps);
+	const { output } = await bundle.generate({
+		format: "esm",
+		hashCharacters: "hex",
+		entryFileNames: "_june/client.[hash].js",
+		chunkFileNames: "_june/[name]-[hash].js",
+		assetFileNames: "_june/[name]-[hash][extname]"
+	});
+	await bundle.close();
+	let entryFileName = "";
+	for (const o of output) {
+		const dest = join(destDir, o.fileName);
+		await mkdir(dirname(dest), { recursive: true });
+		if (o.type === "chunk") {
+			await writeFile(dest, o.code);
+			if (o.isEntry) entryFileName = o.fileName;
+		} else await writeFile(dest, o.source);
+	}
+	return entryFileName;
+}
+//#endregion
+export { CLIENT_SCRIPT_URL, bundleClientSplit, bundleClientToFile, bundleClientToString, findClientEntry, isExpectedClientLog };