void 0.10.8 → 0.10.11

package/dist/requests-B8sZxaFM.mjs

@@ -0,0 +1,50 @@
+import { D as outro, T as log, a as cliTitle, s as dim, u as import_picocolors, w as intro } from "./agents-CtgBYqld.mjs";
+import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
+//#region src/cli/requests.ts
+async function runRequestsCommand(root, range, status) {
+	console.log();
+	intro(cliTitle("project requests"));
+	const token = getToken(root);
+	if (!token) {
+		log.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	if (!/^\d+(m|h|d)$/.test(range)) {
+		log.error(`requests: Invalid range '${range}'. Use a format like 15m, 2h, or 3d.`);
+		process.exit(1);
+	}
+	const linked = readProjectConfig(root);
+	if (!linked) {
+		log.error("No linked project. Run `void project link` first.");
+		process.exit(1);
+	}
+	const client = new PlatformClient(token, { root });
+	let entries;
+	try {
+		entries = await client.getRequests(linked.projectId, range, 200, status || void 0);
+	} catch (err) {
+		log.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	if (entries.length === 0) {
+		outro(`No requests found in the last ${range}${status ? ` matching status ${status}` : ""}.`);
+		return;
+	}
+	for (const entry of entries) printRequest(entry);
+	outro(dim(`${entries.length} requests`));
+}
+function printRequest(entry) {
+	const time = formatTime(entry.timestamp);
+	const method = (entry.method || "-").padEnd(4);
+	const status = entry.status || "-";
+	const statusNum = parseInt(status, 10);
+	const coloredStatus = statusNum >= 500 ? import_picocolors.default.red(status) : statusNum >= 400 ? import_picocolors.default.yellow(status) : status;
+	const duration = Number.isFinite(entry.durationMs) ? dim(`${Math.round(entry.durationMs)}ms`) : "";
+	console.log(`${dim(time)} ${method} ${coloredStatus} ${dim(entry.type)} ${duration}`.trimEnd());
+}
+function formatTime(ts) {
+	const d = /* @__PURE__ */ new Date(`${ts.replace(" ", "T")}Z`);
+	return Number.isNaN(d.getTime()) ? ts : d.toLocaleTimeString("en-GB", { hour12: false });
+}
+//#endregion
+export { runRequestsCommand };

package/dist/{resolve-project-D2HI3TrG.mjs → resolve-project-BBMtLLV9.mjs}

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime-DJK8HYOj.mjs";
-import { a as join } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
+import { a as join } from "./dist-DaKKDf8D.mjs";
 import { readFileSync } from "node:fs";
 //#region src/cli/resolve-project.ts
 var resolve_project_exports = /* @__PURE__ */ __exportAll({

package/dist/{rollback-Yh7bCKob.mjs → rollback-CkvTFXx5.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 { 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-CtgBYqld.mjs";
+import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
 //#region src/cli/rollback.ts
 async function runRollbackCommand(root, deployId) {
 	console.log();

package/dist/{route-types-CfKfhbIg.mjs → route-types-COI2DsZv.mjs}

@@ -1,5 +1,5 @@
-import { a as join, s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { r as writeFileIfChanged } from "./project-tsconfig-D9uSVVpA.mjs";
+import { a as join, s as relative } from "./dist-DaKKDf8D.mjs";
+import { r as writeFileIfChanged } from "./project-tsconfig-B-QtXjLQ.mjs";
 import { a as isVoidSocialAuthProvider } from "./providers-CJlNS3kT.mjs";
 import { mkdirSync } from "node:fs";
 import { getAuthTables, getSchema } from "better-auth/db";

package/dist/{runner-h272wcPj.mjs → runner-kapo9aPs.mjs}

@@ -1,6 +1,6 @@
-import { a as join, n as dirname } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { c as collectMigrations, o as classifyMigration } from "./validate-DT7nFMlf.mjs";
-import { n as hasPackageDependency, r as readNearestPackageJson } from "./package-json-B0NuUWGd.mjs";
+import { a as join, n as dirname } from "./dist-DaKKDf8D.mjs";
+import { c as collectMigrations, o as classifyMigration } from "./validate-Cw_RLeTj.mjs";
+import { n as hasPackageDependency, r as readNearestPackageJson } from "./package-json-Cx1osYo6.mjs";
 import { existsSync, mkdirSync } from "node:fs";
 import { createHash, createHmac } from "node:crypto";
 //#region src/migrations/runner.ts

package/dist/{runner-pg-waxJOnBb.mjs → runner-pg-CHM76xuC.mjs}

@@ -1,4 +1,4 @@
-import { c as collectMigrations } from "./validate-DT7nFMlf.mjs";
+import { c as collectMigrations } from "./validate-Cw_RLeTj.mjs";
 //#region src/migrations/runner-pg.ts
 /**
 * Apply unapplied SQL migrations via a connected PostgreSQL client.

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/better-auth-pg.d.mts

@@ -1,4 +1,4 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-BvnM9px6.mjs";
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DealXecJ.mjs";
 
 //#region src/runtime/better-auth-pg.d.ts
 declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];

package/dist/runtime/better-auth.d.mts

@@ -1,4 +1,4 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-BvnM9px6.mjs";
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DealXecJ.mjs";
 
 //#region src/runtime/better-auth.d.ts
 declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];

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

@@ -1,142 +1,4 @@
 /// <reference types="@cloudflare/workers-types" />
-import { t as StandardSchemaV1 } from "../standard-schema-DJ0HW7QP.mjs";
 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";
-
-//#region src/runtime/env-public.d.ts
-type AnyValidator = StandardSchemaV1<unknown, unknown>;
-type AnySchema = Record<string, AnyValidator>;
-/**
-* Type-only stub for the validated env shape. Augmented by the generated
-* `.void/env.d.ts` so `env.X` is typed per the user's schema. Includes an
-* index signature so untyped property access returns `unknown` (rather than
-* a hard error) for bindings and keys not declared in the schema.
-*/
-interface ValidatedEnv {
-  readonly [key: string]: unknown;
-}
-type InferEnv<S extends AnySchema> = { readonly [K in keyof S]: StandardSchemaV1.InferOutput<S[K]> };
-/**
-* Register an env schema and return the typed `env` proxy.
-*
-* Calling `defineEnv` is the only required step — Void auto-discovers
-* `env.ts` at project root, imports it, and uses the schema for runtime
-* validation, type generation, and deploy-time secret checks.
-*
-* The return value is identical to the `env` export from `void/env`.
-* Re-export it from your `env.ts` if you prefer the explicit
-* `import { env } from "~/env"` pattern.
-*/
-declare function defineEnv<S extends AnySchema>(schema: S): InferEnv<S>;
-/**
-* Internal: validate the entire schema against the worker's actual env on
-* the first request per isolate. Catches bad remote-secret values and
-* post-deploy drift that the deploy CLI can't see (it only knows secret
-* names, not their values).
-*
-* Spliced into the generated worker entry by `compileWorkerEntry`. Cached
-* after the first call so subsequent requests pay no cost.
-*
-* Async lifecycle: this function awaits any async Standard Schema
-* validators (zod `refine`, arktype async narrows, etc.) and seeds the
-* per-key cache with the resolved values. Subsequent reads via `env.X`
-* hit the sync cache — async work only happens here, at boot. If a user
-* accesses `env.X` for a key with an async validator *before* this
-* function has run (e.g. during module-top-level code), the proxy will
-* throw with guidance pointing back to this boot-time pre-validation.
-*/
-declare function _validateEnvOnce(envValues: unknown): Promise<void>;
-/** Internal: framework-only access to the registered schema (for plugin/CLI). */
-declare function _getRegisteredSchema(): AnySchema | null;
-/**
-* Internal: returns `true` once `defineEnv()` has been called at least once,
-* regardless of whether the caller passed an empty schema. Gives tooling a
-* reliable signal — `_getRegisteredSchema()` alone can't distinguish
-* `defineEnv({})` (an intentional empty schema) from "never called".
-*/
-declare function _hasRegisteredSchema(): boolean;
-/**
-* 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.
-*
-* Detection is schema-agnostic: probe each validator with `undefined` and,
-* if it succeeds with a non-undefined value, that value is the default.
-* Works for our built-in `.default(...)` helpers and for any Standard
-* 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.
-*/
-declare function _getSchemaDefaults(): Record<string, string>;
-declare class EnvValidationError extends Error {
-  readonly key: string;
-  readonly issues: Array<StandardSchemaV1.Issue>;
-  constructor(key: string, issues: Array<StandardSchemaV1.Issue>);
-}
-/**
-* Typed env proxy. Reads from the runtime env, validating declared keys
-* on first access and passing through bindings / unknown keys unchanged.
-*
-* Sync-only: the `get` trap must be synchronous, so validators that return
-* a `Promise` cannot be awaited here. For async Standard Schema validators,
-* `_validateEnvOnce()` pre-resolves them at worker boot and seeds the
-* per-env cache; property reads then serve the cached value synchronously.
-* If an async validator is encountered here without a prior pre-validation,
-* the trap throws with guidance on how to resolve it.
-*/
-declare const env: ValidatedEnv;
-/** Aggregate report from validating an entire env object against the schema. */
-type EnvValidationReport = {
-  valid: boolean;
-  missing: Array<string>;
-  invalid: Array<{
-    key: string;
-    messages: Array<string>;
-  }>;
-  /**
-  * Resolved values for keys that validated successfully. Used to seed the
-  * per-env cache after async pre-validation so sync `env.X` reads hit the
-  * cache.
-  */
-  values: Map<string, unknown>;
-};
-/**
-* Validate an env record (e.g. merged `.env*` + remote secret list) against
-* the registered schema. Used by the dev plugin (warnings), the deploy CLI
-* (hard error), and `_validateEnvOnce` at worker boot.
-*
-* Async: awaits any validators that return a `Promise` (zod async refines,
-* arktype narrows, etc.). Callers already run in async contexts.
-*/
-declare function validateAllEnv(envValues: Record<string, unknown>): Promise<EnvValidationReport>;
-declare global {
-  namespace Cloudflare {
-    interface Env {
-      DB: D1Database;
-      KV: KVNamespace;
-      STORAGE: R2Bucket;
-      AI: Ai;
-      SANDBOX: DurableObjectNamespace<import("@cloudflare/sandbox").Sandbox>;
-      /** @internal Service binding to proxy worker (AI, revalidation, future features) */
-      __VOID_PROXY?: Fetcher;
-      /** @internal Custom proxy URL override */
-      __VOID_PROXY_URL?: string;
-      /** @internal Auth token for HTTP proxy (local dev) */
-      __VOID_TOKEN?: string;
-      /** @internal Project ID for HTTP proxy (local dev) */
-      __VOID_PROJECT_ID?: string;
-      /** @internal Staging environment flag */
-      __VOID_STAGING?: string;
-      /** @internal Project ID (service binding path) */
-      __PROJECT_ID?: string;
-      /** @internal Proxy token (service binding path) */
-      __VOID_PROXY_TOKEN?: string;
-      [key: `QUEUE_${string}`]: Queue<unknown> | undefined;
-    }
-  }
-}
-//#endregion
+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";
 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,95 +1,7 @@
-import { i as getRawRuntimeEnv } from "../env-raw-CoS20LHP.mjs";
-import { getRuntimeEnv } from "./env.mjs";
 import { boolean, email, getSecretOverride, 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).
-*
-* Redaction is belt-and-braces:
-*   1. An explicit `.secret()` / `.public()` flag on a schema entry wins.
-*   2. Otherwise, a key-name regex (`KEY|TOKEN|SECRET|…`) redacts anything
-*      that looks like credentials.
-*   3. Even on non-secret keys, a value that itself looks high-entropy
-*      (`sk_…`, `ghp_…`, ≥24 characters of mixed alphanumerics) is redacted
-*      — catches wrong-file typos like `PORT=sk_live_abc123`.
-*
-* 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";
-/**
-* Regex matching env key names that almost always carry secrets.
-* Case-insensitive; matched as a substring anywhere in the key.
-*/
-const SECRET_KEY_RE = /KEY|TOKEN|SECRET|PASSWORD|PASS(WD)?|CREDENTIAL|PRIVATE|AUTH|BEARER|APIKEY|DSN/i;
-/** Common secret value prefixes (Stripe, GitHub, Slack, AWS, …). */
-const SECRET_VALUE_PREFIX_RE = /^(sk|pk|ghp|xoxb|AKIA)/i;
-/** High-entropy alphanumeric string of ≥24 chars. */
-const HIGH_ENTROPY_RE = /^[A-Za-z0-9_\-+/=.:]{24,}$/;
-/** `true` when the key name heuristically denotes a secret. */
-function isLikelySecretKey(name) {
-	return SECRET_KEY_RE.test(name);
-}
-/**
-* `true` when the value looks like a credential regardless of key name.
-* Err on the side of redacting — a false positive hides one non-secret
-* debugging hint, a false negative pastes a token into a GitHub issue.
-*/
-function isLikelySecretValue(value) {
-	if (typeof value !== "string" || value.length === 0) return false;
-	return SECRET_VALUE_PREFIX_RE.test(value) || HIGH_ENTROPY_RE.test(value);
-}
-/**
-* Redact every occurrence of `raw` inside a validator-produced `message`
-* when the key should be masked. Built-in helpers embed the raw value in
-* their error strings (e.g. `Expected a number, got "not-a-number"`); we
-* scrub those after the fact so third-party Standard Schema libraries —
-* which have their own message format — also get reasonable redaction as
-* long as the offending value was a secret-looking literal.
-*/
-function redactMessage(key, rawValue, message, options = {}) {
-	if (options.unmask) return message;
-	if (!(options.override === "secret" || options.override !== "public" && (isLikelySecretKey(key) || isLikelySecretValue(rawValue)))) 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
+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";
 //#region src/runtime/env-public.ts
 /**
 * Public env API — `void/env`.
@@ -177,7 +89,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 +169,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/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-imD0UVDT.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-Cjh8uM3Y.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 };