void 0.10.8 → 0.10.11

package/dist/runtime/isr-cache.mjs

@@ -0,0 +1,523 @@
+//#region src/runtime/isr-cache.ts
+/**
+* Build the normalized path segment for an ISR-cached page.
+* Root path `/` maps to `__index__` to avoid trailing-slash ambiguity.
+*/
+function normalizeIsrPath(pathname) {
+	let normalized = pathname;
+	if (normalized === "/") normalized = "__index__";
+	else {
+		normalized = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+		if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+	}
+	return normalized;
+}
+/**
+* Inverse of `normalizeIsrPath`: turn a normalized segment back into a
+* pathname starting with `/`.
+*/
+function denormalizeIsrPath(normalized) {
+	return normalized === "__index__" ? "/" : `/${normalized}`;
+}
+/**
+* Canonicalize an inbound pathname to the form used inside edge cache URLs.
+* Equivalent to `denormalizeIsrPath(normalizeIsrPath(pathname))` — strips any
+* trailing slash except for root.
+*/
+function canonicalIsrPathname(pathname) {
+	return denormalizeIsrPath(normalizeIsrPath(pathname));
+}
+/**
+* KV cache key for an ISR-cached page. Deployment- AND host-scoped: cached HTML
+* cannot outlive the hashed assets of the deployment that produced it (a fresh
+* `wrangler deploy` mints a new deployment id → cold cache), and one host's
+* cached content never bleeds into another host served by the same worker
+* (custom domain + workers.dev, apex + www, etc.).
+*/
+function isrKey(deploymentId, host, pathname) {
+	return `void-isr/${deploymentId}/${host}/${normalizeIsrPath(pathname)}`;
+}
+/**
+* Host-registry key. Every host that has written cached content registers itself
+* under `void-isr-hosts/<id>/<host>` (value `''`) so a purge with no request host
+* (cron / queue `revalidate({ paths })`) can enumerate the hosts to purge.
+* Scoped by deployment id so registrations from an old deploy do not leak.
+*/
+function hostRegistryKey(deploymentId, host) {
+	return `void-isr-hosts/${deploymentId}/${host}`;
+}
+/**
+* Edge-cache (`caches.default`) key for the HTML variant. The public URL stays
+* clean; this internal key carries the deployment id so a new deploy never
+* reads HTML produced by an older deploy.
+*/
+function htmlEdgeKey(host, pathname, id) {
+	return `https://${host}${canonicalIsrPathname(pathname)}?__void_isr=${id}`;
+}
+/**
+* Edge-cache key for the JSON (pages-protocol) variant. Separated from HTML by
+* the `&__void=json` marker.
+*/
+function jsonEdgeKey(host, pathname, id) {
+	return `${htmlEdgeKey(host, pathname, id)}&__void=json`;
+}
+const MAX_CACHE = 256;
+const literalRegexCache = /* @__PURE__ */ new Map();
+/**
+* Match a pattern against a pathname using LITERAL semantics — no named
+* captures. Two wildcards are special: `*` matches any characters INCLUDING `/`
+* (a splat), and a WHOLE-segment `:name` (preceded by `/` or start, followed by
+* `/` or end) matches exactly ONE path segment (`[^/]+`). A mid-segment literal
+* `:` (e.g. `/api/v1:health`) is left alone. This is a strict SUPERSET of the
+* old `*`-only matcher (old `*`-only manifests match identically). Malformed
+* patterns yield `false` rather than throwing.
+*/
+function matchLiteralPattern(pattern, pathname) {
+	let regex = literalRegexCache.get(pattern);
+	if (regex) {
+		literalRegexCache.delete(pattern);
+		literalRegexCache.set(pattern, regex);
+	} else {
+		try {
+			const escaped = pattern.replace(/(^|\/):[A-Za-z0-9_]+(?=\/|$)/g, "$1").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("", "[^/]+");
+			regex = new RegExp(`^${escaped}$`);
+		} catch {
+			return false;
+		}
+		if (literalRegexCache.size >= MAX_CACHE) {
+			const first = literalRegexCache.keys().next();
+			if (!first.done) literalRegexCache.delete(first.value);
+		}
+		literalRegexCache.set(pattern, regex);
+	}
+	try {
+		return regex.test(pathname);
+	} catch {
+		return false;
+	}
+}
+/**
+* Pack response headers + body into a single ArrayBuffer.
+* Format: [4 bytes uint32 LE header length][UTF-8 header JSON][raw body]
+*/
+function packIsrValue(headers, body) {
+	const headerJson = new TextEncoder().encode(JSON.stringify(headers));
+	const buffer = new ArrayBuffer(4 + headerJson.byteLength + body.byteLength);
+	new DataView(buffer).setUint32(0, headerJson.byteLength, true);
+	new Uint8Array(buffer, 4, headerJson.byteLength).set(headerJson);
+	new Uint8Array(buffer, 4 + headerJson.byteLength).set(new Uint8Array(body));
+	return buffer;
+}
+/**
+* Unpack headers + body from a packed ArrayBuffer.
+* Returns null if the buffer is too small or malformed.
+*/
+function unpackIsrValue(buffer) {
+	if (buffer.byteLength < 4) return null;
+	const headerLen = new DataView(buffer).getUint32(0, true);
+	if (buffer.byteLength < 4 + headerLen) return null;
+	try {
+		const headerBytes = new Uint8Array(buffer, 4, headerLen);
+		return {
+			headers: JSON.parse(new TextDecoder().decode(headerBytes)),
+			body: buffer.slice(4 + headerLen)
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Read an ISR cache entry from KV. Returns null on cache miss, malformed
+* metadata, or ANY KV error (fail-open → caller renders live). The KV key is
+* deployment-scoped via `env.__VOID_ISR_DEPLOYMENT_ID` (see module header) and
+* host-scoped via `host` so one host never reads another host's cached bytes.
+*/
+async function readIsrCache(env, host, pathname) {
+	const kv = env.ISR_CACHE;
+	if (!kv) return null;
+	const key = isrKey(env.__VOID_ISR_DEPLOYMENT_ID ?? "", host, pathname);
+	let value;
+	let metadata;
+	try {
+		const result = await kv.getWithMetadata(key, "arrayBuffer");
+		value = result.value;
+		metadata = result.metadata;
+	} catch {
+		return null;
+	}
+	if (!value || !metadata) return null;
+	const unpacked = unpackIsrValue(value);
+	if (!unpacked) return null;
+	if (!Number.isInteger(metadata.s) || metadata.s < 200 || metadata.s > 599) return null;
+	if (!Number.isFinite(metadata.c) || metadata.c <= 0 || !Number.isFinite(metadata.t) || metadata.t <= 0) return null;
+	try {
+		new Headers(unpacked.headers);
+	} catch {
+		return null;
+	}
+	return {
+		body: new ReadableStream({ start(controller) {
+			controller.enqueue(new Uint8Array(unpacked.body));
+			controller.close();
+		} }),
+		status: metadata.s,
+		headers: unpacked.headers,
+		createdAt: metadata.c,
+		ttl: metadata.t
+	};
+}
+/**
+* Write an ISR cache entry to KV. The `response.clone()` is taken SYNCHRONOUSLY
+* before any `await` so a caller that consumes `response.body` for the client
+* response (after kicking us off via `ctx.waitUntil`) cannot race the body
+* away. Any KV error is swallowed (fail-open on the write path).
+*/
+async function writeIsrCache(env, host, pathname, response, ttl) {
+	const kv = env.ISR_CACHE;
+	if (!kv) return;
+	const responseClone = response.clone();
+	const headers = serializeHeaders(responseClone);
+	const status = responseClone.status;
+	const id = env.__VOID_ISR_DEPLOYMENT_ID ?? "";
+	try {
+		const packed = packIsrValue(headers, await responseClone.arrayBuffer());
+		await kv.put(isrKey(id, host, pathname), packed, { metadata: {
+			s: status,
+			c: Date.now(),
+			t: ttl
+		} });
+	} catch {}
+	await registerIsrHost(kv, id, host);
+}
+/**
+* In-isolate guard: `${id}/${host}` values whose host-registry key this isolate
+* has already written (or attempted). Bounds host registration to ~one KV write
+* per (isolate, deployment, host) instead of one per page write.
+*/
+const registeredHosts = /* @__PURE__ */ new Set();
+async function registerIsrHost(kv, deploymentId, host) {
+	const guardKey = `${deploymentId}/${host}`;
+	if (registeredHosts.has(guardKey)) return;
+	registeredHosts.add(guardKey);
+	try {
+		await kv.put(hostRegistryKey(deploymentId, host), "");
+	} catch {
+		registeredHosts.delete(guardKey);
+	}
+}
+/**
+* List every host that has registered cached content for a deployment. Used by
+* the on-demand `revalidate({ paths })` purge when there is no request host
+* (cron / queue). Fail-open: a registry read error yields the hosts collected so
+* far (or none) rather than throwing — degraded purge coverage, never a 500.
+*/
+async function listIsrHosts(kv, deploymentId) {
+	const prefix = `void-isr-hosts/${deploymentId}/`;
+	const hosts = [];
+	try {
+		let cursor;
+		do {
+			const list = await kv.list({
+				prefix,
+				cursor
+			});
+			for (const key of list.keys) hosts.push(key.name.slice(prefix.length));
+			cursor = list.list_complete ? void 0 : list.cursor;
+		} while (cursor);
+	} catch {}
+	return hosts;
+}
+/**
+* Delete an ISR cache entry from KV. Used when a worker permanently opts out
+* via `x-revalidate: 0`. Any KV error is swallowed (fail-open).
+*/
+async function deleteIsrCache(env, host, pathname) {
+	const kv = env.ISR_CACHE;
+	if (!kv) return;
+	try {
+		await kv.delete(isrKey(env.__VOID_ISR_DEPLOYMENT_ID ?? "", host, pathname));
+	} catch {}
+}
+/** Check if a cached entry is stale. */
+function isStale(entry) {
+	return Date.now() - entry.createdAt > entry.ttl * 1e3;
+}
+/** Build a Response from an ISR cache entry. */
+function isrCacheResponse(entry, stale) {
+	const headers = new Headers(entry.headers);
+	headers.set("x-isr-cache", stale ? "STALE" : "HIT");
+	if (stale) {
+		const staleTtl = Math.min(10, entry.ttl);
+		headers.set("Cache-Control", `public, s-maxage=${staleTtl}, max-age=0, must-revalidate`);
+	} else {
+		const remainingSeconds = Math.max(0, Math.floor((entry.createdAt + entry.ttl * 1e3 - Date.now()) / 1e3));
+		headers.set("Cache-Control", `public, s-maxage=${remainingSeconds}, max-age=0, must-revalidate`);
+	}
+	return new Response(entry.body, {
+		status: entry.status,
+		headers
+	});
+}
+/**
+* Read the `x-revalidate` header from a worker response.
+* Returns the override TTL, or the default. A value of 0 means "do not cache".
+*/
+function resolveRevalidateTtl(response, defaultTtl) {
+	const header = response.headers.get("x-revalidate");
+	if (header === null) return defaultTtl;
+	const value = parseInt(header, 10);
+	if (isNaN(value) || value < 0) return defaultTtl;
+	return value;
+}
+function acceptsEventStream(request) {
+	return request.headers.get("Accept")?.toLowerCase().split(",").some((part) => part.split(";", 1)[0]?.trim() === "text/event-stream") ?? false;
+}
+/**
+* ISR should be bypassed for requests with credentials and EventSource
+* requests. Pages protocol navigation (X-VoidPages) uses a separate JSON edge
+* cache.
+*/
+function shouldBypassIsr(request) {
+	return request.headers.has("Cookie") || request.headers.has("Authorization") || acceptsEventStream(request);
+}
+/**
+* Resolve the ISR TTL for a given pathname.
+* Accepts the `revalidate` config (number, object, or undefined). For the
+* object form, the first matching pattern wins.
+*/
+function resolvePathTtl(revalidate, pathname) {
+	if (revalidate == null) return 0;
+	if (typeof revalidate === "number") return revalidate;
+	for (const [pattern, ttl] of Object.entries(revalidate)) if (matchLiteralPattern(pattern, pathname)) return ttl;
+	return 0;
+}
+/** Extract response headers as a plain object, skipping ISR-managed headers. */
+const SKIP_HEADERS = /* @__PURE__ */ new Set([
+	"cache-control",
+	"x-isr-cache",
+	"x-void-page-data",
+	"set-cookie"
+]);
+function serializeHeaders(response) {
+	const result = {};
+	response.headers.forEach((value, key) => {
+		if (!SKIP_HEADERS.has(key.toLowerCase())) result[key] = value;
+	});
+	return result;
+}
+const PAGE_DATA_SCRIPT_RE = /<script\b[^>]*\bid=(["'])__VOID_PAGE_DATA__\1[^>]*>([\s\S]*?)<\/script>/i;
+function normalizePageDataForJsonCache(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.deferred !== void 0 || parsed.deferredKeys !== void 0) return null;
+		return raw;
+	} catch {
+		return null;
+	}
+}
+function extractPageDataFromHtml(html) {
+	const match = html.match(PAGE_DATA_SCRIPT_RE);
+	if (!match) return null;
+	return normalizePageDataForJsonCache(match[2]);
+}
+const CLIENT_REVALIDATE_CACHE_CONTROL = "public, max-age=0, must-revalidate";
+function clientRevalidateResponse(response) {
+	const res = new Response(response.body, response);
+	res.headers.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
+	return res;
+}
+function isEventStreamResponse(response) {
+	return response.headers.get("content-type")?.toLowerCase().split(";", 1)[0]?.trim() === "text/event-stream";
+}
+function jsonCacheResponse(pageData, ttl, state) {
+	return new Response(pageData, { headers: {
+		"content-type": "application/json",
+		"X-VoidPages": "true",
+		Vary: "X-VoidPages",
+		"Cache-Control": `public, s-maxage=${ttl}, max-age=0, must-revalidate`,
+		"x-isr-cache": state
+	} });
+}
+/**
+* Populate the JSON edge cache from a response's embedded page data (the
+* `x-void-page-data` header or the `__VOID_PAGE_DATA__` inline script). No-ops
+* when there is no extractable page data. Any cache error is swallowed
+* (fail-open) so this is always safe to fire inside `ctx.waitUntil`.
+*/
+async function populateJsonEdgeCache(cache, cacheKey, response, ttl, state) {
+	if (!cache) return;
+	try {
+		const fromHeader = response.headers.get("x-void-page-data");
+		const pageData = fromHeader ? normalizePageDataForJsonCache(fromHeader) : extractPageDataFromHtml(await response.clone().text());
+		if (!pageData) return;
+		await cache.put(cacheKey, jsonCacheResponse(pageData, ttl, state));
+	} catch {}
+}
+/**
+* The per-colo edge cache (`caches.default`), or `undefined` when the Cache API
+* is absent/degraded. Accessed through a cast because this package has both
+* `@types/node` and `@cloudflare/workers-types` in scope, and Node's ambient
+* `CacheStorage` (which lacks `.default`) otherwise shadows the Workers one on
+* the `caches` global.
+*
+* Non-throwing by contract: dereferencing `caches.default` can throw if the
+* Cache API is missing (e.g. a non-worker runtime) or degraded. We swallow that
+* here and return `undefined` so `handleIsr` never rejects before its fail-open
+* guards run — the serving invariant is a degraded cache must render live, never
+* 500. Every call site guards `undefined` (via `if (!cache)` or `cache?.`).
+*/
+function edgeCache() {
+	try {
+		return caches.default;
+	} catch {
+		return;
+	}
+}
+async function safeCachePut(cache, key, response) {
+	if (!cache) return;
+	try {
+		await cache.put(key, response);
+	} catch {}
+}
+async function safeCacheDelete(cache, key) {
+	if (!cache) return;
+	try {
+		await cache.delete(key);
+	} catch {}
+}
+/**
+* Build a new Request with the `X-VoidPages` header removed. Headers on an
+* existing Request are immutable, so we must clone into a fresh Request. ISR
+* only runs for GET, so there is no body to preserve.
+*/
+function cloneWithoutVoidPages(request) {
+	const headers = new Headers(request.headers);
+	headers.delete("X-VoidPages");
+	return new Request(request, { headers });
+}
+/**
+* Revalidate an ISR page in the background. Re-renders as HTML (X-VoidPages
+* stripped), writes fresh HTML to KV + HTML edge cache, and populates the JSON
+* edge cache from embedded page data. Errors are caught and logged — serve
+* stale, don't retry. `ttl === 0` means the worker permanently opted out:
+* delete the KV entry and both edge variants.
+*/
+async function revalidateInBackground(env, request, host, pathname, defaultTtl, keys, render) {
+	try {
+		const response = await render(cloneWithoutVoidPages(request));
+		if (isEventStreamResponse(response)) return;
+		const ttl = resolveRevalidateTtl(response, defaultTtl);
+		const cache = edgeCache();
+		if (ttl > 0 && response.status === 200) {
+			await writeIsrCache(env, host, pathname, response, ttl);
+			const headers = new Headers(response.headers);
+			headers.set("x-isr-cache", "HIT");
+			headers.set("Cache-Control", `public, s-maxage=${ttl}, max-age=0, must-revalidate`);
+			headers.delete("set-cookie");
+			headers.delete("x-void-page-data");
+			await safeCachePut(cache, keys.htmlKey, new Response(response.clone().body, {
+				status: response.status,
+				headers
+			}));
+			await populateJsonEdgeCache(cache, keys.jsonKey, response, ttl, "HIT");
+		} else if (ttl === 0) {
+			await deleteIsrCache(env, host, pathname);
+			await safeCacheDelete(cache, keys.htmlKey);
+			await safeCacheDelete(cache, keys.jsonKey);
+		}
+	} catch (err) {
+		console.error("ISR revalidation failed:", err);
+	}
+}
+/**
+* Run the ISR caching ladder for a request.
+*
+* Returns a cached/rendered `Response` when ISR applies, or `null` when the
+* caller should render live itself (request not ISR-eligible, or a read/hit
+* cache op failed open).
+*
+* Ladder:
+*   - Bail (`null`) if not GET, a Range request, `shouldBypassIsr`, or the path
+*     has no ISR TTL. Range requests bail BEFORE any cache read/write so they
+*     render live (correct 206) and never touch the shared full-response entry.
+*   - JSON (X-VoidPages) path: edge match → hit serves `clientRevalidateResponse`;
+*     miss renders live JSON and returns it — the JSON path never writes the edge
+*     cache. The JSON edge variant is warmed only as a side-effect of the HTML
+*     render path (cold colo re-renders JSON).
+*   - HTML path: L1 edge match → L2 KV. Hit serves `isrCacheResponse`
+*     (stale hits also queue a background revalidation). Miss renders live and,
+*     when cacheable, writes KV + JSON edge + HTML edge in the background.
+*/
+async function handleIsr(request, env, ctx, options, render) {
+	const { revalidate, deploymentId } = options;
+	if (request.method !== "GET") return null;
+	if (request.headers.has("range")) return null;
+	if (shouldBypassIsr(request)) return null;
+	const url = new URL(request.url);
+	const pathname = url.pathname;
+	const isrTtl = resolvePathTtl(revalidate, pathname);
+	if (isrTtl <= 0) return null;
+	env.__VOID_ISR_DEPLOYMENT_ID ??= deploymentId;
+	const host = url.hostname;
+	const cache = edgeCache();
+	if (request.headers.has("X-VoidPages")) {
+		const jsonKey = jsonEdgeKey(host, pathname, deploymentId);
+		let jsonCached;
+		try {
+			jsonCached = await cache?.match(jsonKey);
+		} catch {
+			return null;
+		}
+		if (jsonCached) return clientRevalidateResponse(jsonCached);
+		return render(request);
+	}
+	const htmlKey = htmlEdgeKey(host, pathname, deploymentId);
+	const jsonKey = jsonEdgeKey(host, pathname, deploymentId);
+	let edgeCached;
+	try {
+		edgeCached = await cache?.match(htmlKey);
+	} catch {
+		return null;
+	}
+	if (edgeCached) return clientRevalidateResponse(edgeCached);
+	const cached = await readIsrCache(env, host, pathname);
+	if (cached) try {
+		const stale = isStale(cached);
+		if (stale) ctx.waitUntil(revalidateInBackground(env, request, host, pathname, isrTtl, {
+			htmlKey,
+			jsonKey
+		}, render));
+		const cacheResponse = isrCacheResponse(cached, stale);
+		ctx.waitUntil(safeCachePut(cache, htmlKey, cacheResponse.clone()));
+		return clientRevalidateResponse(cacheResponse);
+	} catch {
+		return null;
+	}
+	const response = await render(request);
+	if (isEventStreamResponse(response)) return response;
+	const ttl = resolveRevalidateTtl(response, isrTtl);
+	if (ttl > 0 && response.status === 200) {
+		ctx.waitUntil(writeIsrCache(env, host, pathname, response, ttl));
+		ctx.waitUntil(populateJsonEdgeCache(cache, jsonKey, response, ttl, "MISS"));
+		const cacheHeaders = new Headers(response.headers);
+		cacheHeaders.set("Cache-Control", `public, s-maxage=${ttl}, max-age=0, must-revalidate`);
+		cacheHeaders.set("x-isr-cache", "MISS");
+		cacheHeaders.delete("x-void-page-data");
+		cacheHeaders.delete("set-cookie");
+		const cacheResponse = new Response(response.clone().body, {
+			status: response.status,
+			headers: cacheHeaders
+		});
+		ctx.waitUntil(safeCachePut(cache, htmlKey, cacheResponse));
+		const clientHeaders = new Headers(cacheHeaders);
+		clientHeaders.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
+		for (const cookie of response.headers.getSetCookie()) clientHeaders.append("set-cookie", cookie);
+		return new Response(response.body, {
+			status: response.status,
+			headers: clientHeaders
+		});
+	}
+	return response;
+}
+//#endregion
+export { canonicalIsrPathname, clientRevalidateResponse, cloneWithoutVoidPages, deleteIsrCache, denormalizeIsrPath, extractPageDataFromHtml, handleIsr, hostRegistryKey, htmlEdgeKey, isEventStreamResponse, isStale, isrCacheResponse, isrKey, jsonEdgeKey, listIsrHosts, matchLiteralPattern, normalizeIsrPath, normalizePageDataForJsonCache, packIsrValue, populateJsonEdgeCache, readIsrCache, resolvePathTtl, resolveRevalidateTtl, serializeHeaders, shouldBypassIsr, unpackIsrValue, writeIsrCache };

package/dist/runtime/isr.d.mts

@@ -6,9 +6,10 @@ type RevalidateOptions = {
 /**
 * Revalidate ISR-cached pages on demand.
 *
-* In production, calls the platform proxy via service binding which forwards
-* to the API for R2 deletion + edge cache purge. In local dev, this is a
-* no-op (no ISR cache to purge).
+* On managed Void, calls the platform proxy via service binding which forwards
+* to the API for R2 deletion + edge cache purge. On self-host, purges this
+* worker's own ISR_CACHE (KV) entries plus the caches.default edge variants.
+* When neither is configured (e.g. local dev with no ISR), this is a no-op.
 *
 * @example
 * ```ts

package/dist/runtime/isr.mjs

@@ -1,11 +1,13 @@
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
+import { denormalizeIsrPath, htmlEdgeKey, isrKey, jsonEdgeKey, listIsrHosts } from "./isr-cache.mjs";
 //#region src/runtime/isr.ts
 /**
 * Revalidate ISR-cached pages on demand.
 *
-* In production, calls the platform proxy via service binding which forwards
-* to the API for R2 deletion + edge cache purge. In local dev, this is a
-* no-op (no ISR cache to purge).
+* On managed Void, calls the platform proxy via service binding which forwards
+* to the API for R2 deletion + edge cache purge. On self-host, purges this
+* worker's own ISR_CACHE (KV) entries plus the caches.default edge variants.
+* When neither is configured (e.g. local dev with no ISR), this is a no-op.
 *
 * @example
 * ```ts
@@ -21,7 +23,44 @@ import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
 async function revalidate(options) {
 	const rawEnv = getRawRuntimeEnv();
 	const proxy = rawEnv.__VOID_PROXY;
-	if (!proxy) return;
+	if (!proxy) {
+		const kv = rawEnv.ISR_CACHE;
+		const id = rawEnv.__VOID_ISR_DEPLOYMENT_ID;
+		if (!kv || !id) return;
+		const requestHost = rawEnv.__VOID_ISR_HOST;
+		const purge = async (host, path) => {
+			await kv.delete(isrKey(id, host, path));
+			try {
+				const cache = caches.default;
+				await cache.delete(htmlEdgeKey(host, path, id));
+				await cache.delete(jsonEdgeKey(host, path, id));
+			} catch {}
+		};
+		if (options.all) {
+			const prefix = `void-isr/${id}/`;
+			let cursor;
+			do {
+				const list = await kv.list({
+					prefix,
+					cursor
+				});
+				for (const key of list.keys) {
+					const tail = key.name.slice(prefix.length);
+					const slash = tail.indexOf("/");
+					if (slash < 0) continue;
+					await purge(tail.slice(0, slash), denormalizeIsrPath(tail.slice(slash + 1)));
+				}
+				cursor = list.list_complete ? void 0 : list.cursor;
+			} while (cursor);
+		} else {
+			const paths = options.paths ?? [];
+			if (paths.length === 0) return;
+			const hosts = new Set(await listIsrHosts(kv, id));
+			if (requestHost) hosts.add(requestHost);
+			for (const host of hosts) for (const path of paths) await purge(host, path);
+		}
+		return;
+	}
 	const projectId = rawEnv.__PROJECT_ID;
 	const token = rawEnv.__VOID_PROXY_TOKEN;
 	if (!projectId || !token) throw new Error("isr: Revalidation requires __PROJECT_ID and __VOID_PROXY_TOKEN bindings.");

package/dist/runtime/live.d.mts

@@ -1,6 +1,6 @@
 /// <reference types="@cloudflare/workers-types" />
 import { r as AuthUser } from "../auth-qgMlYp7Z.mjs";
-import { a as CloudEnv, r as CloudContext } from "../handler-imD0UVDT.mjs";
+import { a as CloudEnv, r as CloudContext } from "../handler-Cjh8uM3Y.mjs";
 
 //#region src/runtime/live.d.ts
 type MaybePromise<T> = T | Promise<T>;

package/dist/runtime/live.mjs

@@ -1,4 +1,4 @@
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
 import { getUser } from "./auth.mjs";
 //#region src/runtime/live.ts
 let liveBindingName = "VOID_LIVE";

package/dist/runtime/sandbox.mjs

@@ -1,4 +1,4 @@
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
 import { requireRuntimeBinding } from "./env.mjs";
 import { Sandbox, getSandbox as getSandbox$1 } from "@cloudflare/sandbox";
 //#region src/runtime/sandbox.ts

package/dist/runtime/validator.d.mts

@@ -1,2 +1,2 @@
-import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-imD0UVDT.mjs";
+import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-Cjh8uM3Y.mjs";
 export { HandlerInput, ValidatorSlots, runValidation };

package/dist/runtime/ws-server.d.mts

@@ -1,5 +1,5 @@
 import { n as AuthState } from "../auth-qgMlYp7Z.mjs";
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-BvnM9px6.mjs";
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-DealXecJ.mjs";
 import { AnyWebSocketDefinition } from "./ws.mjs";
 
 //#region src/runtime/ws-server.d.ts

package/dist/runtime/ws.d.mts

@@ -1,6 +1,6 @@
-import { r as AuthUser } from "../auth-qgMlYp7Z.mjs";
 import { t as StandardSchemaV1 } from "../standard-schema-DJ0HW7QP.mjs";
-import { a as CloudEnv } from "../handler-imD0UVDT.mjs";
+import { r as AuthUser } from "../auth-qgMlYp7Z.mjs";
+import { a as CloudEnv } from "../handler-Cjh8uM3Y.mjs";
 import { WebSocketRouteMap } from "void/routes";
 
 //#region src/runtime/ws.d.ts

package/dist/{scan-Dp_Gyzs3.mjs → scan-DEwlM_Xy.mjs}

@@ -1,5 +1,5 @@
-import { a as join, n as dirname, r as extname, t as basename } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
+import { a as join, n as dirname, r as extname, t as basename } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
 import { t as glob } from "./dist-BuiRJkTd.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/router/parse-filename.ts

package/dist/{scan-i7Yz54fv.mjs → scan-DYXkrasO.mjs}

@@ -1,8 +1,8 @@
-import { a as join, i as isAbsolute, t as basename } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
+import { a as join, i as isAbsolute, t as basename } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
 import { n as globSync, t as glob } from "./dist-BuiRJkTd.mjs";
-import { d as isCallExpression, f as isIdentifier, h as isObjectExpression, p as isLiteral } from "./plugin-inference-CJxi_fWI.mjs";
-import { o as parseRouteFilename, s as parseWebSocketFilename, t as scanPages } from "./scan-Dp_Gyzs3.mjs";
+import { c as isIdentifier, d as isObjectExpression, l as isLiteral, s as isCallExpression } from "./entry-D7yy4xVH.mjs";
+import { o as parseRouteFilename, s as parseWebSocketFilename, t as scanPages } from "./scan-DEwlM_Xy.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { parseSync } from "vite";

package/dist/{secret-u7FRvg8d.mjs → secret-Dt32J6RI.mjs}

@@ -1,6 +1,6 @@
-import { D as outro, E as note, O as password, S as confirm, T as log, a as cliTitle, j as isCancel, w as intro, x as cancel } from "./agents-Bmr5tFFb.mjs";
-import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Cj96iiBH.mjs";
-import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-D2HI3TrG.mjs";
+import { D as outro, E as note, O as password, S as confirm, T as log, a as cliTitle, j as isCancel, w as intro, x as cancel } from "./agents-CtgBYqld.mjs";
+import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
+import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-BBMtLLV9.mjs";
 import { readFileSync } from "node:fs";
 //#region src/cli/secret.ts
 async function runSecretCommand(root, args) {