void 0.10.7 → 0.10.10

package/dist/{mcp-D7yc0dXY.mjs → mcp-BNjMGMB0.mjs}

@@ -1,5 +1,5 @@
 import { a as join, n as dirname } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { S as writeProjectConfig, f as getToken, n as PlatformClient } from "./client-Cj96iiBH.mjs";
+import { S as writeProjectConfig, f as getToken, n as PlatformClient } from "./client-C9FG6Vzc.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";

package/dist/{node-yFFk626c.mjs → node-CnE-SZCk.mjs}

@@ -1,6 +1,6 @@
 import { a as join } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
 import { c as loadVoidAuthConfig, s as findVoidAuthConfig } from "./scan-i7Yz54fv.mjs";
-import { f as readConfig } from "./config-1twldYCW.mjs";
+import { f as readConfig } from "./config-BcAeIPe3.mjs";
 import { a as resolveVoidAuthMigrationSchema } from "./route-types-CfKfhbIg.mjs";
 import { n as applySqliteAuthMigrations, t as applyPgAuthMigrations } from "./auth-migrations-BTZ-ATvQ.mjs";
 import { getMiniflareDatabasePath } from "./runner-h272wcPj.mjs";

package/dist/pages/index.mjs

@@ -1,8 +1,8 @@
 import { a as join } from "../pathe.M-eThtNZ-CQzLbt4c.mjs";
 import { r as resolvePagesDir } from "../project-paths-tpdR1mJR.mjs";
-import { f as readConfig } from "../config-1twldYCW.mjs";
+import { f as readConfig } from "../config-BcAeIPe3.mjs";
 import { a as resolveNamedLayout, i as resolveLayoutIds, n as resolveEffectiveLayoutChain, r as resolveLayoutChain, t as scanPages } from "../scan-Dp_Gyzs3.mjs";
-import { i as parseRedirectsFile } from "../headers-BwvFGhkx.mjs";
+import { i as parseRedirectsFile } from "../headers-CTAjX-UO.mjs";
 import { renderBodyAttrs, renderHeadToString, renderHtmlAttrs, resolveHead } from "./head.mjs";
 import { serializePageData } from "./serialize.mjs";
 //#region src/pages/manifest.ts

package/dist/{prepare-C_cVurhP.mjs → prepare-BRyC4TCC.mjs}

@@ -3,7 +3,7 @@ import { D as outro, E as note, T as log, a as cliTitle, w as intro } from "./ag
 import { i as resolveProjectPaths } from "./project-paths-tpdR1mJR.mjs";
 import { c as loadVoidAuthConfig, r as scanRoutes, s as findVoidAuthConfig } from "./scan-i7Yz54fv.mjs";
 import { n as ensureProjectTsconfig, r as writeFileIfChanged } from "./project-tsconfig-D9uSVVpA.mjs";
-import { c as getDatabaseDialect, f as readConfig } from "./config-1twldYCW.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BcAeIPe3.mjs";
 import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-CJxi_fWI.mjs";
 import { i as generateVoidAuthDrizzleSchema, n as generateQueueTypes, r as generateVoidAuthDatabaseModule, s as generateDbDts, t as generateRouteTypes } from "./route-types-CfKfhbIg.mjs";
 import { t as discoverSchema } from "./discover-BuVVSAum.mjs";

package/dist/{project-cmd-DnU7u9QF.mjs → project-cmd-B2bcKefD.mjs}

@@ -1,5 +1,5 @@
 import { D as outro, T as log, a as cliTitle, f as tablePrefix, s as dim, u as import_picocolors, w as intro } from "./agents-Bmr5tFFb.mjs";
-import { d as getSiteDomain, f as getToken, n as PlatformClient } from "./client-Cj96iiBH.mjs";
+import { d as getSiteDomain, f as getToken, n as PlatformClient } from "./client-C9FG6Vzc.mjs";
 //#region src/cli/projects.ts
 async function runProjectsCommand(root) {
 	console.log();
@@ -33,32 +33,32 @@ async function runProjectsCommand(root) {
 //#region src/cli/project-cmd.ts
 async function runProjectCommand(root, args) {
 	if (args.subcommand === "status") {
-		const { runListCommand } = await import("./list-3GEw7b6m.mjs");
+		const { runListCommand } = await import("./list-BKDjA3M5.mjs");
 		return runListCommand(root, args.name || void 0);
 	}
 	if (args.subcommand === "link") {
-		const { runLink } = await import("./link-CUmiosyb.mjs");
+		const { runLink } = await import("./link-Co136MEs.mjs");
 		return runLink(root, args.name || void 0);
 	}
 	if (args.subcommand === "list") return runProjectsCommand(root);
 	if (args.subcommand === "logs") {
-		const { runLogsCommand } = await import("./logs-D-rQ56Lq.mjs");
+		const { runLogsCommand } = await import("./logs-DlAg25ww.mjs");
 		return runLogsCommand(root, args.filter, args.range, args.deployment || void 0, args.level || void 0);
 	}
 	if (args.subcommand === "rollback") {
-		const { runRollbackCommand } = await import("./rollback-Yh7bCKob.mjs");
+		const { runRollbackCommand } = await import("./rollback-9dfmB-YZ.mjs");
 		return runRollbackCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "cancel") {
-		const { runCancelDeployCommand } = await import("./cancel-deploy-BEBOEgtu.mjs");
+		const { runCancelDeployCommand } = await import("./cancel-deploy-BosnzEHC.mjs");
 		return runCancelDeployCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "delete") {
-		const { runDeleteCommand } = await import("./delete-D2kr3Kmk.mjs");
+		const { runDeleteCommand } = await import("./delete-CThKLXfi.mjs");
 		return runDeleteCommand(root, args.name || void 0, { force: args.force });
 	}
 	if (args.subcommand === "purge-cache") {
-		const { runPurgeCacheCommand } = await import("./cache-wH-mP8UE.mjs");
+		const { runPurgeCacheCommand } = await import("./cache-DIUSnIjJ.mjs");
 		return runPurgeCacheCommand(root, args.projectSlug || void 0);
 	}
 }

package/dist/{rollback-Yh7bCKob.mjs → rollback-9dfmB-YZ.mjs}

@@ -1,5 +1,5 @@
 import { D as outro, S as confirm, T as log, a as cliTitle, c as ensureUtc, j as isCancel, k as select, o as createSpinner, s as dim, u as import_picocolors, 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 { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-C9FG6Vzc.mjs";
 //#region src/cli/rollback.ts
 async function runRollbackCommand(root, deployId) {
 	console.log();

package/dist/runtime/ai.mjs

@@ -1,5 +1,5 @@
 import { t as cfAccessHeaders } from "../cf-access-Bqw81xAf.mjs";
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
 //#region src/runtime/ai-types.ts
 /** Maps provider prefix to expected env var name for the API key */
 const PROVIDER_KEY_MAP = {
@@ -29,6 +29,44 @@ const PROVIDER_KEY_MAP = {
 const PROXY_URL = "https://proxy.void.cloud/ai";
 const STAGING_PROXY_URL = "https://proxy.staging.void.cloud/ai";
 const VOID_FILE_MARKER = "__voidFile";
+const PROVIDER_AUTH_DEFAULTS = {
+	"google-ai-studio": {
+		header: "x-goog-api-key",
+		prefix: ""
+	},
+	anthropic: {
+		header: "x-api-key",
+		prefix: ""
+	},
+	elevenlabs: {
+		header: "xi-api-key",
+		prefix: ""
+	},
+	deepgram: {
+		header: "authorization",
+		prefix: "Token "
+	},
+	fal: {
+		header: "authorization",
+		prefix: "Key "
+	},
+	cartesia: {
+		header: "x-api-key",
+		prefix: ""
+	},
+	baseten: {
+		header: "authorization",
+		prefix: "Api-Key "
+	},
+	ideogram: {
+		header: "Api-Key",
+		prefix: ""
+	},
+	parallel: {
+		header: "x-api-key",
+		prefix: ""
+	}
+};
 function hasStreamFlag(value) {
 	return typeof value === "object" && value !== null && "stream" in value;
 }
@@ -203,6 +241,41 @@ function getProxyUrl(runtimeEnv) {
 	if (typeof custom === "string" && custom.length > 0) return custom + "/ai";
 	return runtimeEnv.__VOID_STAGING ? STAGING_PROXY_URL : PROXY_URL;
 }
+function providerAuthDefaults(provider) {
+	return PROVIDER_AUTH_DEFAULTS[provider] ?? {
+		header: "authorization",
+		prefix: "Bearer "
+	};
+}
+function gatewayEndpointUrl(baseUrl, endpoint) {
+	return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/${endpoint.startsWith("/") ? endpoint.slice(1) : endpoint}`;
+}
+function isUnsafeProviderPath(path) {
+	if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(path) || path.includes("\\")) return true;
+	const pathname = path.split(/[?#]/, 1)[0] ?? "";
+	for (const segment of pathname.split("/")) try {
+		if (decodeURIComponent(segment) === "..") return true;
+	} catch {
+		return true;
+	}
+	return false;
+}
+/**
+* Build a real outgoing HTTP body for the user's own AI Gateway (P3 self-host).
+*
+* Unlike `serializeProviderBody`/`providerRequestBody` (which build the proxy
+* envelope decoded on the proxy side), this emits an actual `BodyInit` +
+* content-type for a direct `fetch` to the gateway.
+*/
+function toDirectBody(body) {
+	if (body === void 0 || body === null) return { body: void 0 };
+	if (typeof body === "string") return { body };
+	if (body instanceof ReadableStream || body instanceof FormData || body instanceof URLSearchParams || body instanceof Blob || body instanceof ArrayBuffer || isBinaryView(body)) return { body };
+	return {
+		body: JSON.stringify(body),
+		contentType: "application/json"
+	};
+}
 function resolveBackend() {
 	const runtimeEnv = getRawRuntimeEnv();
 	const proxy = runtimeEnv.__VOID_PROXY;
@@ -211,26 +284,14 @@ function resolveBackend() {
 	const projectId = runtimeEnv.__VOID_PROJECT_ID;
 	if (typeof token === "string" && typeof projectId === "string") return makeHttpBackend(token, projectId, runtimeEnv);
 	const directAi = runtimeEnv.AI;
-	if (directAi) return {
-		run: directAi.run.bind(directAi),
-		async image(model, inputs, options) {
-			const { runOptions } = splitImageOptions(options);
-			return responseFromResult(await directAi.run(model, inputs, runOptions));
-		},
-		providerFetch: unsupportedProviderFetch,
-		models: directAi.models.bind(directAi),
-		toMarkdown: directAi.toMarkdown?.bind(directAi) ?? unsupported("toMarkdown")
-	};
-	throw new Error("ai: Not available. Run `void auth login` and `void project link` first.");
+	if (directAi) return makeDirectBackend(directAi, runtimeEnv, runtimeEnv.__VOID_AI_GATEWAY);
+	throw new Error("ai: Not available. Run `void auth login` and `void project link` first, or bind Workers AI (env.AI) for self-hosted deploys.");
 }
 function unsupported(method) {
 	return () => {
 		throw new Error(`ai: ai.${method}() is not supported in this environment.`);
 	};
 }
-function unsupportedProviderFetch() {
-	throw new Error("ai: ai.provider().fetch() is not supported in this environment.");
-}
 async function providerRequestBody(provider, path, init, options, runtimeEnv) {
 	return {
 		provider,
@@ -370,6 +431,43 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 		}
 	};
 }
+function makeDirectBackend(directAi, runtimeEnv, gatewayId) {
+	return {
+		run: directAi.run.bind(directAi),
+		async image(model, inputs, options) {
+			const { runOptions } = splitImageOptions(options);
+			return responseFromResult(await directAi.run(model, inputs, runOptions));
+		},
+		async providerFetch(provider, path, init, options) {
+			if (!gatewayId) return Response.json({ error: "ai: ai.provider().fetch() needs an AI Gateway when self-hosting. Set \"ai\": { \"gateway\": \"<id>\" } in void.json." }, { status: 501 });
+			if (isUnsafeProviderPath(path)) return Response.json({ error: `ai: provider path '${path}' must be relative.` }, { status: 400 });
+			let providerKey;
+			try {
+				providerKey = resolveProviderKey(provider, runtimeEnv, options);
+			} catch (e) {
+				return Response.json({ error: e.message }, { status: 400 });
+			}
+			let baseUrl;
+			try {
+				baseUrl = await directAi.gateway(gatewayId).getUrl(provider);
+			} catch (e) {
+				return Response.json({ error: `ai: gateway '${gatewayId}': ${e.message}` }, { status: 502 });
+			}
+			const { body, contentType } = toDirectBody(init?.body);
+			const headers = new Headers(init?.headers);
+			const defaults = providerAuthDefaults(provider);
+			headers.set(options?.apiKeyHeader ?? defaults.header, `${options?.apiKeyPrefix ?? defaults.prefix}${providerKey}`);
+			if (contentType && !headers.has("content-type")) headers.set("content-type", contentType);
+			return fetch(gatewayEndpointUrl(baseUrl, path), {
+				method: init?.method ?? "POST",
+				headers,
+				body
+			});
+		},
+		models: directAi.models.bind(directAi),
+		toMarkdown: directAi.toMarkdown?.bind(directAi) ?? unsupported("toMarkdown")
+	};
+}
 let _backend;
 function backend() {
 	return _backend ??= resolveBackend();

package/dist/runtime/env-public.mjs

@@ -1,5 +1,5 @@
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
-import { getRuntimeEnv } from "./env.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
+import { getRuntimeEnv, isInternalBinding } from "./env.mjs";
 import { boolean, email, getSecretOverride, json, number, oneOf, string, url } from "./env-helpers.mjs";
 //#region src/shared/env-mask.ts
 /**
@@ -177,7 +177,10 @@ async function _validateEnvOnce(envValues) {
 				validatedCache.set(cacheKey, cache);
 				cacheList.push(cache);
 			}
-			for (const [key, value] of report.values) if (!cache.has(key)) cache.set(key, value);
+			for (const [key, value] of report.values) {
+				if (isInternalBinding(key, cacheKey)) continue;
+				if (!cache.has(key)) cache.set(key, value);
+			}
 		} catch {}
 		bootValidationState = { ok: true };
 		return;
@@ -254,11 +257,13 @@ var EnvValidationError = class extends Error {
 	}
 };
 function readKey(key) {
+	const rawEnv = getRawRuntimeEnv();
+	if (isInternalBinding(key, rawEnv)) return;
 	const rawValue = getRuntimeEnv()[key];
 	if (!registeredSchema) return rawValue;
 	const validator = registeredSchema[key];
 	if (!validator) return rawValue;
-	const cacheKey = getRawRuntimeEnv();
+	const cacheKey = rawEnv;
 	let cache = validatedCache.get(cacheKey);
 	if (!cache) {
 		cache = /* @__PURE__ */ new Map();

package/dist/runtime/env.d.mts

@@ -5,9 +5,22 @@ type RuntimeEnv = Record<string, unknown>;
 //#endregion
 //#region src/runtime/env.d.ts
 declare function withRuntimeEnv<T>(env: unknown, fn: () => T): T;
+/**
+* Shared internal-binding predicate. A binding is framework-internal — and must
+* never be exposed to user code — when it carries an internal prefix
+* (`__VOID_`, `__PROJECT_`; always hidden) or is an exact-name internal (e.g.
+* `ISR_CACHE`; hidden ONLY while ISR is active for the isolate). `rawEnv` is the
+* unfiltered runtime env, consulted via {@link isIsrActive} to gate the
+* exact-name check so a non-ISR app's own `ISR_CACHE` binding stays visible —
+* matching the build-time `isr` gate on the generated `c.env` filter.
+*
+* Single source of truth for the runtime `env` filter here and the public
+* `void/env` proxy (`env-public.ts`).
+*/
+declare function isInternalBinding(name: string, rawEnv: RuntimeEnv): boolean;
 /** Returns the runtime env with internal platform bindings hidden. */
 declare function getRuntimeEnv(): RuntimeEnv;
 declare function getRuntimeBinding<T = unknown>(name: string): T | undefined;
 declare function requireRuntimeBinding<T = unknown>(name: string): T;
 //#endregion
-export { type RuntimeEnv, getRuntimeBinding, getRuntimeEnv, requireRuntimeBinding, withRuntimeEnv };
+export { type RuntimeEnv, getRuntimeBinding, getRuntimeEnv, isInternalBinding, requireRuntimeBinding, withRuntimeEnv };

package/dist/runtime/env.mjs

@@ -1,4 +1,4 @@
-import { i as getRawRuntimeEnv, n as asEnv, r as envContext, t as INTERNAL_BINDING_PREFIXES } from "../env-raw-CoS20LHP.mjs";
+import { a as getRawRuntimeEnv, i as envContext, n as INTERNAL_BINDING_PREFIXES, o as isIsrActive, r as asEnv, t as INTERNAL_BINDING_EXACT_NAMES } from "../env-raw-Cx8ElDdj.mjs";
 //#region src/runtime/env.ts
 /**
 * Public runtime env API — exposed via "void/_env".
@@ -12,24 +12,37 @@ function withRuntimeEnv(env, fn) {
 	if (!resolved) return fn();
 	return envContext.run(resolved, fn);
 }
-function isInternalBinding(name) {
-	return INTERNAL_BINDING_PREFIXES.some((p) => name.startsWith(p));
+/**
+* Shared internal-binding predicate. A binding is framework-internal — and must
+* never be exposed to user code — when it carries an internal prefix
+* (`__VOID_`, `__PROJECT_`; always hidden) or is an exact-name internal (e.g.
+* `ISR_CACHE`; hidden ONLY while ISR is active for the isolate). `rawEnv` is the
+* unfiltered runtime env, consulted via {@link isIsrActive} to gate the
+* exact-name check so a non-ISR app's own `ISR_CACHE` binding stays visible —
+* matching the build-time `isr` gate on the generated `c.env` filter.
+*
+* Single source of truth for the runtime `env` filter here and the public
+* `void/env` proxy (`env-public.ts`).
+*/
+function isInternalBinding(name, rawEnv) {
+	if (INTERNAL_BINDING_PREFIXES.some((p) => name.startsWith(p))) return true;
+	return isIsrActive(rawEnv) && INTERNAL_BINDING_EXACT_NAMES.includes(name);
 }
 function filterEnvProxy(env) {
 	return new Proxy(env, {
 		get(target, prop, receiver) {
-			if (typeof prop === "string" && isInternalBinding(prop)) return;
+			if (typeof prop === "string" && isInternalBinding(prop, target)) return;
 			return Reflect.get(target, prop, receiver);
 		},
 		has(target, prop) {
-			if (typeof prop === "string" && isInternalBinding(prop)) return false;
+			if (typeof prop === "string" && isInternalBinding(prop, target)) return false;
 			return Reflect.has(target, prop);
 		},
 		ownKeys(target) {
-			return Reflect.ownKeys(target).filter((key) => typeof key !== "string" || !isInternalBinding(key));
+			return Reflect.ownKeys(target).filter((key) => typeof key !== "string" || !isInternalBinding(key, target));
 		},
 		getOwnPropertyDescriptor(target, prop) {
-			if (typeof prop === "string" && isInternalBinding(prop)) return;
+			if (typeof prop === "string" && isInternalBinding(prop, target)) return;
 			return Reflect.getOwnPropertyDescriptor(target, prop);
 		}
 	});
@@ -39,8 +52,9 @@ function getRuntimeEnv() {
 	return filterEnvProxy(getRawRuntimeEnv());
 }
 function getRuntimeBinding(name) {
-	if (isInternalBinding(name)) return;
-	return getRawRuntimeEnv()[name];
+	const raw = getRawRuntimeEnv();
+	if (isInternalBinding(name, raw)) return;
+	return raw[name];
 }
 function requireRuntimeBinding(name) {
 	const value = getRuntimeBinding(name);
@@ -48,4 +62,4 @@ function requireRuntimeBinding(name) {
 	throw new Error(`env: Missing Cloudflare binding '${name}'.`);
 }
 //#endregion
-export { getRuntimeBinding, getRuntimeEnv, requireRuntimeBinding, withRuntimeEnv };
+export { getRuntimeBinding, getRuntimeEnv, isInternalBinding, requireRuntimeBinding, withRuntimeEnv };

package/dist/runtime/isr-cache.d.mts

@@ -0,0 +1,207 @@
+//#region src/runtime/isr-cache.d.ts
+/**
+* Single-tenant ISR (incremental static regeneration) cache ladder for the
+* self-hosted Void worker (`vite build && wrangler deploy`).
+*
+* On managed Void, ISR lives in the dispatch worker that sits IN FRONT of the
+* user worker. Self-host has no dispatch worker, so this module ports that
+* caching ladder INTO the user worker, collapsed from multi-tenant to a single
+* deployment:
+*
+*   - No `projectId`, no cross-tenant metering.
+*   - No `#rw=` rewrite variant, no query-string variant fanout, no variant cap.
+*   - The deployment id is baked at build time as a compile-time literal and
+*     surfaced on `env.__VOID_ISR_DEPLOYMENT_ID` (Task 7). The KV helpers read
+*     it from `env` (matching the `revalidate()` purge path in `runtime/isr.ts`),
+*     while `handleIsr` uses the `deploymentId` option for the edge-cache keys —
+*     the two are the same value.
+*
+* Fail-open contract: every `env.ISR_CACHE` (KV) and `caches.default` operation
+* is wrapped so a misconfigured or erroring cache degrades to a live render,
+* never a 500. Read/hit-path failures bail (caller renders live); write-path
+* failures are swallowed.
+*
+* Worker-only: no `lib.dom` types — globals come from `@cloudflare/workers-types`.
+*
+* Ported from `void-platform/packages/dispatch` (`isr.ts`, `index.ts`,
+* `pattern.ts`) and `void-platform/packages/isr-shared`.
+*/
+/**
+* Minimal env surface this module needs. Both fields are optional so a worker
+* with no ISR binding (or a caller that only knows the deployment id) still
+* typechecks and fails open at runtime.
+*/
+interface IsrCacheEnv {
+  ISR_CACHE?: KVNamespace;
+  __VOID_ISR_DEPLOYMENT_ID?: string;
+}
+type IsrCacheEntry = Readonly<{
+  body: ReadableStream;
+  status: number;
+  headers: Record<string, string>;
+  createdAt: number;
+  ttl: number;
+}>;
+type IsrCacheMetadata = Readonly<{
+  /** HTTP status code */s: number; /** createdAt (ms) */
+  c: number; /** TTL (seconds) */
+  t: number;
+}>;
+/** Renders a live response for a request (worker dispatch + asset serving). */
+type RenderFn = (request: Request) => Promise<Response>;
+type HandleIsrOptions = Readonly<{
+  revalidate: number | Record<string, number> | undefined;
+  deploymentId: string;
+}>;
+/**
+* Build the normalized path segment for an ISR-cached page.
+* Root path `/` maps to `__index__` to avoid trailing-slash ambiguity.
+*/
+declare function normalizeIsrPath(pathname: string): string;
+/**
+* Inverse of `normalizeIsrPath`: turn a normalized segment back into a
+* pathname starting with `/`.
+*/
+declare function denormalizeIsrPath(normalized: string): string;
+/**
+* Canonicalize an inbound pathname to the form used inside edge cache URLs.
+* Equivalent to `denormalizeIsrPath(normalizeIsrPath(pathname))` — strips any
+* trailing slash except for root.
+*/
+declare function canonicalIsrPathname(pathname: string): string;
+/**
+* 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.).
+*/
+declare function isrKey(deploymentId: string, host: string, pathname: string): string;
+/**
+* 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.
+*/
+declare function hostRegistryKey(deploymentId: string, host: string): string;
+/**
+* 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.
+*/
+declare function htmlEdgeKey(host: string, pathname: string, id: string): string;
+/**
+* Edge-cache key for the JSON (pages-protocol) variant. Separated from HTML by
+* the `&__void=json` marker.
+*/
+declare function jsonEdgeKey(host: string, pathname: string, id: string): string;
+/**
+* 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.
+*/
+declare function matchLiteralPattern(pattern: string, pathname: string): boolean;
+/**
+* Pack response headers + body into a single ArrayBuffer.
+* Format: [4 bytes uint32 LE header length][UTF-8 header JSON][raw body]
+*/
+declare function packIsrValue(headers: Record<string, string>, body: ArrayBuffer): ArrayBuffer;
+/**
+* Unpack headers + body from a packed ArrayBuffer.
+* Returns null if the buffer is too small or malformed.
+*/
+declare function unpackIsrValue(buffer: ArrayBuffer): {
+  headers: Record<string, string>;
+  body: ArrayBuffer;
+} | 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.
+*/
+declare function readIsrCache(env: IsrCacheEnv, host: string, pathname: string): Promise<IsrCacheEntry | null>;
+/**
+* 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).
+*/
+declare function writeIsrCache(env: IsrCacheEnv, host: string, pathname: string, response: Response, ttl: number): Promise<void>;
+/**
+* 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.
+*/
+declare function listIsrHosts(kv: KVNamespace, deploymentId: string): Promise<Array<string>>;
+/**
+* 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).
+*/
+declare function deleteIsrCache(env: IsrCacheEnv, host: string, pathname: string): Promise<void>;
+/** Check if a cached entry is stale. */
+declare function isStale(entry: IsrCacheEntry): boolean;
+/** Build a Response from an ISR cache entry. */
+declare function isrCacheResponse(entry: IsrCacheEntry, stale: boolean): Response;
+/**
+* Read the `x-revalidate` header from a worker response.
+* Returns the override TTL, or the default. A value of 0 means "do not cache".
+*/
+declare function resolveRevalidateTtl(response: Response, defaultTtl: number): number;
+/**
+* ISR should be bypassed for requests with credentials and EventSource
+* requests. Pages protocol navigation (X-VoidPages) uses a separate JSON edge
+* cache.
+*/
+declare function shouldBypassIsr(request: Request): boolean;
+/**
+* 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.
+*/
+declare function resolvePathTtl(revalidate: number | Record<string, number> | undefined, pathname: string): number;
+declare function serializeHeaders(response: Response): Record<string, string>;
+declare function normalizePageDataForJsonCache(raw: string): string | null;
+declare function extractPageDataFromHtml(html: string): string | null;
+declare function clientRevalidateResponse(response: Response): Response;
+declare function isEventStreamResponse(response: Response): boolean;
+/**
+* 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`.
+*/
+declare function populateJsonEdgeCache(cache: Cache | undefined, cacheKey: string, response: Response, ttl: number, state: "HIT" | "MISS"): Promise<void>;
+/**
+* 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.
+*/
+declare function cloneWithoutVoidPages(request: Request): Request;
+/**
+* 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.
+*/
+declare function handleIsr(request: Request, env: IsrCacheEnv, ctx: ExecutionContext, options: HandleIsrOptions, render: RenderFn): Promise<Response | null>;
+//#endregion
+export { HandleIsrOptions, IsrCacheEntry, IsrCacheEnv, IsrCacheMetadata, RenderFn, 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 };