void 0.22.0 → 0.23.0

package/dist/runtime/routing.mjs

@@ -0,0 +1,1082 @@
+import { t as convertReturnValue } from "../response-Tn7rU0MV.mjs";
+import { t as VoidAssetRewriteError } from "../handler-DghKr6dU.mjs";
+import { n as handlePageGet, r as handlePageMutation } from "../protocol-U7bfjHmA.mjs";
+import { compilePattern, mergeQueryIntoLocation, substituteParams } from "@void/edge";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/runtime/routing-errors.ts
+const __VOID_ERROR_PAGE_FONT_STACK = "system-ui, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+const errorStack = Error;
+/** Error rendering is shared by generated Pages apps; production never includes exception details. */
+function createErrorRenderer(options) {
+	const __VOID_DEV = options.dev === true;
+	const __VOID_PROJECT_ROOT = options.projectRoot;
+	const __VOID_HOME_DIR = options.homeDir;
+	function __voidEscapeHtml(value) {
+		return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+	}
+	function __voidShouldServeHtmlErrorPage(request) {
+		if (request.method !== "GET" && request.method !== "HEAD") return false;
+		const url = new URL(request.url);
+		if (url.pathname === "/api" || url.pathname.startsWith("/api/")) return false;
+		if (/\/[^/]+\.[^/]+$/.test(url.pathname)) return false;
+		const destination = request.headers.get("sec-fetch-dest");
+		if (destination && destination !== "document" && destination !== "empty") return false;
+		const accept = request.headers.get("accept");
+		return !accept || accept.includes("text/html") || accept.includes("*/*");
+	}
+	function __voidNormalizeFsPath(value) {
+		return typeof value === "string" ? value.replaceAll("\\", "/") : "";
+	}
+	function __voidIsAbsolutePath(value) {
+		return value.startsWith("/") || /^[A-Za-z]:\//.test(value);
+	}
+	function __voidDisplayPath(value) {
+		const path = __voidNormalizeFsPath(value);
+		const homeDir = __voidNormalizeFsPath(__VOID_HOME_DIR);
+		const projectRoot = __voidNormalizeFsPath(__VOID_PROJECT_ROOT);
+		if (!path) return "";
+		if (projectRoot && (path === projectRoot || path.startsWith(projectRoot + "/"))) {
+			const suffix = path.slice(projectRoot.length).replace(/^\/?/, "");
+			return suffix ? "./" + suffix : "./";
+		}
+		if (homeDir && (path === homeDir || path.startsWith(homeDir + "/"))) {
+			const suffix = path.slice(homeDir.length).replace(/^\/?/, "");
+			return suffix ? "~/" + suffix : "~/";
+		}
+		return path;
+	}
+	function __voidEditorHref(value, line, column) {
+		const path = __voidNormalizeFsPath(value);
+		if (!__voidIsAbsolutePath(path)) return "";
+		return "vscode://file/" + encodeURI(path).replaceAll("#", "%23").replaceAll("?", "%3F") + ":" + String(line) + ":" + String(column);
+	}
+	function __voidCreateStackFrame(functionName, file, line, column, raw) {
+		const normalizedFile = __voidNormalizeFsPath(file);
+		const lineNumber = Number(line);
+		const columnNumber = Number(column);
+		if (!normalizedFile || !Number.isFinite(lineNumber) || lineNumber <= 0) return null;
+		const safeColumn = Number.isFinite(columnNumber) && columnNumber > 0 ? columnNumber : 1;
+		return {
+			functionName: functionName || "",
+			file: normalizedFile,
+			line: lineNumber,
+			column: safeColumn,
+			displayPath: __voidDisplayPath(normalizedFile),
+			href: __voidEditorHref(normalizedFile, lineNumber, safeColumn),
+			raw: raw || ""
+		};
+	}
+	function __voidParseFrameLocation(value) {
+		const match = value.match(/^(.*):(\d+):(\d+)$/);
+		if (!match) return null;
+		return __voidCreateStackFrame("", match[1], Number(match[2]), Number(match[3]), value);
+	}
+	function __voidParseStackFrames(stack) {
+		if (!stack) return [];
+		const frames = [];
+		for (const rawLine of stack.split(/\n+/)) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			let frame = null;
+			let match = line.match(/^at\s+(?:async\s+)?(.+?)\s+\((.+)\)$/);
+			if (match) {
+				const location = __voidParseFrameLocation(match[2]);
+				frame = location ? {
+					...location,
+					functionName: match[1]
+				} : null;
+			} else {
+				match = line.match(/^at\s+(.+)$/);
+				if (match) frame = __voidParseFrameLocation(match[1]);
+				else {
+					match = line.match(/^(.*?)@(.+)$/);
+					if (match) {
+						const location = __voidParseFrameLocation(match[2]);
+						frame = location ? {
+							...location,
+							functionName: match[1]
+						} : null;
+					}
+				}
+			}
+			if (frame) frames.push({
+				...frame,
+				raw: line
+			});
+		}
+		return frames;
+	}
+	function __voidGetStackFrames(error) {
+		if (!(error instanceof Error)) return [];
+		if (!error.stack && typeof errorStack.captureStackTrace === "function") try {
+			errorStack.captureStackTrace(error, __voidGetStackFrames);
+		} catch {}
+		const originalPrepareStackTrace = errorStack.prepareStackTrace;
+		try {
+			errorStack.prepareStackTrace = (_, callSites) => callSites;
+			const structured = error.stack;
+			if (Array.isArray(structured)) {
+				const frames = [];
+				for (const callSite of structured) try {
+					const fileName = callSite.getFileName?.() || callSite.getScriptNameOrSourceURL?.();
+					const line = callSite.getLineNumber?.();
+					const column = callSite.getColumnNumber?.();
+					const frame = __voidCreateStackFrame(callSite.getFunctionName?.() || callSite.getMethodName?.() || "", fileName || "", line, column, String(callSite));
+					if (frame) frames.push(frame);
+				} catch {}
+				if (frames.length > 0) return frames;
+			}
+		} catch {} finally {
+			errorStack.prepareStackTrace = originalPrepareStackTrace;
+		}
+		return __voidParseStackFrames(typeof error.stack === "string" ? error.stack : "");
+	}
+	function __voidDescribeThrownValue(value) {
+		if (value instanceof Error) return {
+			name: value.name || "Error",
+			message: value.message || "",
+			stack: typeof value.stack === "string" ? value.stack : "",
+			frames: __voidGetStackFrames(value)
+		};
+		if (typeof value === "string") return {
+			name: "Thrown value",
+			message: value,
+			stack: "",
+			frames: []
+		};
+		let message = "";
+		try {
+			if (typeof value === "object" && value !== null) message = JSON.stringify(value, null, 2) ?? String(value);
+			else message = String(value);
+		} catch {
+			message = String(value);
+		}
+		return {
+			name: "Thrown value",
+			message,
+			stack: "",
+			frames: []
+		};
+	}
+	function __voidRenderStack(entry) {
+		if (Array.isArray(entry.frames) && entry.frames.length > 0) return `<div class="__void-error-stack"><div class="__void-error-stack-label">Stack trace</div><div class="__void-error-frames">${entry.frames.map((frame) => {
+			const name = frame.functionName || "(anonymous)";
+			const location = frame.displayPath + ":" + frame.line + ":" + frame.column;
+			const body = `<span class="__void-error-frame-function">${__voidEscapeHtml(name)}</span><span class="__void-error-frame-location">${__voidEscapeHtml(location)}</span>`;
+			if (frame.href) return `<a class="__void-error-frame" href="${__voidEscapeHtml(frame.href)}">${body}</a>`;
+			return `<div class="__void-error-frame is-static">${body}</div>`;
+		}).join("")}</div></div>`;
+		if (!entry.stack) return "";
+		return `<div class="__void-error-stack"><div class="__void-error-stack-label">Stack trace</div><pre>${__voidEscapeHtml(entry.stack)}</pre></div>`;
+	}
+	function __voidCollectErrorChain(error) {
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = error;
+		let depth = 0;
+		while (current != null && depth < 8 && !seen.has(current)) {
+			seen.add(current);
+			const entry = __voidDescribeThrownValue(current);
+			chain.push({
+				label: depth === 0 ? "Error" : "Cause " + depth,
+				...entry
+			});
+			current = current instanceof Error ? current.cause : void 0;
+			depth += 1;
+		}
+		if (current != null) chain.push({
+			label: "Cause " + depth,
+			name: "Truncated",
+			message: "Additional nested causes were omitted.",
+			stack: "",
+			frames: []
+		});
+		if (chain.length === 0) chain.push({
+			label: "Error",
+			name: "Unknown error",
+			message: "No error details were available.",
+			stack: "",
+			frames: []
+		});
+		return chain;
+	}
+	function __voidRenderDevErrorOverlay(request, status, title, error) {
+		const chain = __voidCollectErrorChain(error);
+		const errorCountLabel = chain.length + (chain.length === 1 ? " Error" : " Errors");
+		const sections = chain.map((entry, index) => {
+			const heading = entry.name || (index === 0 ? title : "Cause");
+			const message = entry.message || title;
+			const stack = __voidRenderStack(entry);
+			if (index === 0) return `<section class="__void-error-section is-root"><p class="__void-error-message">${__voidEscapeHtml(message)}</p>${stack}</section>`;
+			return `<section class="__void-error-section"><div class="__void-error-kicker">${__voidEscapeHtml(entry.label)}</div><h2>${__voidEscapeHtml(heading)}</h2><p>${__voidEscapeHtml(message)}</p>${stack}</section>`;
+		}).join("");
+		return `<style>
+    .__void-error-overlay {
+      position: fixed;
+      inset: 0;
+      z-index: 2147483647;
+      pointer-events: none;
+      font-family: ${__VOID_ERROR_PAGE_FONT_STACK};
+      color: #f5f5f5;
+    }
+    .__void-error-backdrop {
+      position: absolute;
+      inset: 0;
+      background: rgba(10, 10, 10, 0.52);
+      backdrop-filter: blur(4px);
+      transition: opacity 180ms ease;
+    }
+    .__void-error-panel {
+      position: absolute;
+      inset: auto auto 24px 24px;
+      inline-size: min(760px, calc(100vw - 48px));
+      max-block-size: min(80dvh, 920px);
+      overflow: auto;
+      pointer-events: auto;
+      border-radius: 32px;
+      corner-shape: squircle;
+      border: 1px solid rgba(255, 255, 255, 0.14);
+      background: linear-gradient(180deg, rgba(24, 24, 27, 0.98), rgba(9, 9, 11, 0.98));
+      box-shadow: 0 24px 80px rgba(0, 0, 0, 0.45);
+      padding: 12px 16px;
+      transition: transform 180ms ease, opacity 180ms ease;
+      transform-origin: bottom left;
+    }
+    .__void-error-close {
+      position: absolute;
+      inset: 12px 12px auto auto;
+      inline-size: 36px;
+      block-size: 36px;
+      border: 0;
+      border-radius: 999px;
+      background: rgba(255, 255, 255, 0.08);
+      color: #fafafa;
+      cursor: pointer;
+      display: grid;
+      place-items: center;
+      padding: 0;
+    }
+    .__void-error-close:hover {
+      background: rgba(255, 255, 255, 0.14);
+    }
+    .__void-error-close svg {
+      inline-size: 16px;
+      block-size: 16px;
+      display: block;
+    }
+    .__void-error-minimized {
+      position: absolute;
+      inset: auto auto 24px 24px;
+      pointer-events: none;
+      opacity: 0;
+      transform: scale(0.92);
+      transform-origin: bottom left;
+      border: 1px solid rgba(248, 113, 113, 0.35);
+      border-radius: 32px;
+      corner-shape: squircle;
+      background: rgba(24, 24, 27, 0.96);
+      color: #fca5a5;
+      padding: 12px 8px;
+      box-shadow: 0 18px 36px rgba(0, 0, 0, 0.28);
+      cursor: pointer;
+      font: 700 13px/1 ${__VOID_ERROR_PAGE_FONT_STACK};
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+      transition: transform 180ms ease, opacity 180ms ease;
+    }
+    .__void-error-header {
+      display: flex;
+      flex-direction: column;
+      gap: 6px;
+      margin-block-end: 0;
+      padding-right: 52px;
+    }
+    .__void-error-status {
+      margin: 0;
+      color: #fca5a5;
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+    }
+    .__void-error-section {
+      border-top: 1px solid rgba(255, 255, 255, 0.08);
+      padding-top: 16px;
+      margin-top: 16px;
+    }
+    .__void-error-section.is-root {
+      border-top: 0;
+      padding-top: 0;
+      margin-top: 0;
+    }
+    .__void-error-message {
+      margin: 0;
+      color: #fff;
+      font-size: 1.7rem;
+      line-height: 1.15;
+      letter-spacing: -0.03em;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+    .__void-error-kicker {
+      margin-bottom: 6px;
+      color: #fda4af;
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+    .__void-error-section h2 {
+      margin: 0 0 8px;
+      font-size: 1.05rem;
+      color: #fff;
+    }
+    .__void-error-section p {
+      margin: 0;
+      color: #e4e4e7;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+    .__void-error-stack {
+      margin-top: 18px;
+      border: 1px solid rgba(255, 255, 255, 0.08);
+      border-radius: 32px;
+      background: rgba(255, 255, 255, 0.03);
+      corner-shape: squircle;
+      overflow: hidden;
+    }
+    .__void-error-stack-label {
+      padding: 12px 14px 10px;
+      color: #f4f4f5;
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+    }
+    .__void-error-frames {
+      display: flex;
+      flex-direction: column;
+    }
+    .__void-error-frame {
+      display: flex;
+      align-items: baseline;
+      justify-content: space-between;
+      gap: 16px;
+      padding: 12px 14px;
+      color: inherit;
+      text-decoration: none;
+      border-top: 1px solid rgba(255, 255, 255, 0.06);
+    }
+    .__void-error-frame:first-child {
+      border-top: 0;
+    }
+    .__void-error-frame:hover {
+      background: rgba(255, 255, 255, 0.05);
+    }
+    .__void-error-frame.is-static {
+      cursor: default;
+    }
+    .__void-error-frame-function {
+      flex: 1 1 auto;
+      min-width: 0;
+      color: #fafafa;
+      font: 600 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .__void-error-frame-location {
+      flex: 0 1 52%;
+      min-width: 0;
+      color: #fda4af;
+      font: 500 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      text-align: right;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .__void-error-section pre {
+      margin: 0;
+      padding: 12px 14px;
+      overflow: auto;
+      color: #e4e4e7;
+      font: 500 12px/1.6 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+    .__void-error-overlay.is-minimized .__void-error-backdrop {
+      opacity: 0;
+      pointer-events: none;
+    }
+    .__void-error-overlay.is-minimized .__void-error-panel {
+      opacity: 0;
+      pointer-events: none;
+      transform: scale(0.92);
+    }
+    .__void-error-overlay.is-minimized .__void-error-minimized {
+      opacity: 1;
+      pointer-events: auto;
+      transform: scale(1);
+    }
+    @media (max-width: 720px) {
+      .__void-error-panel {
+        inset: auto 12px 12px 12px;
+        inline-size: auto;
+        max-block-size: min(70dvh, 920px);
+        padding: 16px;
+      }
+      .__void-error-minimized {
+        inset: auto auto 12px 12px;
+      }
+      .__void-error-frame {
+        flex-direction: column;
+        align-items: flex-start;
+      }
+      .__void-error-frame-location {
+        text-align: left;
+      }
+    }
+  </style>
+<aside class="__void-error-overlay" data-void-error-overlay role="dialog" aria-label="Void dev error overlay"><div class="__void-error-backdrop" data-void-error-backdrop></div><section class="__void-error-panel"><button type="button" class="__void-error-close" data-void-error-close aria-label="Minimize error overlay"><svg viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path d="M3.757 3.757 12.243 12.243M12.243 3.757 3.757 12.243" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/></svg></button><header class="__void-error-header"><p class="__void-error-status">${__voidEscapeHtml(String(status) + ": " + title)}</p></header>${sections}</section><button type="button" class="__void-error-minimized" data-void-error-toggle aria-label="Show dev error overlay" aria-expanded="true">${__voidEscapeHtml(errorCountLabel)}</button><script>(function(){const script=document.currentScript;if(!(script instanceof HTMLScriptElement))return;const root=script.closest("[data-void-error-overlay]");if(!(root instanceof HTMLElement))return;const backdrop=root.querySelector("[data-void-error-backdrop]");const closeButton=root.querySelector("[data-void-error-close]");const toggle=root.querySelector("[data-void-error-toggle]");const setMinimized=(minimized)=>{root.classList.toggle("is-minimized", minimized);if(toggle instanceof HTMLElement)toggle.setAttribute("aria-expanded", minimized ? "false" : "true");};if(backdrop instanceof HTMLElement)backdrop.addEventListener("click",()=>setMinimized(true));if(closeButton instanceof HTMLElement)closeButton.addEventListener("click",()=>setMinimized(true));if(toggle instanceof HTMLElement)toggle.addEventListener("click",()=>setMinimized(false));})();<\/script></aside>`;
+	}
+	function __voidInjectDevErrorOverlay(html, overlay) {
+		return /<\/body\s*>/i.test(html) ? html.replace(/<\/body\s*>/i, overlay + "</body>") : html + overlay;
+	}
+	function __voidGetErrorAssetCss(error) {
+		const tags = error && (typeof error === "object" || typeof error === "function") && "__voidPageAssetTags" in error ? error.__voidPageAssetTags : null;
+		return tags && typeof tags === "object" && "css" in tags && typeof tags.css === "string" ? tags.css : "";
+	}
+	function __voidInjectErrorAssetCss(html, css) {
+		if (!css) return html;
+		return /<\/head\s*>/i.test(html) ? html.replace(/<\/head\s*>/i, css + "</head>") : css + html;
+	}
+	function __voidRenderErrorPage(request, status, title, error) {
+		const heading = status + ": " + title;
+		const prefix = status + ": ";
+		const overlay = __VOID_DEV && status === 500 && error ? __voidRenderDevErrorOverlay(request, status, title, error) : "";
+		return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${__voidEscapeHtml(heading)}</title>
+    ${__voidGetErrorAssetCss(error)}
+    <style>
+      :root {
+        color-scheme: light dark;
+        font-family: ${__VOID_ERROR_PAGE_FONT_STACK};
+        background: #f5f5f5;
+        color: #171717;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        min-block-size: 100dvh;
+        display: grid;
+        place-items: center;
+        padding: 24px;
+        background: radial-gradient(circle at top, rgba(255, 255, 255, 0.96), rgba(245, 245, 245, 0.96) 52%), linear-gradient(180deg, #fafafa 0%, #f1f1f1 100%);
+        font: 500 16px/1.5 ${__VOID_ERROR_PAGE_FONT_STACK};
+      }
+      main {
+        inline-size: min(100%, 560px);
+        padding: 32px 36px;
+        border: 1px solid #d4d4d8;
+        border-radius: 32px;
+        corner-shape: squircle;
+        background: rgba(255, 255, 255, 0.88);
+        text-align: center;
+        backdrop-filter: blur(12px);
+      }
+      h1 {
+        margin: 0;
+        font: 400 clamp(1.5rem, 1.2rem + 1vw, 2rem) / 1.1 ${__VOID_ERROR_PAGE_FONT_STACK};
+        letter-spacing: -0.03em;
+      }
+      strong {
+        font-weight: 600;
+      }
+      @media (prefers-color-scheme: dark) {
+        :root {
+          background: #0a0a0a;
+          color: #f5f5f5;
+        }
+        body {
+          background: radial-gradient(circle at top, rgba(38, 38, 38, 0.96), rgba(10, 10, 10, 0.96) 52%), linear-gradient(180deg, #171717 0%, #0a0a0a 100%);
+        }
+        main {
+          border-color: #27272a;
+          background: rgba(23, 23, 23, 0.88);
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1><strong>${__voidEscapeHtml(prefix)}</strong>${__voidEscapeHtml(title)}</h1>
+    </main>
+    ${overlay}
+  </body>
+</html>`;
+	}
+	function __voidCreateErrorResponse(request, status, title, error) {
+		if (!__voidShouldServeHtmlErrorPage(request)) return new Response(title, { status });
+		return new Response(request.method === "HEAD" ? null : __voidRenderErrorPage(request, status, title, error), {
+			status,
+			headers: { "content-type": "text/html; charset=utf-8" }
+		});
+	}
+	async function serveCustomPage(c, status, fallbackText, error) {
+		try {
+			const assets = c.env?.ASSETS;
+			if (assets && typeof assets.fetch === "function") {
+				const request = new Request(new URL("/" + status + ".html", c.req.url));
+				const response = await assets.fetch(request);
+				if (response.ok) {
+					const assetCss = __voidGetErrorAssetCss(error);
+					if (assetCss) {
+						const html = __voidInjectErrorAssetCss(await response.text(), assetCss);
+						const body = __VOID_DEV && status === 500 && error && __voidShouldServeHtmlErrorPage(c.req.raw) ? __voidInjectDevErrorOverlay(html, __voidRenderDevErrorOverlay(c.req.raw, status, fallbackText, error)) : html;
+						return new Response(c.req.method === "HEAD" ? null : body, {
+							status,
+							headers: { "content-type": "text/html; charset=utf-8" }
+						});
+					}
+					if (__VOID_DEV && status === 500 && error && __voidShouldServeHtmlErrorPage(c.req.raw)) {
+						const overlay = __voidRenderDevErrorOverlay(c.req.raw, status, fallbackText, error);
+						const html = await response.text();
+						return new Response(c.req.method === "HEAD" ? null : __voidInjectDevErrorOverlay(html, overlay), {
+							status,
+							headers: { "content-type": "text/html; charset=utf-8" }
+						});
+					}
+					return new Response(response.body, {
+						status,
+						headers: { "content-type": "text/html; charset=utf-8" }
+					});
+				}
+			}
+		} catch {}
+		return __voidCreateErrorResponse(c.req.raw, status, fallbackText, error);
+	}
+	return {
+		createResponse: __voidCreateErrorResponse,
+		serveCustomPage,
+		onError: (error, c) => {
+			if (error && typeof error === "object" && "getResponse" in error && typeof error.getResponse === "function") return error.getResponse();
+			console.error(error);
+			return serveCustomPage(c, 500, "Internal Server Error", error);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/routing-assets.ts
+function createManifestLoader() {
+	let cached = null;
+	return async (request, env) => {
+		if (cached) return cached;
+		const injected = globalThis.__VITE_MANIFEST__;
+		if (typeof injected === "object" && injected) {
+			cached = injected;
+			return cached;
+		}
+		const assets = env?.ASSETS;
+		if (!assets || typeof assets.fetch !== "function") return null;
+		const response = await assets.fetch(new Request(new URL("/.vite/manifest.json", request.url).toString()));
+		if (!response.ok) return null;
+		cached = await response.json();
+		return cached;
+	};
+}
+const BINDING_HINT_SCRIPT = "<script type=\"module\" src=\"/@id/virtual:void/binding-hint\"><\/script>";
+const REACT_REFRESH_SCRIPT = `<script type="module">
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+<\/script>`;
+const escapeAttribute = (value) => String(value).replace(/"/g, "&quot;");
+const script = (url) => `<script type="module" src="${escapeAttribute(url)}"><\/script>`;
+function collectManifestFiles(manifest, entryId, depthFirst) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [entryId];
+	for (let index = 0; depthFirst ? pending.length > 0 : index < pending.length;) {
+		const id = depthFirst ? pending.pop() : pending[index++];
+		if (seen.has(id)) continue;
+		seen.add(id);
+		const imports = manifest[id]?.imports;
+		if (Array.isArray(imports)) pending.push(...imports);
+	}
+	return [...seen];
+}
+function collectRouteCss(manifest, roots) {
+	const css = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (visited.has(id)) return;
+		visited.add(id);
+		const chunk = manifest[id];
+		if (!chunk) return;
+		if (Array.isArray(chunk.css)) for (const file of chunk.css) css.add(file);
+		if (Array.isArray(chunk.imports)) for (const imported of chunk.imports) visit(imported);
+	};
+	for (const root of roots) visit(root);
+	return css;
+}
+/** Frameworks supply only client entry IDs and active layout/page roots. */
+function createClientAssetTags(options, loadManifest = createManifestLoader()) {
+	return async (request, env, componentId = "") => {
+		const empty = {
+			css: "",
+			preloads: "",
+			body: ""
+		};
+		const manifest = await loadManifest(request, env);
+		if (!manifest || typeof manifest !== "object") {
+			if (!options.dev) return empty;
+			const preloads = [script("/@vite/client"), BINDING_HINT_SCRIPT];
+			if (options.kind === "ssr" && options.reactRefresh) preloads.push(REACT_REFRESH_SCRIPT);
+			let body = script(options.entryUrl);
+			if (options.extraEntryUrl) body += "\n" + script(options.extraEntryUrl);
+			const tags = {
+				css: "",
+				preloads: preloads.join("\n"),
+				body
+			};
+			if (options.devCss && options.kind !== "ssr") {
+				const css = await options.devCss(request, env, {
+					kind: options.kind,
+					componentId,
+					rootPhases: options.devRootPhases?.[componentId] || [[options.entryUrl]]
+				});
+				tags.devCss = Array.isArray(css) ? css : [];
+			}
+			return tags;
+		}
+		const entry = manifest[options.entryId];
+		if (!entry || typeof entry !== "object" || typeof entry.file !== "string") return empty;
+		const ids = collectManifestFiles(manifest, options.entryId, options.kind === "ssr");
+		const extraEntry = options.extraEntryId ? manifest[options.extraEntryId] : void 0;
+		const hasExtra = extraEntry && typeof extraEntry.file === "string";
+		if (hasExtra) ids.push(...collectManifestFiles(manifest, options.extraEntryId, false));
+		const css = options.kind === "ssr" ? /* @__PURE__ */ new Set() : collectRouteCss(manifest, [options.entryId, ...options.pageCssKeys?.[componentId] ?? []]);
+		if (hasExtra) for (const file of collectRouteCss(manifest, [options.extraEntryId])) css.add(file);
+		const preloads = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			const chunk = manifest[id];
+			if (!chunk || typeof chunk !== "object") continue;
+			if (options.kind === "ssr" && Array.isArray(chunk.css)) for (const file of chunk.css) css.add(file);
+			if (id !== options.entryId && id !== options.extraEntryId && typeof chunk.file === "string") preloads.add(chunk.file);
+		}
+		let body = script("/" + entry.file);
+		if (hasExtra) body += "\n" + script("/" + extraEntry.file);
+		return {
+			css: [...css].map((file) => `<link rel="stylesheet" href="/${escapeAttribute(file)}">`).join("\n"),
+			preloads: [...preloads].map((file) => `<link rel="modulepreload" href="/${escapeAttribute(file)}">`).join("\n"),
+			body
+		};
+	};
+}
+//#endregion
+//#region src/runtime/routing-worker.ts
+const ASSET_CONTENT_TYPES = {
+	".avif": "image/avif",
+	".css": "text/css; charset=utf-8",
+	".gif": "image/gif",
+	".html": "text/html; charset=utf-8",
+	".ico": "image/x-icon",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".js": "text/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".txt": "text/plain; charset=utf-8",
+	".wasm": "application/wasm",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2"
+};
+/** Apply native static policy before application middleware adds authored headers. */
+function applyAssetCachePolicy(request, asset, assetsDir = "assets", fingerprinted = false) {
+	if (!["GET", "HEAD"].includes(request.method) || ![
+		200,
+		206,
+		304
+	].includes(asset.status)) return asset;
+	const pathname = new URL(request.url).pathname;
+	const filename = pathname.slice(pathname.lastIndexOf("/") + 1);
+	const extension = filename.slice(filename.lastIndexOf(".")).toLowerCase();
+	const headers = new Headers(asset.headers);
+	if (!headers.has("Content-Type") && ASSET_CONTENT_TYPES[extension]) headers.set("Content-Type", ASSET_CONTENT_TYPES[extension]);
+	const policy = headers.get("Cache-Control");
+	const providerDefault = (policy ?? "").toLowerCase().split(",").map((part) => part.trim()).sort().join(",") === "max-age=0,must-revalidate,public";
+	const hashed = fingerprinted && pathname.startsWith("/" + assetsDir.replace(/^\/+|\/+$/g, "") + "/") && extension !== ".html" && !(headers.get("Content-Type") ?? "").toLowerCase().includes("text/html");
+	if (!headers.has("Set-Cookie") && hashed && (!policy || providerDefault)) headers.set("Cache-Control", "public, max-age=31536000, immutable");
+	else if (!policy) headers.set("Cache-Control", "no-store");
+	return new Response(asset.body, {
+		status: asset.status,
+		statusText: asset.statusText,
+		headers
+	});
+}
+/** Public filenames are never evidence of a content fingerprint. */
+function createAssetCachePolicy(assetsDir, loadManifest = createManifestLoader()) {
+	let files;
+	return async (request, env, asset) => {
+		const path = new URL(request.url).pathname;
+		if (!["GET", "HEAD"].includes(request.method) || ![
+			200,
+			206,
+			304
+		].includes(asset.status) || !path.startsWith("/" + (assetsDir ?? "assets").replace(/^\/+|\/+$/g, "") + "/")) return applyAssetCachePolicy(request, asset, assetsDir);
+		if (!files) files = loadManifest(request, env).then((manifest) => new Set(Object.values(manifest ?? {}).flatMap((entry) => Array.isArray(entry?.immutableFiles) ? entry.immutableFiles : [])), () => /* @__PURE__ */ new Set());
+		return applyAssetCachePolicy(request, asset, assetsDir, (await files).has(path.slice(1)));
+	};
+}
+function createAssetFallback(options = {}) {
+	const cachePolicy = createAssetCachePolicy(options.assetsDir);
+	return async (request, env, response) => {
+		if (response.status !== 404 || !env.ASSETS || request.method !== "GET" && request.method !== "HEAD") return response;
+		const asset = await env.ASSETS.fetch(new Request(request.url, {
+			method: request.method,
+			headers: request.headers
+		}));
+		if (asset.status !== 404) return cachePolicy(request, env, asset);
+		const accept = request.headers.get("accept") ?? "";
+		if (options.serveSpaFallback && accept.includes("text/html")) {
+			const url = new URL("/index.html", request.url);
+			const index = await env.ASSETS.fetch(new Request(url, { method: request.method }));
+			if (index.status === 200) {
+				const res = new Response(index.body, {
+					status: 200,
+					headers: index.headers
+				});
+				res.headers.set("Cache-Control", "no-store");
+				res.headers.set("Content-Type", "text/html; charset=utf-8");
+				return res;
+			}
+		} else if (!options.serveSpaFallback && options.notFound === "404-page" && accept.includes("text/html") && (asset.headers.get("content-type") ?? "").includes("text/html")) {
+			const res = new Response(asset.body, asset);
+			res.headers.set("Cache-Control", "no-store");
+			return res;
+		}
+		return response;
+	};
+}
+/** Hide platform capabilities without copying bindings or changing application bindings. */
+function filterInternalBindings(env, prefixes, exactNames = []) {
+	const hidden = (key) => typeof key === "string" && (prefixes.some((prefix) => key.startsWith(prefix)) || exactNames.includes(key));
+	return new Proxy(env, {
+		get: (target, prop, receiver) => hidden(prop) ? void 0 : Reflect.get(target, prop, receiver),
+		has: (target, prop) => !hidden(prop) && Reflect.has(target, prop),
+		ownKeys: (target) => Reflect.ownKeys(target).filter((key) => !hidden(key)),
+		getOwnPropertyDescriptor: (target, prop) => hidden(prop) ? void 0 : Reflect.getOwnPropertyDescriptor(target, prop)
+	});
+}
+function createWorkerFetch(options) {
+	return async (request, originalEnv, ctx) => {
+		const url = new URL(request.url);
+		const discovery = request.method === "POST" && url.pathname === "/__void/prerender-paths";
+		if (options.validateEnv && !discovery) await options.validateEnv(originalEnv);
+		const env = options.remoteEnv && originalEnv.__VOID_REMOTE === "1" ? options.remoteEnv(originalEnv) : originalEnv;
+		if (options.isr) {
+			env.__VOID_ISR_DEPLOYMENT_ID ??= options.isr.deploymentId;
+			env.__VOID_ISR_HOST = url.hostname;
+		}
+		return options.withRawEnv(env, () => options.withRuntimeEnv(env, async () => {
+			if (options.emailReceipt && url.pathname === "/__void/email/receipt/v1") return options.emailReceipt(request, env, ctx);
+			if (request.method === "GET" && url.pathname === "/__void/ready") {
+				const metadata = options.versionMetadataBinding ? env[options.versionMetadataBinding] : void 0;
+				return Response.json({
+					ready: true,
+					...options.versionMetadataBinding ? { versionId: metadata?.id } : {}
+				}, options.versionMetadataBinding ? { headers: { "cache-control": "no-store" } } : void 0);
+			}
+			const internal = await options.internalRoute(request, env, ctx);
+			if (internal) return internal;
+			if (discovery) {
+				const expected = env.__VOID_PROXY_TOKEN;
+				if (expected) {
+					const token = request.headers.get("x-void-internal");
+					if (!token || token !== expected) return Response.json({ error: "unauthorized" }, { status: 401 });
+				}
+				return Response.json({ paths: await options.collectPrerenderPaths(request, env, ctx) });
+			}
+			const userEnv = options.filterBindings(env);
+			const render = async (req) => options.assets(req, env, await options.app.fetch(req, userEnv, ctx));
+			if (options.isr && env.ISR_CACHE && request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+				const cached = await options.isr.handle(request, env, ctx, render);
+				if (cached) return cached;
+			}
+			return render(request);
+		}));
+	};
+}
+//#endregion
+//#region src/runtime/routing-pages.ts
+function createPageGetHandler(options) {
+	return async (context) => {
+		const mod = options.load ? await options.load() : { head: options.head };
+		return handlePageGet(mod.loader, mod.head, context, options.componentId, options.render, options.assets, options.headConfig ?? void 0, options.renderOptions);
+	};
+}
+function createPageMutationHandler(options) {
+	return async (context) => {
+		const mod = options.load ? await options.load() : {};
+		const actionName = options.namedActions ? new URL(context.req.url).searchParams.keys().next().value : void 0;
+		const handler = options.namedActions ? mod.actions?.[actionName || "default"] : mod.action;
+		if (options.namedActions && !handler) return new Response("Unknown action" + (actionName ? ": " + actionName : ""), { status: 404 });
+		return handlePageMutation(handler, mod.loader, mod.head, context, options.componentId, options.render, options.assets, options.headConfig ?? void 0, options.renderOptions);
+	};
+}
+function createPagesFallback(options) {
+	const cachePolicy = createAssetCachePolicy(options.assetsDir);
+	return async (c) => {
+		const path = c.req.path;
+		if (path === "/api" || path.startsWith("/api/") || c.req.method !== "GET" && c.req.method !== "HEAD") return c.text("Not Found", 404);
+		const assets = c.env?.ASSETS;
+		const assetResponse = assets && typeof assets.fetch === "function" ? await assets.fetch(c.req.raw) : options.routing.markNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));
+		if (assetResponse.status !== 404) return cachePolicy(c.req.raw, c.env, assetResponse);
+		const fallback = options.fallbackRules ? await options.routing.applyFallback(c, options.fallbackRules) : void 0;
+		if (fallback) return fallback;
+		if (path.includes("/.") || path.substring(path.lastIndexOf("/") + 1).includes(".")) return options.errors.serveCustomPage(c, 404, "Not Found");
+		if (path !== "/" && path.endsWith("/")) {
+			const url = new URL(c.req.url);
+			url.pathname = path.slice(0, -1);
+			return Response.redirect(url.href, 301);
+		}
+		return options.routing.markNoMatch(c.req.raw, await options.errors.serveCustomPage(c, 404, "Not Found"));
+	};
+}
+function createSsrFallback(options) {
+	const cachePolicy = createAssetCachePolicy(options.assetsDir);
+	const fetchAssets = async (c) => {
+		const binding = c.env?.ASSETS;
+		if (!binding || typeof binding.fetch !== "function") return options.routing.markNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));
+		const response = await binding.fetch(c.req.raw);
+		return response.status === 404 ? options.routing.markNoMatch(c.req.raw, new Response("Not Found", { status: 404 })) : cachePolicy(c.req.raw, c.env, response);
+	};
+	return async (c) => {
+		if (options.nodeTarget && options.fallbackRules) {
+			const fallback = await options.routing.applyFallback(c, options.fallbackRules);
+			if (fallback) return fallback;
+		}
+		const path = c.req.path;
+		const destination = c.req.header("sec-fetch-dest");
+		if (path === "/api" || path.startsWith("/api/") || /\/[^/]+\.[^/]+$/.test(path) || destination && destination !== "document" && destination !== "empty") {
+			const response = await fetchAssets(c);
+			if (!options.nodeTarget && options.fallbackRules && response.status === 404) {
+				const fallback = await options.routing.applyFallback(c, options.fallbackRules);
+				if (fallback) return fallback;
+			}
+			return response;
+		}
+		const mod = await options.load();
+		const render = typeof mod.render === "function" ? mod.render : mod.default;
+		if (typeof render !== "function") throw new Error("ssr: Invalid entry. Export render(c, assetTags).");
+		return render(c, await options.assets(c.req.raw, c.env));
+	};
+}
+function createAssetNotFound(options) {
+	const cachePolicy = createAssetCachePolicy(options.assetsDir);
+	return async (c) => {
+		if (!options.nodeTarget) {
+			const assets = c.env?.ASSETS;
+			if (assets && typeof assets.fetch === "function") {
+				const response = await assets.fetch(c.req.raw);
+				if (response.status !== 404) return cachePolicy(c.req.raw, c.env, response);
+			}
+		}
+		return (options.fallbackRules ? await options.routing.applyFallback(c, options.fallbackRules) : void 0) ?? options.routing.markNoMatch(c.req.raw, new Response("Not Found", { status: 404 }));
+	};
+}
+//#endregion
+//#region src/runtime/routing.ts
+/** One state owner per generated app: recursive dispatch shares rewrite and fallback guards. */
+function createRoutingRuntime(app, options = {}) {
+	const originalUrls = options.originalUrls ?? /* @__PURE__ */ new WeakMap();
+	const fallbackHandled = /* @__PURE__ */ new WeakSet();
+	const warnedPatterns = /* @__PURE__ */ new Set();
+	const requestContext = new AsyncLocalStorage();
+	const assetExtensions = options.blockedAssetExtensions ?? DEFAULT_ASSET_EXTENSIONS;
+	const assetExtensionRE = assetExtensions.length ? new RegExp(`\\.(${assetExtensions.join("|")})$`, "i") : /(?!)/;
+	const annotate = (response, trace) => {
+		if (!options.dev) return response;
+		const headers = new Headers(response.headers);
+		headers.set("X-Void-Routing", trace);
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	};
+	const dispatch = (request, c) => Promise.resolve(options.nodeTarget ? app.fetch(request, c.env) : app.fetch(request, c.env, c.executionCtx));
+	const rememberOriginal = (request, c) => {
+		originalUrls.set(request, originalUrls.get(c.req.raw) ?? new URL(c.req.url));
+	};
+	const warn = (pattern, error, kind) => {
+		if (warnedPatterns.has(pattern)) return;
+		warnedPatterns.add(pattern);
+		const detail = error instanceof Error ? error.message : String(error);
+		console.warn(kind === "routing" ? `[void] skipping routing rule with invalid source ${JSON.stringify(pattern)}: ${detail}` : `[void] failed to compile route pattern ${JSON.stringify(pattern)}: ${detail}`);
+	};
+	const applyRules = async (c, rules, fallback) => {
+		const url = new URL(c.req.url);
+		for (const rule of rules) {
+			if (rule.host && rule.host !== url.hostname) continue;
+			let match;
+			try {
+				match = compilePattern(rule.source).regex.exec(url.pathname);
+			} catch (error) {
+				warn(rule.source, error, "routing");
+				continue;
+			}
+			if (!match) continue;
+			const destination = substituteParams(rule.destination, match.groups ?? {});
+			if (rule.status === 200) {
+				const q = destination.indexOf("?");
+				const rewriteUrl = new URL(c.req.url);
+				rewriteUrl.pathname = q === -1 ? destination : destination.slice(0, q);
+				const search = q === -1 ? "" : destination.slice(q);
+				if (search) rewriteUrl.search = search;
+				const request = new Request(rewriteUrl.toString(), c.req.raw);
+				rememberOriginal(request, c);
+				if (fallback) fallbackHandled.add(request);
+				const response = await dispatch(request, c);
+				const kind = rule.force === true ? "rewrite" : "fallback";
+				return annotate(response, `${kind}[${rule.source}] -> ${destination} (${rule.origin || "unknown"})`);
+			}
+			const location = mergeQueryIntoLocation(destination, url.search);
+			return annotate(c.redirect(location, rule.status), `redirect[${rule.source}] -> ${destination} ${rule.status} (${rule.origin || "unknown"})`);
+		}
+	};
+	const contextMiddleware = async (context, next) => {
+		const c = context;
+		if (options.managedDispatch && !originalUrls.has(c.req.raw)) {
+			const original = c.req.raw.headers.get("X-Void-Original-URL");
+			if (original != null) try {
+				originalUrls.set(c.req.raw, new URL(original));
+			} catch {}
+		}
+		c.rewrite = (path) => {
+			if (!path.startsWith("/") || path.startsWith("//")) throw new Error("c.rewrite() only accepts internal, path-absolute destinations — they must start with a single \"/\" (a leading \"//\" parses as protocol-relative and would proxy cross-origin); use fetch() for external URLs");
+			const q = path.indexOf("?");
+			const h = path.indexOf("#");
+			const first = q === -1 ? h : h === -1 ? q : Math.min(q, h);
+			const pathname = first === -1 ? path : path.slice(0, first);
+			if (assetExtensionRE.test(pathname)) throw new VoidAssetRewriteError(path);
+			const search = q === -1 ? "" : path.slice(q, h === -1 ? path.length : h);
+			const url = new URL(c.req.url);
+			url.pathname = pathname;
+			if (search) url.search = search;
+			const request = new Request(url.toString(), c.req.raw);
+			rememberOriginal(request, c);
+			return dispatch(request, c).then((response) => annotate(response, `c.rewrite -> ${path} (middleware)`));
+		};
+		const redirect = c.redirect.bind(c);
+		c.redirect = (location, status) => {
+			if (typeof location === "string" && location.startsWith("/") && !location.startsWith("//")) return redirect(mergeQueryIntoLocation(location, new URL(c.req.raw.url).search), status);
+			return redirect(location, status);
+		};
+		c.originalUrl = () => originalUrls.get(c.req.raw) ?? null;
+		c.isRewritten = () => originalUrls.has(c.req.raw);
+		await next();
+	};
+	return {
+		requestContext,
+		originalUrls,
+		contextMiddleware,
+		requestMiddleware: async (c, next) => {
+			await requestContext.run(options.nodeTarget ? { request: c.req.raw } : {
+				request: c.req.raw,
+				executionCtx: c.executionCtx
+			}, next);
+		},
+		routingMiddleware: (rules) => async (c, next) => {
+			if (originalUrls.has(c.req.raw)) return next();
+			const response = await applyRules(c, rules, false);
+			if (response) return response;
+			await next();
+			if (options.dev && c.res && !c.res.headers.has("X-Void-Routing")) try {
+				c.res.headers.set("X-Void-Routing", "pass-through");
+			} catch {}
+		},
+		headerMiddleware: (rules) => async (c, next) => {
+			await next();
+			const pathname = new URL(c.req.url).pathname;
+			const matched = [];
+			for (const rule of rules) try {
+				if (compilePattern(rule.pattern).regex.test(pathname)) matched.push(...rule.headers);
+			} catch (error) {
+				warn(rule.pattern, error, "header");
+			}
+			if (!matched.length) return;
+			const headers = new Headers(c.res.headers);
+			for (const [name, value] of matched) headers.set(name, value);
+			c.res = new Response(c.res.body, {
+				headers,
+				status: c.res.status,
+				statusText: c.res.statusText
+			});
+		},
+		applyFallback: (c, rules) => fallbackHandled.has(c.req.raw) ? Promise.resolve(void 0) : applyRules(c, rules, true),
+		markNoMatch
+	};
+}
+const DEFAULT_ASSET_EXTENSIONS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"avif",
+	"svg",
+	"ico",
+	"css",
+	"js",
+	"mjs",
+	"cjs",
+	"woff",
+	"woff2",
+	"ttf",
+	"otf",
+	"eot",
+	"mp4",
+	"webm",
+	"mp3",
+	"wav",
+	"pdf",
+	"txt",
+	"xml",
+	"json",
+	"wasm",
+	"map"
+];
+function markNoMatch(request, response) {
+	const url = new URL(request.url);
+	if (response.status !== 404 || request.method !== "GET" && request.method !== "HEAD" || url.pathname === "/api" || url.pathname.startsWith("/api/") || /\/[^/]+\.[^/]+$/.test(url.pathname)) return response;
+	const headers = new Headers(response.headers);
+	headers.set("X-Void-No-Match", "1");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function createHttpRouteHandler(load, method) {
+	return async (c) => convertReturnValue(await (await load())[method](c));
+}
+function createModuleLoader(load, cache = true) {
+	let module;
+	return async () => {
+		if (!cache) return load();
+		if (!module) module = await load();
+		return module;
+	};
+}
+//#endregion
+export { DEFAULT_ASSET_EXTENSIONS, createAssetFallback, createAssetNotFound, createClientAssetTags, createErrorRenderer, createHttpRouteHandler, createManifestLoader, createModuleLoader, createPageGetHandler, createPageMutationHandler, createPagesFallback, createRoutingRuntime, createSsrFallback, createWorkerFetch, filterInternalBindings, markNoMatch };