void 0.1.6 → 0.7.0

package/dist/pages/head-client.d.mts

@@ -0,0 +1,15 @@
+import { n as HeadDescriptor } from "../head-P-egrtFE.mjs";
+
+//#region src/pages/head-client.d.ts
+/**
+* Mark SSR-rendered head tags so they are cleaned up on the first SPA navigation.
+* Call once after hydration with the initial page's head descriptor.
+*/
+declare function initClientHead(head: HeadDescriptor | undefined): void;
+/**
+* Apply head changes on SPA navigation.
+* Preserves existing managed tags when their final attributes are unchanged.
+*/
+declare function applyClientHead(head: HeadDescriptor | undefined): void;
+//#endregion
+export { applyClientHead, initClientHead };

package/dist/pages/head-client.mjs

@@ -0,0 +1,90 @@
+//#region src/pages/head-client.ts
+const ATTR = "data-void-head";
+function elementDescriptorSignature(descriptor) {
+	const attrs = Object.entries(descriptor.attrs).sort(([a], [b]) => a.localeCompare(b));
+	return `${encodeURIComponent(descriptor.tag)}:${attrs.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")}`;
+}
+function elementSignature(el) {
+	const attrs = {};
+	for (const attr of Array.from(el.attributes)) if (attr.name !== ATTR) attrs[attr.name] = attr.value;
+	return elementDescriptorSignature({
+		tag: el.tagName.toLowerCase(),
+		attrs
+	});
+}
+function createHeadElement(descriptor) {
+	const el = document.createElement(descriptor.tag);
+	for (const [key, value] of Object.entries(descriptor.attrs)) el.setAttribute(key, value);
+	el.setAttribute(ATTR, "");
+	return el;
+}
+function collectDesiredHeadElements(head) {
+	const desired = [];
+	if (head.meta) for (const entry of head.meta) {
+		const attrs = {};
+		if (entry.charset) attrs.charset = entry.charset;
+		if (entry.name) attrs.name = entry.name;
+		if (entry.property) attrs.property = entry.property;
+		if (entry.content !== void 0) attrs.content = entry.content;
+		desired.push({
+			tag: "meta",
+			attrs
+		});
+	}
+	if (head.link) for (const entry of head.link) {
+		const attrs = {};
+		for (const [key, value] of Object.entries(entry)) if (value != null) attrs[key] = value;
+		desired.push({
+			tag: "link",
+			attrs
+		});
+	}
+	return desired;
+}
+/**
+* Mark SSR-rendered head tags so they are cleaned up on the first SPA navigation.
+* Call once after hydration with the initial page's head descriptor.
+*/
+function initClientHead(head) {
+	if (!head) return;
+	if (head.meta) for (const entry of head.meta) {
+		const selector = entry.charset ? "meta[charset]" : entry.property ? `meta[property="${entry.property}"]` : entry.name ? `meta[name="${entry.name}"]` : null;
+		if (!selector) continue;
+		const el = document.head.querySelector(selector);
+		if (el) el.setAttribute(ATTR, "");
+	}
+	if (head.link) for (const entry of head.link) {
+		const el = document.head.querySelector(`link[rel="${entry.rel}"][href="${entry.href}"]`);
+		if (el) el.setAttribute(ATTR, "");
+	}
+}
+/**
+* Apply head changes on SPA navigation.
+* Preserves existing managed tags when their final attributes are unchanged.
+*/
+function applyClientHead(head) {
+	const existing = /* @__PURE__ */ new Map();
+	for (const el of document.head.querySelectorAll(`[${ATTR}]`)) {
+		const signature = elementSignature(el);
+		const elements = existing.get(signature);
+		if (elements) elements.push(el);
+		else existing.set(signature, [el]);
+	}
+	const desiredElements = [];
+	for (const descriptor of head ? collectDesiredHeadElements(head) : []) {
+		const signature = elementDescriptorSignature(descriptor);
+		const elements = existing.get(signature);
+		const preserved = elements?.shift();
+		if (elements && elements.length === 0) existing.delete(signature);
+		desiredElements.push(preserved ?? createHeadElement(descriptor));
+	}
+	for (const elements of existing.values()) for (const el of elements) el.remove();
+	let cursor = document.head.querySelector(`[${ATTR}]`);
+	for (const el of desiredElements) {
+		if (el !== cursor) document.head.insertBefore(el, cursor);
+		cursor = el.nextSibling;
+	}
+	if (head?.title !== void 0) document.title = head.title;
+}
+//#endregion
+export { applyClientHead, initClientHead };

package/dist/pages/head.d.mts

@@ -0,0 +1,2 @@
+import { a as renderHtmlAttrs, i as renderHeadToString, n as HeadDescriptor, o as resolveHead, r as renderBodyAttrs, t as HeadConfig } from "../head-P-egrtFE.mjs";
+export { HeadConfig, HeadDescriptor, renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveHead };

package/dist/pages/head.mjs

@@ -0,0 +1,112 @@
+//#region src/pages/head.ts
+/**
+* Merge head descriptors with precedence: page > middleware > config.
+*
+* - `title`: page wins; `titleTemplate` from config wraps it (`%s` replaced)
+* - `meta`: page overrides entries with same `name`/`property`; others appended
+* - `link`/`script`: concatenated (config first, then middleware, then page)
+* - `htmlAttrs`/`bodyAttrs`: shallow merge, page wins conflicts
+*/
+function resolveHead(configHead, middlewareHead, pageHead) {
+	if (!configHead && !middlewareHead && !pageHead) return;
+	const result = {};
+	const title = pageHead?.title ?? middlewareHead?.title ?? configHead?.title;
+	if (title !== void 0) {
+		const template = configHead?.titleTemplate;
+		result.title = template ? template.replace("%s", title) : title;
+	}
+	const metaMap = /* @__PURE__ */ new Map();
+	const metaOrder = [];
+	for (const layer of [
+		configHead,
+		middlewareHead,
+		pageHead
+	]) {
+		if (!layer?.meta) continue;
+		for (const entry of layer.meta) {
+			const key = entry.charset ? "charset" : entry.property ? `property:${entry.property}` : `name:${entry.name ?? ""}`;
+			if (!metaMap.has(key)) metaOrder.push(key);
+			metaMap.set(key, entry);
+		}
+	}
+	if (metaMap.size > 0) result.meta = metaOrder.map((key) => metaMap.get(key));
+	const links = [];
+	for (const layer of [
+		configHead,
+		middlewareHead,
+		pageHead
+	]) if (layer?.link) links.push(...layer.link);
+	if (links.length > 0) result.link = links;
+	const scripts = [];
+	for (const layer of [
+		configHead,
+		middlewareHead,
+		pageHead
+	]) if (layer?.script) scripts.push(...layer.script);
+	if (scripts.length > 0) result.script = scripts;
+	const htmlAttrs = {};
+	let hasHtmlAttrs = false;
+	for (const layer of [
+		configHead,
+		middlewareHead,
+		pageHead
+	]) if (layer?.htmlAttrs) {
+		Object.assign(htmlAttrs, layer.htmlAttrs);
+		hasHtmlAttrs = true;
+	}
+	if (hasHtmlAttrs) result.htmlAttrs = htmlAttrs;
+	const bodyAttrs = {};
+	let hasBodyAttrs = false;
+	for (const layer of [
+		configHead,
+		middlewareHead,
+		pageHead
+	]) if (layer?.bodyAttrs) {
+		Object.assign(bodyAttrs, layer.bodyAttrs);
+		hasBodyAttrs = true;
+	}
+	if (hasBodyAttrs) result.bodyAttrs = bodyAttrs;
+	if (result.title === void 0 && !result.meta && !result.link && !result.script && !result.htmlAttrs && !result.bodyAttrs) return;
+	return result;
+}
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** Serialize a HeadDescriptor to HTML tags for injection into `<head>`. */
+function renderHeadToString(head) {
+	const parts = [];
+	if (head.title !== void 0) parts.push(`<title>${escapeHtml(head.title)}</title>`);
+	if (head.meta) for (const entry of head.meta) {
+		const attrs = [];
+		if (entry.charset) attrs.push(`charset="${escapeHtml(entry.charset)}"`);
+		if (entry.name) attrs.push(`name="${escapeHtml(entry.name)}"`);
+		if (entry.property) attrs.push(`property="${escapeHtml(entry.property)}"`);
+		if (entry.content !== void 0) attrs.push(`content="${escapeHtml(entry.content)}"`);
+		parts.push(`<meta ${attrs.join(" ")}>`);
+	}
+	if (head.link) for (const entry of head.link) {
+		const attrs = Object.entries(entry).filter(([, v]) => v != null).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ");
+		parts.push(`<link ${attrs}>`);
+	}
+	if (head.script) for (const entry of head.script) {
+		const { innerHTML, ...rest } = entry;
+		const attrs = Object.entries(rest).filter(([, v]) => v != null).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ");
+		if (innerHTML) parts.push(`<script${attrs ? " " + attrs : ""}>${innerHTML}<\/script>`);
+		else if (attrs) parts.push(`<script ${attrs}><\/script>`);
+	}
+	return parts.join("\n");
+}
+/** Serialize htmlAttrs to an attribute string (includes leading space). */
+function renderHtmlAttrs(head) {
+	if (!head.htmlAttrs) return "";
+	const attrs = Object.entries(head.htmlAttrs).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ");
+	return attrs ? " " + attrs : "";
+}
+/** Serialize bodyAttrs to an attribute string (includes leading space). */
+function renderBodyAttrs(head) {
+	if (!head.bodyAttrs) return "";
+	const attrs = Object.entries(head.bodyAttrs).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ");
+	return attrs ? " " + attrs : "";
+}
+//#endregion
+export { renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveHead };

package/dist/pages/index.d.mts

@@ -0,0 +1,38 @@
+import { a as renderHtmlAttrs, i as renderHeadToString, n as HeadDescriptor, o as resolveHead, r as renderBodyAttrs, t as HeadConfig } from "../head-P-egrtFE.mjs";
+import { i as PageScanResult, n as NamedLayoutDefinition, r as PageDefinition, t as LayoutDefinition } from "../types-mHOEwpW4.mjs";
+import { serializePageData } from "./serialize.mjs";
+
+//#region src/pages/layout-resolution.d.ts
+/** Resolve the layout chain for a component (innermost last) */
+declare function resolveLayoutChain(componentId: string, layouts: Array<LayoutDefinition>): Array<LayoutDefinition>;
+/** Walk up directory tree to find closest _layouts/<name> */
+declare function resolveNamedLayout(name: string, componentId: string, namedLayouts: Array<NamedLayoutDefinition>): NamedLayoutDefinition | null;
+/** Resolve effective layout chain accounting for named layout selection */
+declare function resolveEffectiveLayoutChain(page: {
+  componentId: string;
+  layout?: string | false;
+}, layouts: Array<LayoutDefinition>, namedLayouts: Array<NamedLayoutDefinition>): Array<LayoutDefinition | NamedLayoutDefinition>;
+//#endregion
+//#region src/pages/scan.d.ts
+declare function scanPages(root: string, options?: {
+  output?: "server" | "static";
+}): Promise<PageScanResult>;
+//#endregion
+//#region src/pages/manifest.d.ts
+/**
+* Generates the component import map and layout tree as code strings.
+* Used by both SSR renderer and client entry virtual modules.
+*/
+declare function generateComponentManifest(scan: PageScanResult, pagesDir: string): string;
+//#endregion
+//#region src/pages/static-data.d.ts
+interface StaticPageDataBuildOptions {
+  enabled: boolean;
+  fastPath: boolean;
+}
+interface ResolveStaticPageDataBuildOptionsInput {
+  publicDir?: string | false;
+}
+declare function resolveStaticPageDataBuildOptions(root: string, options?: ResolveStaticPageDataBuildOptionsInput): StaticPageDataBuildOptions;
+//#endregion
+export { type HeadConfig, type HeadDescriptor, type LayoutDefinition, type NamedLayoutDefinition, type PageDefinition, type PageScanResult, type StaticPageDataBuildOptions, generateComponentManifest, renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveEffectiveLayoutChain, resolveHead, resolveLayoutChain, resolveNamedLayout, resolveStaticPageDataBuildOptions, scanPages, serializePageData };

package/dist/pages/index.mjs

@@ -0,0 +1,76 @@
+import { a as join } from "../pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { f as readConfig } from "../config-BIa9HwVX.mjs";
+import { a as resolveNamedLayout, i as resolveLayoutIds, n as resolveEffectiveLayoutChain, r as resolveLayoutChain, t as scanPages } from "../scan-Ba4hFwlH.mjs";
+import { i as parseRedirectsFile } from "../headers-DCXc7mDs.mjs";
+import { renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveHead } from "./head.mjs";
+import { serializePageData } from "./serialize.mjs";
+//#region src/pages/manifest.ts
+/**
+* Generates the component import map and layout tree as code strings.
+* Used by both SSR renderer and client entry virtual modules.
+*/
+function generateComponentManifest(scan, pagesDir) {
+	const lines = [];
+	lines.push("const components = {");
+	for (const page of scan.pages) {
+		const importPath = `${pagesDir}/${page.componentPath}`;
+		lines.push(`  ${JSON.stringify(page.componentId)}: () => import(${JSON.stringify(importPath)}),`);
+	}
+	for (const layout of scan.layouts) {
+		const importPath = `${pagesDir}/${layout.filePath}`;
+		const layoutId = layout.directory ? `${layout.directory}/layout` : "layout";
+		lines.push(`  ${JSON.stringify(layoutId)}: () => import(${JSON.stringify(importPath)}),`);
+	}
+	for (const nl of scan.namedLayouts) {
+		const importPath = `${pagesDir}/${nl.filePath}`;
+		const layoutId = nl.directory ? `${nl.directory}/_layouts/${nl.name}` : `_layouts/${nl.name}`;
+		lines.push(`  ${JSON.stringify(layoutId)}: () => import(${JSON.stringify(importPath)}),`);
+	}
+	lines.push("};");
+	lines.push("const layoutTree = {");
+	for (const page of scan.pages) {
+		const chain = resolveLayoutIds(page, scan.layouts, scan.namedLayouts);
+		if (chain.length > 0) lines.push(`  ${JSON.stringify(page.componentId)}: ${JSON.stringify(chain)},`);
+	}
+	lines.push("};");
+	lines.push("const routeMeta = {");
+	for (const page of scan.pages) if (page.island) lines.push(`  ${JSON.stringify(page.componentId)}: { island: true },`);
+	lines.push("};");
+	lines.push("const routes = [");
+	for (const page of scan.pages) {
+		const regex = patternToRegex(page.pattern);
+		lines.push(`  { pattern: ${regex}, id: ${JSON.stringify(page.componentId)} },`);
+	}
+	lines.push("];");
+	lines.push(`function matchRoute(url) {
+  const path = new URL(url, "http://x").pathname;
+  for (const r of routes) {
+    if (r.pattern.test(path)) return r.id;
+  }
+  return null;
+}`);
+	return lines.join("\n");
+}
+function patternToRegex(pattern) {
+	return `/^${pattern.replace(/:[^/{}]+\{\.\+\}/g, "(.+)").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/, "(.*)").replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/")}$/`;
+}
+//#endregion
+//#region src/pages/static-data.ts
+function resolveStaticPageDataBuildOptions(root, options = {}) {
+	const config = readConfig(root);
+	const enabled = config.output === "static";
+	const r = config.routing;
+	const hasConfigRouting = r?.redirects !== void 0 && Object.keys(r.redirects).length > 0 || r?.rewrites !== void 0 && Object.keys(r.rewrites).length > 0 || r?.fallbacks !== void 0 && Object.keys(r.fallbacks).length > 0;
+	const redirectDirs = [root];
+	if (options.publicDir !== false) redirectDirs.push(options.publicDir ?? join(root, "public"));
+	const hasRedirectsFile = redirectDirs.some((dir) => {
+		const parsed = parseRedirectsFile(dir);
+		return parsed != null && parsed.rules.length > 0;
+	});
+	return {
+		enabled,
+		fastPath: enabled && !hasConfigRouting && !hasRedirectsFile
+	};
+}
+//#endregion
+export { generateComponentManifest, renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveEffectiveLayoutChain, resolveHead, resolveLayoutChain, resolveNamedLayout, resolveStaticPageDataBuildOptions, scanPages, serializePageData };

package/dist/pages/islands-plugin.d.mts

@@ -0,0 +1,50 @@
+import { i as PageScanResult } from "../types-mHOEwpW4.mjs";
+import { ResolvedConfig, ViteDevServer } from "vite";
+
+//#region src/pages/islands-plugin.d.ts
+declare const ISLANDS_RENDERER_ID = "virtual:void-islands-renderer";
+declare const ISLANDS_CLIENT_ENTRY_ID = "virtual:void-islands-client";
+interface IslandEntry {
+  componentPath: string;
+  islandId: string;
+  hydrate: string;
+}
+/** Resolve a relative import specifier to an absolute path by checking extensions. */
+declare function resolveSpecifier(specifier: string, importerDir: string, extensions: Array<string>): string | null;
+/**
+* Check whether the islands client bundle is needed by scanning file contents.
+* Returns true if any island/layout file has island imports or CSS,
+* or any .md file has a `<script>` block.
+*/
+declare function needsIslandClientBundle(dir: string, islandFilePattern: RegExp, checkStyleBlocks: boolean): boolean;
+/** Check if a file has CSS import statements (JS-style imports). */
+declare function fileHasCssImports(filePath: string): boolean;
+/**
+* Rewrite a matched CSS import line so relative specifiers resolve from the
+* virtual module. Absolute and bare specifiers are kept as-is.
+*/
+declare function rewriteCssImportForVirtualModule(matchedLine: string, specifier: string, sourceFilePath: string): string;
+/** Extract CSS import statements from a file and return them as @import rules. */
+declare function extractCssImports(filePath: string): string;
+/** Rebuild islandCssMap from current file contents. */
+declare function rebuildIslandCssMap(pageScan: PageScanResult, pagesDir: string, islandCssMap: Map<string, Array<string>>, fileHasCssFn: (filePath: string) => boolean): void;
+/** Compute which island pages need client-side JavaScript. */
+declare function computePagesNeedingClientJS(pageScan: PageScanResult, pagesDir: string, resolvedConfig: ResolvedConfig | null): Set<string>;
+/**
+* Configure the Vite dev server for island CSS serving.
+* Sets up file watching and a middleware for serving virtual CSS modules.
+*/
+declare function configureIslandCssServer(server: ViteDevServer, islandCssFiles: Set<string>, viteRoot: string, rebuildCssMap: () => void): void;
+/**
+* Watch the pages directory for structural changes (add/remove) and .md content
+* changes (frontmatter layout field) so that new layouts and named layouts are
+* picked up without a dev server restart.
+*
+* Returns a `flush()` function that resolves when any pending rescan completes
+* (useful for tests).
+*/
+declare function watchPagesForRescan(server: ViteDevServer, pagesDir: string, root: string, onRescan: (pageScan: PageScanResult) => void): {
+  flush: () => Promise<void>;
+};
+//#endregion
+export { ISLANDS_CLIENT_ENTRY_ID, ISLANDS_RENDERER_ID, IslandEntry, computePagesNeedingClientJS, configureIslandCssServer, extractCssImports, fileHasCssImports, needsIslandClientBundle, rebuildIslandCssMap, resolveSpecifier, rewriteCssImportForVirtualModule, watchPagesForRescan };

package/dist/pages/islands-plugin.mjs

@@ -0,0 +1,195 @@
+import { n as dirname, s as resolve } from "../pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as resolveEffectiveLayoutChain, t as scanPages } from "../scan-Ba4hFwlH.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { normalizePath } from "vite";
+//#region src/pages/islands-plugin.ts
+const ISLANDS_RENDERER_ID = "virtual:void-islands-renderer";
+const ISLANDS_CLIENT_ENTRY_ID = "virtual:void-islands-client";
+/** Resolve a relative import specifier to an absolute path by checking extensions. */
+function resolveSpecifier(specifier, importerDir, extensions) {
+	const base = normalizePath(resolve(importerDir, specifier));
+	for (const ext of extensions) if (existsSync(base + ext)) return base + ext;
+	if (existsSync(base)) return base;
+	return null;
+}
+/**
+* Check whether the islands client bundle is needed by scanning file contents.
+* Returns true if any island/layout file has island imports or CSS,
+* or any .md file has a `<script>` block.
+*/
+function needsIslandClientBundle(dir, islandFilePattern, checkStyleBlocks) {
+	const importAttrRe = /import\s+\w+\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:/;
+	const cssImportRe = /import\b[^"']*["'][^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)["']/;
+	const mdScriptRe = /^<script\b/m;
+	const styleRe = checkStyleBlocks ? /<style\b/ : null;
+	try {
+		for (const entry of readdirSync(dir, {
+			withFileTypes: true,
+			recursive: true
+		})) {
+			if (!entry.isFile()) continue;
+			const name = entry.name;
+			if (islandFilePattern.test(name) || name.startsWith("layout.") || name.startsWith("_")) {
+				const content = readFileSync(resolve(entry.parentPath, name), "utf-8");
+				if (importAttrRe.test(content)) return true;
+				if (styleRe && styleRe.test(content)) return true;
+				if (cssImportRe.test(content)) return true;
+			}
+			if (name.endsWith(".md")) {
+				const content = readFileSync(resolve(entry.parentPath, name), "utf-8");
+				if (mdScriptRe.test(content)) return true;
+			}
+		}
+	} catch {}
+	return false;
+}
+/** Check if a file has CSS import statements (JS-style imports). */
+function fileHasCssImports(filePath) {
+	try {
+		const code = readFileSync(filePath, "utf-8");
+		return /import\b[^"']*["'][^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)["']/.test(code);
+	} catch {
+		return false;
+	}
+}
+/**
+* Rewrite a matched CSS import line so relative specifiers resolve from the
+* virtual module. Absolute and bare specifiers are kept as-is.
+*/
+function rewriteCssImportForVirtualModule(matchedLine, specifier, sourceFilePath) {
+	if (specifier.startsWith(".")) {
+		const absPath = normalizePath(resolve(dirname(sourceFilePath), specifier));
+		return `import ${JSON.stringify(absPath)};`;
+	}
+	return matchedLine.trim() + ";";
+}
+/** Extract CSS import statements from a file and return them as @import rules. */
+function extractCssImports(filePath) {
+	const code = readFileSync(filePath, "utf-8");
+	const re = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+	const imports = [];
+	let match;
+	while ((match = re.exec(code)) !== null) imports.push(`@import ${JSON.stringify(match[1])};`);
+	return imports.join("\n");
+}
+/** Rebuild islandCssMap from current file contents. */
+function rebuildIslandCssMap(pageScan, pagesDir, islandCssMap, fileHasCssFn) {
+	islandCssMap.clear();
+	for (const page of pageScan.pages) {
+		if (!page.island) continue;
+		const cssPaths = [];
+		const layoutChain = resolveEffectiveLayoutChain(page, pageScan.layouts, pageScan.namedLayouts);
+		for (const layout of layoutChain) {
+			const layoutPath = resolve(pagesDir, layout.filePath);
+			if (fileHasCssFn(layoutPath)) cssPaths.push(layoutPath);
+		}
+		const pagePath = resolve(pagesDir, page.componentPath);
+		if (fileHasCssFn(pagePath)) cssPaths.push(pagePath);
+		if (cssPaths.length > 0) islandCssMap.set(page.componentId, cssPaths);
+	}
+}
+/** Compute which island pages need client-side JavaScript. */
+function computePagesNeedingClientJS(pageScan, pagesDir, resolvedConfig) {
+	const mdPlugin = resolvedConfig?.plugins?.find((plugin) => plugin.name === "void-md");
+	const mdScriptIds = new Set(mdPlugin?.api?.getClientScripts?.()?.keys() ?? []);
+	const importAttrRe = /import\s+\w+\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:\s*("[^"]+"|'[^']+')\s*\}/g;
+	const layoutDirsWithIslands = /* @__PURE__ */ new Set();
+	for (const layout of pageScan.layouts) {
+		if (!layout.island) continue;
+		const code = readFileSync(resolve(pagesDir, layout.filePath), "utf-8");
+		importAttrRe.lastIndex = 0;
+		if (importAttrRe.test(code)) layoutDirsWithIslands.add(layout.directory);
+	}
+	const result = /* @__PURE__ */ new Set();
+	for (const page of pageScan.pages) {
+		if (!page.island) continue;
+		if (mdScriptIds.has(page.componentId)) {
+			result.add(page.componentId);
+			continue;
+		}
+		const code = readFileSync(resolve(pagesDir, page.componentPath), "utf-8");
+		importAttrRe.lastIndex = 0;
+		if (importAttrRe.test(code)) {
+			result.add(page.componentId);
+			continue;
+		}
+		const layoutChain = resolveEffectiveLayoutChain(page, pageScan.layouts, pageScan.namedLayouts);
+		for (const layout of layoutChain) if (layoutDirsWithIslands.has(layout.directory)) {
+			result.add(page.componentId);
+			break;
+		}
+	}
+	return result;
+}
+/**
+* Configure the Vite dev server for island CSS serving.
+* Sets up file watching and a middleware for serving virtual CSS modules.
+*/
+function configureIslandCssServer(server, islandCssFiles, viteRoot, rebuildCssMap) {
+	server.watcher.on("change", (path) => {
+		const normalizedPath = normalizePath(path);
+		if (!islandCssFiles.has(normalizedPath)) return;
+		rebuildCssMap();
+		for (const env of Object.values(server.environments)) {
+			const mod = env.moduleGraph.getModuleById("\0" + ISLANDS_RENDERER_ID);
+			if (mod) env.moduleGraph.invalidateModule(mod);
+		}
+		const cssMod = server.environments.client?.moduleGraph.getModuleById(normalizedPath + ".css");
+		if (cssMod) server.environments.client.moduleGraph.invalidateModule(cssMod);
+	});
+	server.middlewares.use(async (req, res, next) => {
+		if (!req.url) return next();
+		const url = req.url.split("?")[0];
+		if (!url.endsWith(".css")) return next();
+		const srcPath = normalizePath(resolve(viteRoot, url.slice(1, -4)));
+		if (!islandCssFiles.has(srcPath)) return next();
+		try {
+			const result = await server.environments.client.transformRequest(url);
+			if (result) {
+				const m = result.code.match(/\b__vite__css\s*=\s*("(?:[^"\\]|\\.)*")/) || result.code.match(/export\s+default\s+("(?:[^"\\]|\\.)*")/);
+				if (m) {
+					res.setHeader("Content-Type", "text/css");
+					res.statusCode = 200;
+					res.end(JSON.parse(m[1]));
+					return;
+				}
+			}
+		} catch {}
+		next();
+	});
+}
+/**
+* Watch the pages directory for structural changes (add/remove) and .md content
+* changes (frontmatter layout field) so that new layouts and named layouts are
+* picked up without a dev server restart.
+*
+* Returns a `flush()` function that resolves when any pending rescan completes
+* (useful for tests).
+*/
+function watchPagesForRescan(server, pagesDir, root, onRescan) {
+	let pending = null;
+	let debounceTimer = null;
+	const scheduleRescan = (path) => {
+		if (!path.startsWith(pagesDir)) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			pending = scanPages(root).then((pageScan) => {
+				onRescan(pageScan);
+				for (const env of Object.values(server.environments)) {
+					const mod = env.moduleGraph.getModuleById("\0" + ISLANDS_RENDERER_ID);
+					if (mod) env.moduleGraph.invalidateModule(mod);
+				}
+				pending = null;
+			});
+		}, 50);
+	};
+	server.watcher.on("add", scheduleRescan);
+	server.watcher.on("unlink", scheduleRescan);
+	server.watcher.on("change", (path) => {
+		if (path.endsWith(".md")) scheduleRescan(path);
+	});
+	return { flush: () => pending ?? Promise.resolve() };
+}
+//#endregion
+export { ISLANDS_CLIENT_ENTRY_ID, ISLANDS_RENDERER_ID, computePagesNeedingClientJS, configureIslandCssServer, extractCssImports, fileHasCssImports, needsIslandClientBundle, rebuildIslandCssMap, resolveSpecifier, rewriteCssImportForVirtualModule, watchPagesForRescan };

package/dist/pages/prefetch.d.mts

@@ -0,0 +1,31 @@
+//#region src/pages/prefetch.d.ts
+interface CacheForResult {
+  stale: number;
+  expires: number;
+}
+type CacheForInput = number | string | [string, string];
+declare function parseCacheFor(value: CacheForInput): CacheForResult;
+interface CacheEntry {
+  url: string;
+  method: string;
+  response: Promise<unknown>;
+  staleAt: number;
+  expiresAt: number;
+  singleUse: boolean;
+  timer: ReturnType<typeof setTimeout> | null;
+}
+declare class PrefetchCache {
+  private entries;
+  private key;
+  has(url: string, method?: string): boolean;
+  get(url: string, method?: string): CacheEntry | null;
+  isFresh(entry: CacheEntry): boolean;
+  isUsable(entry: CacheEntry): boolean;
+  set(url: string, method: string, response: Promise<unknown>, ttl: CacheForResult): void;
+  /** Mark entry as consumed — removes it if singleUse. */
+  consume(url: string, method?: string): void;
+  flush(url: string, method?: string): void;
+  flushAll(): void;
+}
+//#endregion
+export { CacheEntry, CacheForInput, CacheForResult, PrefetchCache, parseCacheFor };