void 0.10.13 → 0.20.1

package/dist/runtime/env-public.d.mts

@@ -1,4 +1,4 @@
 /// <reference types="@cloudflare/workers-types" />
-import { c as oneOf, i as email, l as string, o as json, r as boolean, s as number, t as EnvSchema, u as url } from "../env-helpers-z4stu8uc.mjs";
-import { a as _getSchemaDefaults, c as defineEnv, i as _getRegisteredSchema, l as env, n as EnvValidationReport, o as _hasRegisteredSchema, r as ValidatedEnv, s as _validateEnvOnce, t as EnvValidationError, u as validateAllEnv } from "../env-public-BfiLcMBk.mjs";
+import { a as number, c as url, i as json, n as boolean, o as oneOf, r as email, s as string, t as EnvSchema } from "../env-helpers-CyKtOBpj.mjs";
+import { a as _getSchemaDefaults, c as defineEnv, i as _getRegisteredSchema, l as env, n as EnvValidationReport, o as _hasRegisteredSchema, r as ValidatedEnv, s as _validateEnvOnce, t as EnvValidationError, u as validateAllEnv } from "../env-public-D_6u46fX.mjs";
 export { type EnvSchema, EnvValidationError, EnvValidationReport, ValidatedEnv, _getRegisteredSchema, _getSchemaDefaults, _hasRegisteredSchema, _validateEnvOnce, boolean, defineEnv, email, env, json, number, oneOf, string, url, validateAllEnv };

package/dist/runtime/env-public.mjs

@@ -1,7 +1,61 @@
-import { boolean, email, getSecretOverride, json, number, oneOf, string, url } from "./env-helpers.mjs";
-import { n as isUnmaskActive, r as redactMessage } from "../env-mask-Dd47NbR6.mjs";
 import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
 import { getRuntimeEnv, isInternalBinding } from "./env.mjs";
+import { boolean, email, json, number, oneOf, string, url } from "./env-helpers.mjs";
+//#region src/shared/env-mask.ts
+/**
+* Secret redaction helpers for env-validation output.
+*
+* Values are redacted (replaced with `<redacted>`) whenever they flow into
+* a user-visible string — `EnvValidationError` messages, CLI reports, the
+* dev-server warning block. The key name is never masked (the user needs
+* it to locate the offending entry).
+*
+* Server env values are production secrets by definition, so validator
+* messages redact the raw input unconditionally. The old `.secret()` /
+* `.public()` masking axis was removed because it did not control storage.
+*
+* Users can opt out of the guard for local debugging via
+* `VOID_ENV_UNMASK=1` in the environment; that path prints a one-shot
+* notice on stderr so the loosened output is visibly attributed.
+*
+* This module is a leaf — no imports from non-leaf modules, safe to reach
+* from both the runtime (worker bundle) and the CLI host.
+*/
+/** Sentinel emitted in place of a redacted value. */
+const REDACTED = "<redacted>";
+/** Environment variable that disables redaction when set to `1`. */
+const UNMASK_ENV_VAR = "VOID_ENV_UNMASK";
+/** Replace raw input in validator messages, regardless of its name or shape. */
+function redactMessage(rawValue, message, options = {}) {
+	if (options.unmask) return message;
+	if (typeof rawValue !== "string" || rawValue.length === 0) return message;
+	return message.split(rawValue).join(REDACTED);
+}
+let unmaskResolved = null;
+let unmaskNoticeShown = false;
+/**
+* Resolve the effective unmask flag, consulting `process.env` exactly once
+* per process. On the first affirmative read, we print a one-shot notice to
+* stderr so CI logs clearly show the guard is off.
+*/
+function isUnmaskActive() {
+	if (unmaskResolved !== null) return unmaskResolved;
+	let active = false;
+	try {
+		active = globalThis.process?.env?.[UNMASK_ENV_VAR] === "1";
+	} catch {
+		active = false;
+	}
+	unmaskResolved = active;
+	if (active && !unmaskNoticeShown) {
+		unmaskNoticeShown = true;
+		try {
+			console.error(`[void/env] ${UNMASK_ENV_VAR}=1 is set — env validation errors will include raw values. Unset it before sharing logs.`);
+		} catch {}
+	}
+	return active;
+}
+//#endregion
 //#region src/runtime/env-public.ts
 /**
 * Public env API — `void/env`.
@@ -31,9 +85,19 @@ import { getRuntimeEnv, isInternalBinding } from "./env.mjs";
 * Bindings (`DB`, `KV`, `STORAGE`, `AI`, queue handlers) and other env keys
 * not declared in the schema pass through unchanged.
 */
-let registeredSchema = null;
-let hasDefineEnvBeenCalled = false;
+const ENV_REGISTRY_SYMBOL = Symbol.for("void.env.registry");
+const registryGlobal = globalThis;
+const registry = registryGlobal[ENV_REGISTRY_SYMBOL] ??= {
+	schema: null,
+	hasDefineEnvBeenCalled: false,
+	bootValidation: null
+};
 const validatedCache = /* @__PURE__ */ new WeakMap();
+/** Vite embeds the same public build inputs into server and browser bundles. */
+function getClientEnvValues() {
+	const values = import.meta.env;
+	return Object.fromEntries(Object.entries(values ?? {}).filter(([key]) => key.startsWith("VITE_")));
+}
 /**
 * Register an env schema and return the typed `env` proxy.
 *
@@ -46,13 +110,12 @@ const validatedCache = /* @__PURE__ */ new WeakMap();
 * `import { env } from "~/env"` pattern.
 */
 function defineEnv(schema) {
-	registeredSchema = schema;
-	hasDefineEnvBeenCalled = true;
+	registry.schema = schema;
+	registry.hasDefineEnvBeenCalled = true;
 	for (const map of validatedCacheValues()) map.clear();
-	bootValidationState = null;
+	registry.bootValidation = null;
 	return env;
 }
-let bootValidationState = null;
 /**
 * Internal: validate the entire schema against the worker's actual env on
 * the first request per isolate. Catches bad remote-secret values and
@@ -71,15 +134,19 @@ let bootValidationState = null;
 * throw with guidance pointing back to this boot-time pre-validation.
 */
 async function _validateEnvOnce(envValues) {
-	if (bootValidationState) {
-		if (!bootValidationState.ok) throw bootValidationState.error;
+	if (registry.bootValidation) {
+		if (!registry.bootValidation.ok) throw registry.bootValidation.error;
 		return;
 	}
-	if (!registeredSchema) {
-		bootValidationState = { ok: true };
+	if (!registry.schema) {
+		registry.bootValidation = { ok: true };
 		return;
 	}
-	const report = await validateAllEnvWithValues(registeredSchema, envValues ?? {});
+	const values = {
+		...envValues ?? {},
+		...getClientEnvValues()
+	};
+	const report = await validateAllEnvWithValues(registry.schema, values);
 	if (report.valid) {
 		try {
 			const cacheKey = getRawRuntimeEnv();
@@ -94,14 +161,14 @@ async function _validateEnvOnce(envValues) {
 				if (!cache.has(key)) cache.set(key, value);
 			}
 		} catch {}
-		bootValidationState = { ok: true };
+		registry.bootValidation = { ok: true };
 		return;
 	}
 	const lines = ["Env validation failed at worker boot:"];
 	for (const key of report.missing) lines.push(`  • ${key} is required but missing`);
 	for (const { key, messages } of report.invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
 	const error = new EnvValidationError("__init__", [{ message: lines.join("\n") }]);
-	bootValidationState = {
+	registry.bootValidation = {
 		ok: false,
 		error
 	};
@@ -113,7 +180,7 @@ function validatedCacheValues() {
 const cacheList = [];
 /** Internal: framework-only access to the registered schema (for plugin/CLI). */
 function _getRegisteredSchema() {
-	return registeredSchema;
+	return registry.schema;
 }
 /**
 * Internal: returns `true` once `defineEnv()` has been called at least once,
@@ -122,13 +189,11 @@ function _getRegisteredSchema() {
 * `defineEnv({})` (an intentional empty schema) from "never called".
 */
 function _hasRegisteredSchema() {
-	return hasDefineEnvBeenCalled;
+	return registry.hasDefineEnvBeenCalled;
 }
 /**
 * Internal: extract `.default(value)` values from the registered schema as
-* stringified env values. Used by the plugin and deploy CLI to seed worker
-* `vars` so `c.env.X` and `process.env.X` see the same fallback that the
-* typed `env.X` proxy returns.
+* stringified env values. Used for explicit build-time client fallbacks.
 *
 * Detection is schema-agnostic: probe each validator with `undefined` and,
 * if it succeeds with a non-undefined value, that value is the default.
@@ -136,14 +201,12 @@ function _hasRegisteredSchema() {
 * Schema validator with intrinsic default behaviour. Async validators are
 * skipped (we can't get a sync default).
 *
-* Keys with no default — required keys, plain `.optional()` — are omitted
-* from the result so they don't shadow user `.env*` entries with empty
-* strings.
+* Keys with no default — required keys and plain `.optional()` keys — are omitted.
 */
 function _getSchemaDefaults() {
 	const defaults = {};
-	if (!registeredSchema) return defaults;
-	for (const [key, validator] of Object.entries(registeredSchema)) {
+	if (!registry.schema) return defaults;
+	for (const [key, validator] of Object.entries(registry.schema)) {
 		let result;
 		try {
 			result = validator["~standard"].validate(void 0);
@@ -163,17 +226,19 @@ var EnvValidationError = class extends Error {
 	issues;
 	constructor(key, issues) {
 		super(`Invalid env "${key}": ${issues.map((i) => i.message).join(", ")}`);
+		this.name = "EnvValidationError";
 		this.key = key;
 		this.issues = issues;
-		this.name = "EnvValidationError";
 	}
 };
 function readKey(key) {
 	const rawEnv = getRawRuntimeEnv();
 	if (isInternalBinding(key, rawEnv)) return;
-	const rawValue = getRuntimeEnv()[key];
-	if (!registeredSchema) return rawValue;
-	const validator = registeredSchema[key];
+	const filtered = getRuntimeEnv();
+	const clientValues = getClientEnvValues();
+	const rawValue = Object.hasOwn(clientValues, key) ? clientValues[key] : filtered[key];
+	if (!registry.schema) return rawValue;
+	const validator = registry.schema[key];
 	if (!validator) return rawValue;
 	const cacheKey = rawEnv;
 	let cache = validatedCache.get(cacheKey);
@@ -187,13 +252,9 @@ function readKey(key) {
 	if (result instanceof Promise) throw new Error(`env: Async validator for '${key}' cannot be resolved synchronously. Proxy property access is synchronous, so async Standard Schema validators must be pre-resolved by calling \`_validateEnvOnce(env)\` at worker boot (Void splices this into the generated entry) or by awaiting \`validateAllEnv(env)\` before the first \`env.${key}\` read. Once pre-validated, the resolved value is cached and served synchronously here.`);
 	if (result.issues) {
 		const unmask = isUnmaskActive();
-		const override = getSecretOverride(validator);
 		throw new EnvValidationError(key, result.issues.map((i) => ({
 			...i,
-			message: redactMessage(key, rawValue, i.message, {
-				override,
-				unmask
-			})
+			message: redactMessage(rawValue, i.message, { unmask })
 		})));
 	}
 	cache.set(key, result.value);
@@ -217,10 +278,10 @@ const env = new Proxy({}, {
 	},
 	has(_target, key) {
 		if (typeof key === "symbol") return false;
-		return Reflect.has(getRuntimeEnv(), key);
+		return Object.hasOwn(getClientEnvValues(), key) || Reflect.has(getRuntimeEnv(), key);
 	},
 	ownKeys() {
-		return Reflect.ownKeys(getRuntimeEnv());
+		return [.../* @__PURE__ */ new Set([...Reflect.ownKeys(getRuntimeEnv()), ...Object.keys(getClientEnvValues())])];
 	},
 	getOwnPropertyDescriptor(_target, key) {
 		if (typeof key === "symbol") return;
@@ -232,7 +293,7 @@ const env = new Proxy({}, {
 	}
 });
 /**
-* Validate an env record (e.g. merged `.env*` + remote secret list) against
+* Validate an env record (local dotenv, build inputs, or runtime bindings) against
 * the registered schema. Used by the dev plugin (warnings), the deploy CLI
 * (hard error), and `_validateEnvOnce` at worker boot.
 *
@@ -240,13 +301,13 @@ const env = new Proxy({}, {
 * arktype narrows, etc.). Callers already run in async contexts.
 */
 async function validateAllEnv(envValues) {
-	if (!registeredSchema) return {
+	if (!registry.schema) return {
 		valid: true,
 		missing: [],
 		invalid: [],
 		values: /* @__PURE__ */ new Map()
 	};
-	return await validateAllEnvWithValues(registeredSchema, envValues);
+	return await validateAllEnvWithValues(registry.schema, envValues);
 }
 /**
 * Internal: shared core that validates a schema against values and also
@@ -267,16 +328,10 @@ async function validateAllEnvWithValues(schema, envValues) {
 		if (result.issues) {
 			report.valid = false;
 			if (raw === void 0 || raw === null || raw === "") report.missing.push(key);
-			else {
-				const override = getSecretOverride(validator);
-				report.invalid.push({
-					key,
-					messages: result.issues.map((i) => redactMessage(key, raw, i.message, {
-						override,
-						unmask
-					}))
-				});
-			}
+			else report.invalid.push({
+				key,
+				messages: result.issues.map((i) => redactMessage(raw, i.message, { unmask }))
+			});
 		} else report.values.set(key, result.value);
 	}
 	return report;

package/dist/runtime/env.d.mts

@@ -1,26 +1,27 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-
 //#region src/runtime/env-raw.d.ts
 type RuntimeEnv = Record<string, unknown>;
 //#endregion
 //#region src/runtime/env.d.ts
-declare function withRuntimeEnv<T>(env: unknown, fn: () => T): T;
+/** @internal Reuse a resource only within the current runtime request. */
+export declare function getRuntimeRequestResource<T>(key: object, initialize: () => T): T;
+export 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;
+ * 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`).
+ */
+export 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;
+export declare function getRuntimeEnv(): RuntimeEnv;
+export declare function getRuntimeBinding<T = unknown>(name: string): T | undefined;
+export declare function requireRuntimeBinding<T = unknown>(name: string): T;
 //#endregion
-export { type RuntimeEnv, getRuntimeBinding, getRuntimeEnv, isInternalBinding, requireRuntimeBinding, withRuntimeEnv };
+export type { RuntimeEnv };

package/dist/runtime/env.mjs

@@ -1,4 +1,5 @@
 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";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/runtime/env.ts
 /**
 * Public runtime env API — exposed via "void/_env".
@@ -7,10 +8,22 @@ import { a as getRawRuntimeEnv, i as envContext, n as INTERNAL_BINDING_PREFIXES,
 * Internal platform bindings (__VOID_*, __PROJECT_*) are filtered
 * from getRuntimeEnv() and blocked in getRuntimeBinding().
 */
+const runtimeRequestContext = new AsyncLocalStorage();
+/** @internal Reuse a resource only within the current runtime request. */
+function getRuntimeRequestResource(key, initialize) {
+	const scope = runtimeRequestContext.getStore();
+	if (!scope) throw new Error("env: Request-scoped resource is unavailable outside a runtime handler.");
+	if (scope.resources.has(key)) return scope.resources.get(key);
+	const resource = initialize();
+	scope.resources.set(key, resource);
+	return resource;
+}
 function withRuntimeEnv(env, fn) {
 	const resolved = asEnv(env);
 	if (!resolved) return fn();
-	return envContext.run(resolved, fn);
+	if (runtimeRequestContext.getStore()) return envContext.run(resolved, fn);
+	const scope = { resources: /* @__PURE__ */ new Map() };
+	return envContext.run(resolved, () => runtimeRequestContext.run(scope, fn));
 }
 /**
 * Shared internal-binding predicate. A binding is framework-internal — and must
@@ -62,4 +75,4 @@ function requireRuntimeBinding(name) {
 	throw new Error(`env: Missing Cloudflare binding '${name}'.`);
 }
 //#endregion
-export { getRuntimeBinding, getRuntimeEnv, isInternalBinding, requireRuntimeBinding, withRuntimeEnv };
+export { getRuntimeBinding, getRuntimeEnv, getRuntimeRequestResource, isInternalBinding, requireRuntimeBinding, withRuntimeEnv };

package/dist/runtime/fetch-stream.d.mts

@@ -1,6 +1,5 @@
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { RouteMap } from "void/routes";
-
 //#region src/runtime/fetch-stream.d.ts
 type MethodsOf<P extends keyof RouteMap> = keyof RouteMap[P] & string;
 type InputOf<P extends keyof RouteMap, M extends MethodsOf<P>> = RouteMap[P][M] extends {
@@ -28,24 +27,24 @@ type StreamOptions<P extends keyof RouteMap, M extends MethodsOf<P>> = BodyOptio
   baseURL?: string;
 };
 /**
-* Consume an SSE endpoint as an async generator of text chunks.
-*
-* Parses Workers AI SSE format (`data: {"response":"chunk"}` + `data: [DONE]`)
-* and plain text SSE (`data: some text`).
-*
-* ```ts
-* import { fetchStream } from "void/client";
-*
-* for await (const chunk of fetchStream("/api/ai/chat", {
-*   method: "POST",
-*   body: { messages: [{ role: "user", content: "Hello" }] },
-* })) {
-*   output += chunk;
-* }
-* ```
-*
-* @yields {string} Text chunks from SSE data frames.
-*/
-declare function fetchStream<P extends keyof RouteMap & string, M extends MethodsOf<P> = ("POST" extends MethodsOf<P> ? "POST" : MethodsOf<P>)>(path: P, options?: StreamOptions<P, M>): AsyncGenerator<string, void, undefined>;
+ * Consume an SSE endpoint as an async generator of text chunks.
+ *
+ * Parses Workers AI SSE format (`data: {"response":"chunk"}` + `data: [DONE]`)
+ * and plain text SSE (`data: some text`).
+ *
+ * ```ts
+ * import { fetchStream } from "void/client";
+ *
+ * for await (const chunk of fetchStream("/api/ai/chat", {
+ *   method: "POST",
+ *   body: { messages: [{ role: "user", content: "Hello" }] },
+ * })) {
+ *   output += chunk;
+ * }
+ * ```
+ *
+ * @yields {string} Text chunks from SSE data frames.
+ */
+export declare function fetchStream<P extends keyof RouteMap & string, M extends MethodsOf<P> = "POST" extends MethodsOf<P> ? "POST" : MethodsOf<P>>(path: P, options?: StreamOptions<P, M>): AsyncGenerator<string, void, undefined>;
 //#endregion
-export { FetchError as StreamError, fetchStream };
+export { FetchError as StreamError };

package/dist/runtime/fetch.d.mts

@@ -1,6 +1,5 @@
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { RouteMap } from "void/routes";
-
 //#region src/runtime/fetch.d.ts
 type MethodsOf<P extends keyof RouteMap> = keyof RouteMap[P] & string;
 type DefaultMethod<P extends keyof RouteMap> = "GET" extends MethodsOf<P> ? "GET" : never;
@@ -41,19 +40,19 @@ type FetchOptions<P extends keyof RouteMap, M extends MethodsOf<P>> = BodyOption
   timeout?: number;
 };
 /**
-* Typed fetch client for Void API routes.
-*
-* Built on top of ofetch. Supports baseURL, retry, timeout, and all
-* ofetch features while providing full route type safety.
-*
-* ```ts
-* import { fetch } from "void/client";
-*
-* const users = await fetch("/api/users"); // typed!
-* const user = await fetch("/api/users/:id", { params: { id: "1" } });
-* ```
-*/
-declare function fetch<P extends keyof RouteMap & string>(path: HasRequiredInput<P, DefaultMethod<P>> extends false ? P : never): Promise<OutputOf<P, DefaultMethod<P>>>;
-declare function fetch<P extends keyof RouteMap & string, M extends MethodsOf<P> = DefaultMethod<P>>(path: P, options: FetchOptions<P, M>): Promise<OutputOf<P, M>>;
+ * Typed fetch client for Void API routes.
+ *
+ * Built on top of ofetch. Supports baseURL, retry, timeout, and all
+ * ofetch features while providing full route type safety.
+ *
+ * ```ts
+ * import { fetch } from "void/client";
+ *
+ * const users = await fetch("/api/users"); // typed!
+ * const user = await fetch("/api/users/:id", { params: { id: "1" } });
+ * ```
+ */
+export declare function fetch<P extends keyof RouteMap & string>(path: HasRequiredInput<P, DefaultMethod<P>> extends false ? P : never): Promise<OutputOf<P, DefaultMethod<P>>>;
+export declare function fetch<P extends keyof RouteMap & string, M extends MethodsOf<P> = DefaultMethod<P>>(path: P, options: FetchOptions<P, M>): Promise<OutputOf<P, M>>;
 //#endregion
-export { FetchError, fetch };
+export { FetchError };

package/dist/runtime/handler.d.mts

@@ -1,3 +1,3 @@
 /// <reference types="@cloudflare/workers-types" />
-import { C as defer, E as ValidatorSlots, S as InferProps, T as HandlerInput, _ as defineQueue, a as CloudEnv, b as Deferred, c as QueueRetryOptions, d as TypedQueueHandler, f as VoidAssetRewriteError, g as defineMiddleware, h as defineHead, i as CloudContextVariables, l as RenderAssetTags, m as defineHandler, n as CloudBindings, o as QueueBatch, p as basicAuth, r as CloudContext, s as QueueMessage, t as BasicAuthOptions, u as TypedHandler, v as defineRender, w as ValidationError, y as defineScheduled } from "../handler-Cjh8uM3Y.mjs";
+import { C as defer, E as ValidatorSlots, S as InferProps, T as HandlerInput, _ as defineQueue, a as CloudEnv, b as Deferred, c as QueueRetryOptions, d as TypedQueueHandler, f as VoidAssetRewriteError, g as defineMiddleware, h as defineHead, i as CloudContextVariables, l as RenderAssetTags, m as defineHandler, n as CloudBindings, o as QueueBatch, p as basicAuth, r as CloudContext, s as QueueMessage, t as BasicAuthOptions, u as TypedHandler, v as defineRender, w as ValidationError, y as defineScheduled } from "../handler-D1hLsObx.mjs";
 export { BasicAuthOptions, CloudBindings, CloudContext, CloudContextVariables, CloudEnv, type Deferred, type HandlerInput, type InferProps, QueueBatch, QueueMessage, QueueRetryOptions, RenderAssetTags, TypedHandler, TypedQueueHandler, ValidationError, type ValidatorSlots, VoidAssetRewriteError, basicAuth, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled };

package/dist/runtime/isr.d.mts

@@ -1,27 +1,26 @@
 //#region src/runtime/isr.d.ts
-type RevalidateOptions = {
+export type RevalidateOptions = {
   paths?: Array<string>;
   all?: boolean;
 };
 /**
-* Revalidate ISR-cached pages on demand.
-*
-* 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
-* import { revalidate } from "void/isr";
-*
-* // Revalidate specific paths
-* await revalidate({ paths: ["/", "/blog/hello"] });
-*
-* // Revalidate all ISR pages
-* await revalidate({ all: true });
-* ```
-*/
-declare function revalidate(options: RevalidateOptions): Promise<void>;
-//#endregion
-export { RevalidateOptions, revalidate };
+ * Revalidate ISR-cached pages on demand.
+ *
+ * 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
+ * import { revalidate } from "void/isr";
+ *
+ * // Revalidate specific paths
+ * await revalidate({ paths: ["/", "/blog/hello"] });
+ *
+ * // Revalidate all ISR pages
+ * await revalidate({ all: true });
+ * ```
+ */
+export declare function revalidate(options: RevalidateOptions): Promise<void>;
+//#endregion

package/dist/runtime/isr.mjs

@@ -1,5 +1,6 @@
 import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
-import { denormalizeIsrPath, htmlEdgeKey, isrKey, jsonEdgeKey, listIsrHosts } from "./isr-cache.mjs";
+import { isrEdgeCacheUrlForToken, splitIsrCacheKey } from "@void/isr";
+import { denormalizeIsrPath, isrKey, isrPrefix, isrVariantPrefix, listIsrHosts } from "@void/isr/runtime";
 //#region src/runtime/isr.ts
 /**
 * Revalidate ISR-cached pages on demand.
@@ -28,16 +29,31 @@ async function revalidate(options) {
 		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));
+		const purgeKey = async (host, path, key, variantToken) => {
+			await kv.delete(key);
 			try {
 				const cache = caches.default;
-				await cache.delete(htmlEdgeKey(host, path, id));
-				await cache.delete(jsonEdgeKey(host, path, id));
+				await cache.delete(isrEdgeCacheUrlForToken(host, path, id, "html", variantToken));
+				await cache.delete(isrEdgeCacheUrlForToken(host, path, id, "json", variantToken));
 			} catch {}
 		};
+		const purgePath = async (host, path) => {
+			await purgeKey(host, path, isrKey(id, host, path), null);
+			let cursor;
+			do {
+				const list = await kv.list({
+					prefix: isrVariantPrefix(id, host, path),
+					cursor
+				});
+				for (const key of list.keys) {
+					const { variantToken } = splitIsrCacheKey(key.name);
+					await purgeKey(host, path, key.name, variantToken);
+				}
+				cursor = list.list_complete ? void 0 : list.cursor;
+			} while (cursor);
+		};
 		if (options.all) {
-			const prefix = `void-isr/${id}/`;
+			const prefix = isrPrefix(id);
 			let cursor;
 			do {
 				const list = await kv.list({
@@ -48,7 +64,9 @@ async function revalidate(options) {
 					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)));
+					const host = tail.slice(0, slash);
+					const { normalizedPath, variantToken } = splitIsrCacheKey(tail.slice(slash + 1));
+					await purgeKey(host, denormalizeIsrPath(normalizedPath), key.name, variantToken);
 				}
 				cursor = list.list_complete ? void 0 : list.cursor;
 			} while (cursor);
@@ -57,7 +75,7 @@ async function revalidate(options) {
 			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);
+			for (const host of hosts) for (const path of paths) await purgePath(host, path);
 		}
 		return;
 	}

package/dist/runtime/kv.d.mts

@@ -1,25 +1,25 @@
 //#region src/runtime/kv.d.ts
-type PutOptions = {
+export type PutOptions = {
   ttl?: number;
   expiration?: number;
   metadata?: Record<string, unknown>;
 };
-type ListOptions = {
+export type ListOptions = {
   prefix?: string;
   limit?: number;
   cursor?: string;
 };
-type ListKey<M = unknown> = {
+export type ListKey<M = unknown> = {
   name: string;
   expiration?: number;
   metadata?: M;
 };
-type ListResult<M = unknown> = {
+export type ListResult<M = unknown> = {
   keys: Array<ListKey<M>>;
   list_complete: boolean;
   cursor?: string;
 };
-type KVMap<T> = {
+export type KVMap<T> = {
   get(key: string): Promise<T | null>;
   put(key: string, value: T, options?: PutOptions): Promise<void>;
   delete(key: string): Promise<void>;
@@ -29,7 +29,7 @@ type KVMap<T> = {
     metadata: M | null;
   }>;
 };
-type KVClient = {
+export type KVClient = {
   get<T = string>(key: string): Promise<T | null>;
   put(key: string, value: unknown, options?: PutOptions): Promise<void>;
   delete(key: string): Promise<void>;
@@ -41,8 +41,7 @@ type KVClient = {
   map<T = unknown>(prefix: string): KVMap<T>;
 };
 /** Create a KV client for a specific KVNamespace instance. */
-declare function createKV(namespace: KVNamespace): KVClient;
+export declare function createKV(namespace: KVNamespace): KVClient;
 /** Default KV client — resolves `KV` from the active runtime environment. */
-declare const kv: KVClient;
-//#endregion
-export { KVClient, KVMap, ListKey, ListOptions, ListResult, PutOptions, createKV, kv };
+export declare const kv: KVClient;
+//#endregion