getfilepress 0.1.2 → 0.1.4

package/packages/app/src/lib/genie/config-patch.ts

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Limited chrome keys Genie may bake into `filepress.config.ts` (Q8). */
+export type GenieConfigPatch = {
+	lede?: string | null;
+	tagline?: string | null;
+	logo?: string | null;
+};
+
+const KEYS = ['lede', 'tagline', 'logo'] as const;
+
+function upsertStringField(src: string, key: string, value: string | null | undefined): string {
+	if (value === undefined) return src;
+	const fieldRe = new RegExp(`(\\n\\t)${key}:\\s*(['\`"])([\\s\\S]*?)\\2,?`, 'm');
+	if (value === null || value === '') {
+		return src.replace(fieldRe, '');
+	}
+	const quoted = JSON.stringify(value);
+	if (fieldRe.test(src)) {
+		return src.replace(fieldRe, `$1${key}: ${quoted},`);
+	}
+	// Insert after defineFilepressConfig({
+	return src.replace(
+		/(defineFilepressConfig\(\{\s*)/,
+		`$1\n\t${key}: ${quoted},`
+	);
+}
+
+/** Apply a config patch to the site's `filepress.config.ts` (string fields only). */
+export function applyConfigPatch(siteRoot: string, patch: GenieConfigPatch): void {
+	const path = join(siteRoot, 'filepress.config.ts');
+	if (!existsSync(path)) {
+		throw new Error('No filepress.config.ts at site root — cannot patch config');
+	}
+	let src = readFileSync(path, 'utf8');
+	const before = src;
+	for (const key of KEYS) {
+		if (key in patch) src = upsertStringField(src, key, patch[key]);
+	}
+	if (src !== before) writeFileSync(path, src);
+}
+
+export function readConfigPatchFile(path: string): GenieConfigPatch {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, 'utf8')) as GenieConfigPatch;
+	} catch {
+		return {};
+	}
+}
+
+/** Best-effort identity fields for Ollama prompts (no TS evaluate). */
+export function stubIdentityFromConfig(siteRoot: string): {
+	title: string;
+	description: string;
+	author: string;
+	canonicalUrl: string;
+} {
+	const path = join(siteRoot, 'filepress.config.ts');
+	const src = existsSync(path) ? readFileSync(path, 'utf8') : '';
+	const pick = (key: string, fallback: string) => {
+		const m = src.match(new RegExp(`${key}:\\s*['\`"]([^'\`"]+)['\`"]`));
+		return m?.[1]?.trim() || fallback;
+	};
+	return {
+		title: pick('title', 'Site'),
+		description: pick('description', ''),
+		author: pick('author', pick('title', 'Author')),
+		canonicalUrl: pick('url', 'https://example.com')
+	};
+}

package/packages/app/src/lib/genie/ops.ts

@@ -6,9 +6,22 @@ import {
 	tokensFromSourceCss
 } from '../../../../import/src/theme.ts';
 import { formatAttributionMarkdown, searchStockImage } from '../../../../import/src/stock.ts';
-import { fetchBuffer } from '../../../../import/src/fetch.ts';
-import { ollamaAvailable, ollamaSetupHint } from '../../../../import/src/ollama.ts';
-import type { DesignBrief } from '../../../../import/src/ir.ts';
+import { fetchBuffer, fetchText } from '../../../../import/src/fetch.ts';
+import {
+	briefFromInspiration,
+	extractInspirationSignals,
+	type InspirationSignals
+} from '../../../../import/src/inspire.ts';
+import {
+	assertOllamaEndpoint,
+	generateDesignBrief,
+	listOllamaModels,
+	ollamaAvailable,
+	ollamaSetupHint,
+	summarizeHtmlForBrief
+} from '../../../../import/src/ollama.ts';
+import { scanOllamaNetwork } from '../../../../import/src/ollanet-scan.ts';
+import type { DesignBrief, SiteIR } from '../../../../import/src/ir.ts';
 import {
 	activateVersion,
 	ensureBaseline,
@@ -17,6 +30,7 @@ import {
 	readVersionBrief,
 	writeSnapshot
 } from './store.ts';
+import { stubIdentityFromConfig, type GenieConfigPatch } from './config-patch.ts';
 import type { GenieSteerPatch } from './types.ts';
 
 /** Build a starting brief from on-disk theme.css + optional prior genie brief. */
@@ -88,10 +102,19 @@ export function ensureBaselineIfNeeded(siteRoot: string) {
 	return ensureBaseline(siteRoot, { brief, themeCss });
 }
 
+function ollamaHost() {
+	return assertOllamaEndpoint(process.env.OLLAMA_HOST?.trim() || 'http://127.0.0.1:11434');
+}
+
+function defaultOllamaModel() {
+	return process.env.FILEPRESS_OLLAMA_MODEL?.trim() || 'gemma4:12b';
+}
+
 export async function health(siteRoot: string) {
-	const host = process.env.OLLAMA_HOST?.trim() || 'http://127.0.0.1:11434';
-	const model = process.env.FILEPRESS_OLLAMA_MODEL?.trim() || 'gemma4:12b';
+	const host = ollamaHost();
+	const model = defaultOllamaModel();
 	const up = await ollamaAvailable(host);
+	const models = up ? await listOllamaModels(host) : [];
 	ensureBaselineIfNeeded(siteRoot);
 	return {
 		ok: true,
@@ -100,9 +123,12 @@ export async function health(siteRoot: string) {
 		ollama: {
 			host,
 			model,
+			models,
 			available: up,
 			hint: up
-				? `Ollama is reachable. For a GPU-tuned named variant, try Finetuna: https://github.com/Catalyst-Forge-LLC/finetuna — then set FILEPRESS_OLLAMA_MODEL.`
+				? models.length
+					? `Ollama is reachable (${models.length} model${models.length === 1 ? '' : 's'}). Pick a server/model below, or tune with Finetuna: https://github.com/Catalyst-Forge-LLC/finetuna`
+					: `Ollama is up but no models listed. Pull one (e.g. ollama pull ${model}) or use Finetuna: https://github.com/Catalyst-Forge-LLC/finetuna`
 				: ollamaSetupHint(host)
 		},
 		active: getActive(siteRoot),
@@ -117,6 +143,20 @@ export async function health(siteRoot: string) {
 	};
 }
 
+function resolveRequestHost(raw?: string) {
+	return raw?.trim() ? assertOllamaEndpoint(raw) : ollamaHost();
+}
+
+/** Optional ollanet discovery (localhost / config / Tailscale; LAN only when requested). */
+export async function scanOllamaHosts(opts: { lan?: boolean } = {}) {
+	const result = await scanOllamaNetwork({ lan: Boolean(opts.lan) });
+	return {
+		...result,
+		defaultHost: ollamaHost(),
+		defaultModel: defaultOllamaModel()
+	};
+}
+
 function collectImageFiles(siteRoot: string, brief: DesignBrief) {
 	const imageFiles: Array<{ absPath: string; destName: string }> = [];
 	for (const slot of ['hero', 'header', 'background', 'logo', 'portrait'] as const) {
@@ -129,7 +169,10 @@ function collectImageFiles(siteRoot: string, brief: DesignBrief) {
 	return imageFiles;
 }
 
-export function applySteer(siteRoot: string, patch: GenieSteerPatch) {
+export function applySteer(
+	siteRoot: string,
+	patch: GenieSteerPatch & { configPatch?: GenieConfigPatch }
+) {
 	ensureBaselineIfNeeded(siteRoot);
 	const base = loadWorkingBrief(siteRoot);
 	const brief = mergeBrief(base, patch.brief || {});
@@ -145,7 +188,8 @@ export function applySteer(siteRoot: string, patch: GenieSteerPatch) {
 		brief,
 		themeCss,
 		imageFiles: collectImageFiles(siteRoot, brief),
-		steers: [{ type: 'steer', patch: patch.brief || {} }]
+		steers: [{ type: 'steer', patch: patch.brief || {} }],
+		configPatch: patch.configPatch
 	});
 
 	const shouldActivate = patch.activate !== false;
@@ -214,7 +258,7 @@ export function receiveUpload(
 	if (buf.length > MAX_UPLOAD) throw new Error('Upload exceeds 5MB limit');
 
 	const safeBase = opts.filename.replace(/[^\w.-]+/g, '-').slice(0, 80) || opts.role;
-	const extMatch = safeBase.match(/\.(jpe?g|png|webp|gif)$/i);
+	const extMatch = safeBase.match(/\.(jpe?g|png|webp|gif|svg)$/i);
 	let ext = extMatch ? extMatch[0].toLowerCase() : '.jpg';
 	if (ext === '.jpeg') ext = '.jpg';
 	const destName = `${opts.role}${ext}`;
@@ -223,10 +267,12 @@ export function receiveUpload(
 	mkdirSync(staticImg, { recursive: true });
 	writeFileSync(join(staticImg, destName), buf);
 
+	const imagePath = `/images/${destName}`;
 	return applySteer(siteRoot, {
 		label: `Upload ${opts.role}`,
 		prompt: `Local upload → ${opts.role}`,
-		brief: { images: { [opts.role]: `/images/${destName}` } },
+		brief: { images: { [opts.role]: imagePath } },
+		configPatch: opts.role === 'logo' ? { logo: imagePath } : undefined,
 		activate: opts.activate !== false
 	});
 }
@@ -235,3 +281,178 @@ export function doActivate(siteRoot: string, versionId: string) {
 	ensureBaselineIfNeeded(siteRoot);
 	return activateVersion(siteRoot, versionId);
 }
+
+function assertHttpUrls(urls: string[]): string[] {
+	const out: string[] = [];
+	for (const raw of urls) {
+		const u = raw.trim();
+		if (!u) continue;
+		let parsed: URL;
+		try {
+			parsed = new URL(u);
+		} catch {
+			throw new Error(`Invalid URL: ${u}`);
+		}
+		if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+			throw new Error(`Only http(s) inspire URLs allowed: ${u}`);
+		}
+		out.push(parsed.href);
+	}
+	if (!out.length) throw new Error('Provide 1–3 inspire URLs');
+	if (out.length > 3) throw new Error('At most 3 inspire URLs');
+	return out;
+}
+
+function stubSiteIr(siteRoot: string): SiteIR {
+	const identity = stubIdentityFromConfig(siteRoot);
+	return {
+		source: { url: identity.canonicalUrl, generator: null },
+		identity,
+		posts: [],
+		pages: [],
+		nav: [],
+		topics: [],
+		lede: null,
+		notes: [],
+		assets: []
+	};
+}
+
+/** Live inspire crawl → DesignBrief snapshot (optional Ollama refine). */
+export async function runInspire(
+	siteRoot: string,
+	opts: {
+		urls: string[];
+		useLlm?: boolean;
+		model?: string;
+		host?: string;
+		activate?: boolean;
+		label?: string;
+	}
+) {
+	ensureBaselineIfNeeded(siteRoot);
+	const urls = assertHttpUrls(opts.urls);
+	const signals: InspirationSignals[] = [];
+	const summaries: string[] = [];
+	const notes: string[] = [];
+
+	for (const u of urls) {
+		try {
+			const sig = await extractInspirationSignals(u);
+			signals.push(sig);
+			const { text } = await fetchText(u);
+			summaries.push(`${u}: ${summarizeHtmlForBrief(text)}`);
+			notes.push(`${u} → ${sig.paletteMode}`);
+		} catch (e) {
+			throw new Error(
+				`Inspire failed for ${u}: ${e instanceof Error ? e.message : String(e)}`
+			);
+		}
+	}
+
+	let brief = mergeBrief(loadWorkingBrief(siteRoot), briefFromInspiration(signals));
+	// Prefer inspire look for chrome; keep any already-chosen image paths unless inspire cleared them
+	const host = resolveRequestHost(opts.host);
+	const model = (opts.model || defaultOllamaModel()).trim();
+	let llm = { used: false, model: null as string | null, host: null as string | null };
+
+	if (opts.useLlm !== false) {
+		const up = await ollamaAvailable(host);
+		if (up) {
+			brief = await generateDesignBrief({
+				host,
+				model,
+				ir: stubSiteIr(siteRoot),
+				inspireSummaries: summaries,
+				inspireSignals: signals,
+				seed: brief
+			});
+			llm = { used: true, model, host };
+		} else {
+			notes.push('Ollama unavailable — used deterministic inspire brief');
+		}
+	}
+
+	const themeCss = themeCssFromBrief(brief);
+	const meta = writeSnapshot(siteRoot, {
+		label: opts.label || `Inspire: ${urls.map((u) => new URL(u).hostname).join(', ')}`.slice(0, 72),
+		prompt: urls.join('\n'),
+		brief,
+		themeCss,
+		imageFiles: collectImageFiles(siteRoot, brief),
+		inspireUrls: urls,
+		llm,
+		steers: [{ type: 'inspire', urls, notes }]
+	});
+	const active =
+		opts.activate !== false ? activateVersion(siteRoot, meta.id) : getActive(siteRoot);
+	return { meta, active, brief, notes, llm };
+}
+
+/** Ollama refine of the working brief from a short natural-language prompt. */
+export async function refineWithOllama(
+	siteRoot: string,
+	opts: { prompt: string; model?: string; host?: string; activate?: boolean }
+) {
+	ensureBaselineIfNeeded(siteRoot);
+	const prompt = opts.prompt.trim();
+	if (!prompt) throw new Error('`prompt` is required');
+
+	const host = resolveRequestHost(opts.host);
+	const model = (opts.model || defaultOllamaModel()).trim();
+	if (!(await ollamaAvailable(host))) {
+		throw new Error(ollamaSetupHint(host));
+	}
+
+	const seed = loadWorkingBrief(siteRoot);
+	const brief = await generateDesignBrief({
+		host,
+		model,
+		ir: stubSiteIr(siteRoot),
+		inspireSummaries: [`Author steer: ${prompt}`],
+		inspireSignals: [],
+		seed
+	});
+	const themeCss = themeCssFromBrief(brief);
+	const meta = writeSnapshot(siteRoot, {
+		label: `Refine: ${prompt.slice(0, 40)}`,
+		prompt,
+		brief,
+		themeCss,
+		imageFiles: collectImageFiles(siteRoot, brief),
+		llm: { used: true, model, host },
+		steers: [{ type: 'refine', prompt }]
+	});
+	const active =
+		opts.activate !== false ? activateVersion(siteRoot, meta.id) : getActive(siteRoot);
+	return { meta, active, brief, llm: { used: true, model, host } };
+}
+
+/** Snapshot a config-only chrome patch (lede / tagline / logo). */
+export function applyConfigOnly(
+	siteRoot: string,
+	opts: { patch: GenieConfigPatch; label?: string; activate?: boolean }
+) {
+	ensureBaselineIfNeeded(siteRoot);
+	const keys = Object.keys(opts.patch).filter(
+		(k) => opts.patch[k as keyof GenieConfigPatch] !== undefined
+	);
+	if (!keys.length) throw new Error('No config fields to patch');
+
+	const brief = opts.patch.logo
+		? mergeBrief(loadWorkingBrief(siteRoot), { images: { logo: opts.patch.logo } })
+		: loadWorkingBrief(siteRoot);
+	const themeCss = loadWorkingThemeCss(siteRoot, brief);
+	const meta = writeSnapshot(siteRoot, {
+		label: opts.label || `Config: ${keys.join(', ')}`,
+		prompt: JSON.stringify(opts.patch),
+		brief,
+		themeCss,
+		imageFiles: collectImageFiles(siteRoot, brief),
+		configPatch: opts.patch,
+		steers: [{ type: 'config', patch: opts.patch }]
+	});
+	const active =
+		opts.activate !== false ? activateVersion(siteRoot, meta.id) : getActive(siteRoot);
+	return { meta, active, brief };
+}

package/packages/app/src/lib/genie/store.ts

@@ -10,6 +10,7 @@ import {
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import type { DesignBrief, GenieActive, GenieVersionMeta } from './types.ts';
+import { applyConfigPatch, readConfigPatchFile, type GenieConfigPatch } from './config-patch.ts';
 
 const GENIE_DIR = '.filepress-genie';
 
@@ -85,6 +86,9 @@ export type SnapshotInput = {
 	/** Absolute or site-relative files to copy into version images/ as basename */
 	imageFiles?: Array<{ absPath: string; destName: string }>;
 	attribution?: string;
+	configPatch?: GenieConfigPatch;
+	inspireUrls?: string[];
+	llm?: { used: boolean; model: string | null; host: string | null };
 };
 
 export function writeSnapshot(siteRoot: string, input: SnapshotInput): GenieVersionMeta {
@@ -101,13 +105,13 @@ export function writeSnapshot(siteRoot: string, input: SnapshotInput): GenieVers
 		starred: false,
 		prompt: input.prompt || '',
 		steers: input.steers || [],
-		inspireUrls: [],
-		llm: { used: false, model: null, host: null }
+		inspireUrls: input.inspireUrls || [],
+		llm: input.llm || { used: false, model: null, host: null }
 	};
 
 	writeJson(join(dir, 'meta.json'), meta);
 	writeJson(join(dir, 'design-brief.json'), input.brief);
-	writeJson(join(dir, 'config-patch.json'), {});
+	writeJson(join(dir, 'config-patch.json'), input.configPatch || {});
 	writeFileSync(join(dir, 'theme.css'), input.themeCss);
 	if (input.attribution) {
 		writeFileSync(join(dir, 'attribution.md'), input.attribution);
@@ -144,6 +148,11 @@ export function activateVersion(siteRoot: string, versionId: string): GenieActiv
 		copyFileSync(attr, join(siteRoot, '.filepress-import', 'IMAGE_ATTRIBUTION.md'));
 	}
 
+	const patch = readConfigPatchFile(join(dir, 'config-patch.json'));
+	if (Object.keys(patch).length > 0) {
+		applyConfigPatch(siteRoot, patch);
+	}
+
 	const active: GenieActive = {
 		versionId,
 		activatedAt: new Date().toISOString()

package/packages/app/src/lib/pages.server.ts

@@ -1,7 +1,9 @@
-import { createPages } from '@filepress/core/server';
+import { createPages, pathMountReservedSlugs } from '@filepress/core/server';
 import { getPagesDir } from './site.server';
+import config from '$site-config';
 
 /** Bound to the active site's `pages/` (missing dir → empty). */
 export const pages = createPages({
-	pagesDir: getPagesDir()
+	pagesDir: getPagesDir(),
+	extraReservedSlugs: pathMountReservedSlugs(config.paths ?? [])
 });

package/packages/app/src/routes/sitemap.xml/+server.ts

@@ -1,17 +1,20 @@
 import type { RequestHandler } from './$types';
-import { buildSitemapXml } from '@filepress/core/server';
+import { buildSitemapXml, listPathMountHtmlUrls } from '@filepress/core/server';
 import { content } from '$lib/content.server';
 import { pages } from '$lib/pages.server';
+import { getSiteRoot } from '$lib/site.server';
 import config from '$site-config';
 
 export const prerender = true;
 
 export const GET: RequestHandler = () => {
+	const mountUrls = listPathMountHtmlUrls(getSiteRoot(), config.paths ?? []);
 	const xml = buildSitemapXml(config, {
 		posts: content.getPublishedPosts(),
 		tags: content.getAllTags(),
 		pageCount: content.getIndexPageCount(config.postsPerPage),
-		pages: pages.getPublishedPages()
+		pages: pages.getPublishedPages(),
+		mountUrls
 	});
 	return new Response(xml, {
 		headers: { 'Content-Type': 'application/xml; charset=utf-8' }

package/packages/app/vite-plugin-genie.ts

@@ -1,11 +1,15 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Plugin } from 'vite';
 import {
+	applyConfigOnly,
 	applySteer,
 	doActivate,
 	fetchStockCover,
 	health,
-	receiveUpload
+	receiveUpload,
+	refineWithOllama,
+	runInspire,
+	scanOllamaHosts
 } from './src/lib/genie/ops.ts';
 import { deleteVersion, listVersions } from './src/lib/genie/store.ts';
 
@@ -97,6 +101,65 @@ export function geniePlugin(siteRoot: string): Plugin {
 						});
 					}
 
+					if (method === 'POST' && path === '/__filepress/genie/scan') {
+						const body = JSON.parse((await readBody(req)) || '{}');
+						return sendJson(res, 200, await scanOllamaHosts({ lan: Boolean(body.lan) }));
+					}
+
+					if (method === 'POST' && path === '/__filepress/genie/inspire') {
+						const body = JSON.parse(await readBody(req));
+						const urls = Array.isArray(body.urls)
+							? body.urls
+							: typeof body.urls === 'string'
+								? body.urls.split(/\n+/).map((s: string) => s.trim())
+								: [];
+						return sendJson(
+							res,
+							200,
+							await runInspire(siteRoot, {
+								urls,
+								useLlm: body.useLlm,
+								model: body.model,
+								host: body.host,
+								activate: body.activate,
+								label: body.label
+							})
+						);
+					}
+
+					if (method === 'POST' && path === '/__filepress/genie/refine') {
+						const body = JSON.parse(await readBody(req));
+						if (!body.prompt || typeof body.prompt !== 'string') {
+							return sendJson(res, 400, { error: '`prompt` string required' });
+						}
+						return sendJson(
+							res,
+							200,
+							await refineWithOllama(siteRoot, {
+								prompt: body.prompt,
+								model: body.model,
+								host: body.host,
+								activate: body.activate
+							})
+						);
+					}
+
+					if (method === 'POST' && path === '/__filepress/genie/config') {
+						const body = JSON.parse(await readBody(req));
+						if (!body.patch || typeof body.patch !== 'object') {
+							return sendJson(res, 400, { error: '`patch` object required' });
+						}
+						return sendJson(
+							res,
+							200,
+							applyConfigOnly(siteRoot, {
+								patch: body.patch,
+								label: body.label,
+								activate: body.activate
+							})
+						);
+					}
+
 					if (method === 'POST' && path === '/__filepress/genie/delete') {
 						const body = JSON.parse(await readBody(req));
 						deleteVersion(siteRoot, body.versionId);

package/packages/app/vite-plugin-path-mounts.ts

@@ -0,0 +1,107 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import {
+	createReadStream,
+	existsSync,
+	statSync,
+} from 'node:fs';
+import { extname, join, normalize, relative, resolve, sep } from 'node:path';
+import type { Plugin } from 'vite';
+import type { PathMount } from '../core/src/lib/paths-shared.ts';
+
+const MIME: Record<string, string> = {
+	'.html': 'text/html; charset=utf-8',
+	'.css': 'text/css; charset=utf-8',
+	'.js': 'text/javascript; charset=utf-8',
+	'.mjs': 'text/javascript; charset=utf-8',
+	'.json': 'application/json; charset=utf-8',
+	'.svg': 'image/svg+xml',
+	'.png': 'image/png',
+	'.jpg': 'image/jpeg',
+	'.jpeg': 'image/jpeg',
+	'.gif': 'image/gif',
+	'.webp': 'image/webp',
+	'.ico': 'image/x-icon',
+	'.woff': 'font/woff',
+	'.woff2': 'font/woff2',
+	'.txt': 'text/plain; charset=utf-8',
+	'.xml': 'application/xml; charset=utf-8',
+	'.map': 'application/json; charset=utf-8',
+};
+
+function contentType(filePath: string): string {
+	return MIME[extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+}
+
+/**
+ * Resolve a request path under a mount to a file on disk.
+ * Returns null when the path escapes the mount root or does not exist.
+ */
+function resolveMountFile(mountRoot: string, urlPath: string, mountUrl: string): string | null {
+	const prefix = mountUrl.endsWith('/') ? mountUrl.slice(0, -1) : mountUrl;
+	let rest = urlPath === prefix ? '' : urlPath.slice(prefix.length);
+	if (rest.startsWith('/')) rest = rest.slice(1);
+	rest = decodeURIComponent(rest.split('?')[0] ?? '');
+
+	const candidates = rest
+		? [rest, join(rest, 'index.html'), `${rest}.html`]
+		: ['index.html'];
+
+	for (const rel of candidates) {
+		const abs = normalize(resolve(mountRoot, rel));
+		const rootNorm = normalize(mountRoot) + sep;
+		if (abs !== normalize(mountRoot) && !abs.startsWith(rootNorm)) continue;
+		if (existsSync(abs) && statSync(abs).isFile()) return abs;
+	}
+	return null;
+}
+
+function sendFile(res: ServerResponse, filePath: string): void {
+	res.statusCode = 200;
+	res.setHeader('Content-Type', contentType(filePath));
+	res.setHeader('Cache-Control', 'no-store');
+	createReadStream(filePath).pipe(res);
+}
+
+export interface PathMountsPluginOptions {
+	siteRoot: string;
+	/** Resolved mounts from site config (may be empty). */
+	mounts: PathMount[];
+}
+
+/**
+ * Serve `paths` mounts in `filepress dev` and copy them into `build/` after
+ * `filepress build`. Mount contents are opaque to FilePress (site-owned HTML/CSS/JS).
+ */
+export function pathMountsPlugin(opts: PathMountsPluginOptions): Plugin {
+	const { siteRoot, mounts } = opts;
+
+	return {
+		name: 'filepress-path-mounts',
+		configureServer(server) {
+			if (mounts.length === 0) return;
+
+			server.middlewares.use((req: IncomingMessage, res: ServerResponse, next) => {
+				const raw = req.url || '';
+				const pathname = raw.split('?')[0] ?? '';
+				const mount = mounts.find(
+					(m) => pathname === m.url || pathname.startsWith(`${m.url}/`),
+				);
+				if (!mount) return next();
+
+				const root = resolve(siteRoot, mount.dir);
+				if (!existsSync(root)) return next();
+
+				const file = resolveMountFile(root, pathname, mount.url);
+				if (!file) return next();
+				sendFile(res, file);
+			});
+		},
+		// Copy happens in scripts/filepress.mjs after `vite build` so adapter-static
+		// has already written `build/` (closeBundle runs too early / wrong tree).
+	};
+}
+
+/** Dev helper: relative path for logging. */
+export function describeMount(siteRoot: string, mount: PathMount): string {
+	return `${mount.url} ← ${relative(siteRoot, resolve(siteRoot, mount.dir)) || mount.dir}`;
+}