void 0.20.1 → 0.20.3

package/dist/runtime/remote/index.mjs

@@ -1,6 +1,53 @@
-import { t as cfAccessHeaders } from "../../cf-access-AJ1ehiFR.mjs";
+import { t as cfAccessHeaders } from "../../cf-access-DRsQRe6k.mjs";
 import { n as serializeR2Conditional } from "../../r2-conditions-D1Wk8i7b.mjs";
 //#region src/runtime/remote/client.ts
+function readableMessage(value) {
+	if (typeof value !== "string") return;
+	const text = value.replace(/(?:\u001b\]|\u009d)[\s\S]*?(?:\u0007|\u001b\\|\u009c|$)/g, "").replace(/(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").trim();
+	if (!text || /^[{[]/.test(text) || /<\/?[a-z!][^>]*>/i.test(text)) return;
+	return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+}
+function isGenericPermissionMessage(message) {
+	return /^(?:(?:HTTP\s*)?(?:401|403)\s*[:-]?\s*)?(?:forbidden|unauthorized|access denied|permission denied|invalid or expired token)[.!]?$/i.test(message);
+}
+async function proxyError(response) {
+	const reader = response.body?.getReader();
+	const decoder = new TextDecoder();
+	let text = "";
+	let remaining = 16384;
+	try {
+		while (reader && remaining > 0) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			text += decoder.decode(value.subarray(0, remaining), { stream: true });
+			remaining -= value.byteLength;
+		}
+		text += decoder.decode();
+	} catch {} finally {
+		await reader?.cancel().catch(() => {});
+		reader?.releaseLock();
+	}
+	let message;
+	let error;
+	try {
+		const body = JSON.parse(text);
+		if (body && typeof body === "object" && !Array.isArray(body)) {
+			const payload = body;
+			message = readableMessage(payload.message);
+			error = readableMessage(payload.error);
+		}
+	} catch {
+		if (!response.headers.get("content-type")?.includes("text/html")) error = readableMessage(text);
+	}
+	if (message && isGenericPermissionMessage(message)) message = void 0;
+	if (!message && error && !isGenericPermissionMessage(error)) message = error;
+	if (!message) {
+		if (response.status === 401) message = "Remote access could not be authenticated. Sign in to the connected platform again, or restart the build to obtain a fresh prerender token.";
+		else if (response.status === 403) message = "Remote access could not be authorized. Check the selected platform and project, then ask a project admin or owner to confirm your access. If your access is correct, retry shortly.";
+		else message = error ?? "The remote service returned an unreadable error. Retry the request.";
+	}
+	return /* @__PURE__ */ new Error(`remote: Proxy request failed with ${response.status}: ${message}`);
+}
 /**
 * HTTP client for the remote bindings proxy (proxy.void.cloud).
 *
@@ -34,12 +81,10 @@ var ProxyClient = class {
 			body: JSON.stringify({
 				...body,
 				projectId: this.projectId
-			})
+			}),
+			redirect: "manual"
 		});
-		if (!res.ok) {
-			const text = await res.text().catch(() => res.statusText);
-			throw new Error(`remote: Proxy request failed with ${res.status}: '${text}'.`);
-		}
+		if (!res.ok) throw await proxyError(res);
 		return res;
 	}
 	/**
@@ -62,12 +107,10 @@ var ProxyClient = class {
 				...init.headers,
 				...this.authHeaders
 			},
-			body
+			body,
+			redirect: "manual"
 		});
-		if (!res.ok) {
-			const text = await res.text().catch(() => res.statusText);
-			throw new Error(`remote: Proxy request failed with ${res.status}: '${text}'.`);
-		}
+		if (!res.ok) throw await proxyError(res);
 		return res;
 	}
 };

package/dist/runtime/sandbox.d.mts

@@ -3,80 +3,28 @@ import { Sandbox, SandboxOptions } from "@cloudflare/sandbox";
 //#region src/runtime/sandbox.d.ts
 export declare const DEFAULT_SANDBOX_ID = "default";
 export declare const DEFAULT_SANDBOX_BINDING = "SANDBOX";
-export declare const SANDBOX_USAGE_QUEUE_BINDING = "USAGE_EVENTS_QUEUE";
-export declare const SANDBOX_GATE_BINDING = "__VOID_PROXY";
-export declare const HEARTBEAT_MS: number;
+export declare const SANDBOX_SERVICE_BINDING = "__VOID_SANDBOX";
 export type VoidSandboxOptions = SandboxOptions & {
   binding?: string;
 };
-export type SandboxUsageEvent = Readonly<{
-  requests: 0;
-  responseBytes: 0;
-  userId?: string;
-  projectId?: string;
-  slug?: string;
-  sandboxRuntimeSeconds: number;
-  sandboxInstanceId: string;
-}>;
-/**
- * Thrown by `getSandbox()` when the platform gate denies a new acquire because
- * the user has hit a concurrency or runtime budget cap. Surface this to the
- * caller so they can render a friendly error; do not retry transparently.
- */
 export declare class SandboxLimitError extends Error {
   override readonly name = "SandboxLimitError";
   readonly reason: "concurrency" | "runtime_budget";
   constructor(reason: "concurrency" | "runtime_budget", message?: string);
 }
-/** Managed platform Sandbox is unavailable or its activation gate cannot be verified. */
 export declare class SandboxUnavailableError extends Error {
   override readonly name = "SandboxUnavailableError";
   constructor(message?: string);
 }
 export declare function __setSandboxBindingName(bindingName: string): void;
 /**
- * Sandbox variant that participates in Void platform metering: it records
- * container runtime seconds into DO storage, emits periodic heartbeats to
- * the usage queue, and notifies the gate when the container stops.
- *
- * Generated code from `void inference` wires user `Sandbox` subclasses to
- * extend this class on platform deploys so per-tenant accounting works
- * without user opt-in. On local dev (no usage-queue / gate bindings), all
- * overrides degrade to no-ops and the sandbox behaves like the upstream
- * `Sandbox` class.
+ * Retained for generated native/local Worker entries. Managed deployments host
+ * the platform-owned Sandbox class in a separate Worker and never use this DO.
  */
 export declare class VoidPlatformSandbox<Env = unknown> extends Sandbox<Env> {
   override onStart(): Promise<void>;
-  override alarm(alarmProps?: AlarmInvocationInfo): Promise<void>;
-  override onStop(): Promise<void>;
-  override onActivityExpired(): Promise<void>;
-  private flushFinal;
 }
-/**
- * Resolve the platform-provided sandbox stub for the given id, optionally
- * coordinating with the platform gate to enforce per-user concurrency and
- * runtime budgets.
- *
- * When the gate binding (`__VOID_PROXY` by default) is present AND the
- * platform's `__PROJECT_ID` + `__VOID_PROXY_TOKEN` identity vars are
- * available, we POST to `https://gate/sandbox/acquire` with the HMAC-signed
- * body the shared proxy auth middleware expects. A `409` response means the
- * user has exceeded a budget — we throw `SandboxLimitError` so the caller
- * can render a clear message. Any other non-OK status (or a thrown transport
- * error from the service binding) fails closed before returning a usable
- * managed stub.
- *
- * When all reserved platform identity bindings are absent, this is a native
- * Cloudflare or local deployment and returns the upstream stub directly.
- *
- * The stub is constructed BEFORE calling the gate so we can pass its opaque,
- * namespace-specific Durable Object id (`stub.id.toString()`) as `sandboxId`.
- * The same id is available as `ctx.id.toString()` inside lifecycle hooks, so
- * acquire, heartbeat, and release use one globally unique instance identity
- * even when separate projects or deployments both request the name `default`.
- * Constructing the stub does NOT start a container — that only happens on
- * the first method call against the stub.
- */
+/** Resolve an isolated Sandbox on the current deployment. Starts on first use. */
 export declare function getSandbox<T extends Sandbox = Sandbox>(id?: string, options?: VoidSandboxOptions): Promise<T>;
 export declare const sandbox: {
   get: typeof getSandbox;

package/dist/runtime/sandbox.mjs

@@ -4,14 +4,7 @@ import { Sandbox, getSandbox as getSandbox$1 } from "@cloudflare/sandbox";
 //#region src/runtime/sandbox.ts
 const DEFAULT_SANDBOX_ID = "default";
 const DEFAULT_SANDBOX_BINDING = "SANDBOX";
-const SANDBOX_USAGE_QUEUE_BINDING = "USAGE_EVENTS_QUEUE";
-const SANDBOX_GATE_BINDING = "__VOID_PROXY";
-const HEARTBEAT_MS = 3e5;
-/**
-* Thrown by `getSandbox()` when the platform gate denies a new acquire because
-* the user has hit a concurrency or runtime budget cap. Surface this to the
-* caller so they can render a friendly error; do not retry transparently.
-*/
+const SANDBOX_SERVICE_BINDING = "__VOID_SANDBOX";
 var SandboxLimitError = class extends Error {
 	name = "SandboxLimitError";
 	reason;
@@ -20,7 +13,6 @@ var SandboxLimitError = class extends Error {
 		this.reason = reason;
 	}
 };
-/** Managed platform Sandbox is unavailable or its activation gate cannot be verified. */
 var SandboxUnavailableError = class extends Error {
 	name = "SandboxUnavailableError";
 	constructor(message = "Managed Sandbox is unavailable on this Void platform.") {
@@ -31,233 +23,102 @@ let sandboxBindingName = DEFAULT_SANDBOX_BINDING;
 function __setSandboxBindingName(bindingName) {
 	sandboxBindingName = bindingName;
 }
-const STORAGE_KEY_START_TS = "__voidStartTs";
-const STORAGE_KEY_LAST_FLUSH_TS = "__voidLastFlushTs";
-function getUsageContext() {
-	const runtimeEnv = getRawRuntimeEnv();
-	return {
-		userId: runtimeEnv.__VOID_USER_ID,
-		projectId: runtimeEnv.__PROJECT_ID,
-		slug: runtimeEnv.__VOID_PROJECT_SLUG
-	};
-}
-function getSandboxInstanceId(ctx) {
-	return ctx.id.toString();
-}
-/**
-* Flush the accumulated runtime delta to the usage queue. No-op when the
-* usage-queue binding is not bound (e.g. local dev without the platform
-* proxy). Errors are swallowed and logged — usage emission must never crash
-* the sandbox lifecycle.
-*/
-async function emitRuntimeSeconds(ctx, sandboxRuntimeSeconds) {
-	if (sandboxRuntimeSeconds <= 0) return;
-	const queue = getRawRuntimeEnv()[SANDBOX_USAGE_QUEUE_BINDING];
-	if (!queue) return;
-	const event = {
-		requests: 0,
-		responseBytes: 0,
-		sandboxRuntimeSeconds,
-		sandboxInstanceId: getSandboxInstanceId(ctx),
-		...getUsageContext()
-	};
-	try {
-		await queue.send(event);
-	} catch (error) {
-		console.error("[void/sandbox] failed to emit usage event:", error);
-	}
-}
-function isManagedPlatformSandbox(runtimeEnv) {
-	return [
-		SANDBOX_GATE_BINDING,
-		"__PROJECT_ID",
-		"__VOID_PROXY_TOKEN",
-		"__VOID_USER_ID",
-		"__VOID_PROJECT_SLUG"
-	].some((binding) => runtimeEnv[binding] !== void 0);
+function rethrowSandboxError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	for (const reason of ["concurrency", "runtime_budget"]) if (message.includes(`VOID_SANDBOX_${reason}`)) throw new SandboxLimitError(reason);
+	if (message.includes("VOID_SANDBOX_unavailable")) throw new SandboxUnavailableError();
+	throw error;
 }
-function resolveGateIdentity(runtimeEnv = getRawRuntimeEnv()) {
-	const gate = runtimeEnv[SANDBOX_GATE_BINDING];
-	if (!gate) return null;
-	const projectId = runtimeEnv.__PROJECT_ID;
-	const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
-	if (!projectId || !aiToken) return null;
-	return {
-		gate,
-		projectId,
-		aiToken
+function managedClient(capability) {
+	const call = async (target, operation, args) => {
+		try {
+			return decodeManagedResult(await target.invoke(operation, prepareManagedArgs(operation, args)));
+		} catch (error) {
+			rethrowSandboxError(error);
+		}
 	};
-}
-async function acquireManagedSandbox(sandboxId, runtimeEnv = getRawRuntimeEnv()) {
-	if (!isManagedPlatformSandbox(runtimeEnv)) return;
-	const identity = resolveGateIdentity(runtimeEnv);
-	if (!identity) throw new SandboxUnavailableError("Managed Sandbox activation could not verify the platform identity bindings.");
-	let response;
-	try {
-		response = await identity.gate.fetch("https://gate/sandbox/acquire", {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				projectId: identity.projectId,
-				aiToken: identity.aiToken,
-				sandboxId
-			})
-		});
-	} catch {
-		throw new SandboxUnavailableError("Managed Sandbox activation could not reach the platform gate.");
+	return new Proxy(Object.create(null), { get(_target, property) {
+		if (typeof property !== "string" || property === "then") return;
+		if (property === "tunnels") return new Proxy(Object.create(null), { get(_tunnels, method) {
+			if (typeof method !== "string" || method === "then") return;
+			return (...args) => call(capability, "tunnels", [method, ...args]);
+		} });
+		return (...args) => call(capability, property, args);
+	} });
+	function decodeManagedResult(value) {
+		if (Array.isArray(value)) return value.map(decodeManagedResult);
+		if (!value || typeof value !== "object") return value;
+		const record = value;
+		if (record.__voidSandboxType === "process") {
+			const { capability: processCapability, __voidSandboxType: _type, ...snapshot } = value;
+			return Object.assign(snapshot, {
+				kill: (...args) => call(processCapability, "kill", args),
+				getStatus: (...args) => call(processCapability, "getStatus", args),
+				getLogs: (...args) => call(processCapability, "getLogs", args),
+				waitForLog: (...args) => call(processCapability, "waitForLog", args),
+				waitForPort: (...args) => call(processCapability, "waitForPort", args),
+				waitForExit: (...args) => call(processCapability, "waitForExit", args)
+			});
+		}
+		if (record.__voidSandboxType === "session") {
+			const session = value;
+			return new Proxy({ id: session.id }, { get(target, property) {
+				if (property === "id") return target.id;
+				if (typeof property !== "string" || property === "then") return;
+				return (...args) => call(session.capability, property, args);
+			} });
+		}
+		return value;
 	}
-	if (response.status === 409) {
-		const body = await response.json().catch(() => ({}));
-		throw new SandboxLimitError(body.reason === "concurrency" || body.reason === "runtime_budget" ? body.reason : "concurrency");
+	function prepareManagedArgs(operation, args) {
+		if (operation !== "startProcess") return args;
+		const [command, options, ...rest] = args;
+		if (!options || typeof options !== "object" || Array.isArray(options)) return args;
+		const onStart = options.onStart;
+		if (typeof onStart !== "function") return args;
+		return [
+			command,
+			{
+				...options,
+				onStart: (process) => onStart(decodeManagedResult(process))
+			},
+			...rest
+		];
 	}
-	if (!response.ok) throw new SandboxUnavailableError(`Managed Sandbox activation was rejected by the platform gate (HTTP ${response.status}).`);
-}
-/**
-* Release notification to the gate so it can drop the active lease counter.
-* Returns the in-flight fetch as a Promise (errors swallowed) so callers can
-* route it through `ctx.waitUntil()` and keep it alive past lifecycle
-* teardown. Failure is silent — the gate maintains its own TTL fallback.
-*/
-function notifyGateRelease(ctx) {
-	const identity = resolveGateIdentity();
-	if (!identity) return Promise.resolve();
-	const sandboxId = getSandboxInstanceId(ctx);
-	return identity.gate.fetch("https://gate/sandbox/release", {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			projectId: identity.projectId,
-			aiToken: identity.aiToken,
-			sandboxId
-		})
-	}).then(() => void 0).catch(() => {});
 }
 /**
-* Heartbeat-driven keepalive ping for the gate's concurrency slot. The DO's
-* `STALE_MS` (1h) sweep would otherwise reap slots for long-running sandbox
-* sessions whose `acquiredAt` ages past the threshold between acquire and
-* release, letting new acquires exceed `sandboxMaxConcurrentInstances`. The
-* 5 min heartbeat sits well inside the sweep window, so each successful
-* refresh resets the stale clock. Returns the in-flight fetch as a Promise
-* (errors swallowed) so callers can route it through `ctx.waitUntil()` and
-* keep the alarm path itself off the critical path — a failed refresh just
-* means the slot ages out naturally, which matches the pre-existing failure
-* mode if the gate goes down entirely.
-*/
-function notifyGateRefresh(ctx) {
-	const identity = resolveGateIdentity();
-	if (!identity) return Promise.resolve();
-	const sandboxId = getSandboxInstanceId(ctx);
-	return identity.gate.fetch("https://gate/sandbox/refresh", {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify({
-			projectId: identity.projectId,
-			aiToken: identity.aiToken,
-			sandboxId
-		})
-	}).then(() => void 0).catch(() => {});
-}
-/**
-* Sandbox variant that participates in Void platform metering: it records
-* container runtime seconds into DO storage, emits periodic heartbeats to
-* the usage queue, and notifies the gate when the container stops.
-*
-* Generated code from `void inference` wires user `Sandbox` subclasses to
-* extend this class on platform deploys so per-tenant accounting works
-* without user opt-in. On local dev (no usage-queue / gate bindings), all
-* overrides degrade to no-ops and the sandbox behaves like the upstream
-* `Sandbox` class.
+* Retained for generated native/local Worker entries. Managed deployments host
+* the platform-owned Sandbox class in a separate Worker and never use this DO.
 */
 var VoidPlatformSandbox = class extends Sandbox {
 	async onStart() {
-		await acquireManagedSandbox(getSandboxInstanceId(this.ctx), this.env);
-		const now = Date.now();
-		const stored = await this.ctx.storage.get([STORAGE_KEY_START_TS, STORAGE_KEY_LAST_FLUSH_TS]);
-		const orphanedAnchor = stored.get(STORAGE_KEY_LAST_FLUSH_TS) ?? stored.get(STORAGE_KEY_START_TS);
-		if (orphanedAnchor !== void 0 && orphanedAnchor < now) {
-			const sandboxRuntimeSeconds = (now - orphanedAnchor) / 1e3;
-			await emitRuntimeSeconds(this.ctx, sandboxRuntimeSeconds);
-			await this.ctx.storage.delete([STORAGE_KEY_START_TS, STORAGE_KEY_LAST_FLUSH_TS]);
-		}
-		try {
-			await super.onStart();
-		} catch (err) {
-			this.ctx.waitUntil(notifyGateRelease(this.ctx));
-			throw err;
-		}
-		const startedAt = Date.now();
-		await this.ctx.storage.put({
-			[STORAGE_KEY_START_TS]: startedAt,
-			[STORAGE_KEY_LAST_FLUSH_TS]: startedAt
-		});
-		await this.ctx.storage.setAlarm(startedAt + HEARTBEAT_MS);
-	}
-	async alarm(alarmProps) {
-		await super.alarm(alarmProps);
-		const lastFlush = await this.ctx.storage.get(STORAGE_KEY_LAST_FLUSH_TS);
-		if (typeof lastFlush !== "number") return;
-		const now = Date.now();
-		const sandboxRuntimeSeconds = Math.max(0, (now - lastFlush) / 1e3);
-		await emitRuntimeSeconds(this.ctx, sandboxRuntimeSeconds);
-		this.ctx.waitUntil(notifyGateRefresh(this.ctx));
-		await Promise.all([this.ctx.storage.put(STORAGE_KEY_LAST_FLUSH_TS, now), this.ctx.storage.setAlarm(now + HEARTBEAT_MS)]);
-	}
-	async onStop() {
-		await this.flushFinal();
-		this.ctx.waitUntil(notifyGateRelease(this.ctx));
-		await super.onStop();
-	}
-	async onActivityExpired() {
-		await this.flushFinal();
-		this.ctx.waitUntil(notifyGateRelease(this.ctx));
-		await super.onActivityExpired();
-	}
-	async flushFinal() {
-		const lastFlush = await this.ctx.storage.get(STORAGE_KEY_LAST_FLUSH_TS);
-		if (typeof lastFlush === "number") {
-			const sandboxRuntimeSeconds = Math.max(0, (Date.now() - lastFlush) / 1e3);
-			await emitRuntimeSeconds(this.ctx, sandboxRuntimeSeconds);
-		}
-		await this.ctx.storage.delete(STORAGE_KEY_START_TS);
-		await this.ctx.storage.delete(STORAGE_KEY_LAST_FLUSH_TS);
+		const env = this.env;
+		if (env.__PROJECT_ID !== void 0 || env.__VOID_PROXY !== void 0) throw new SandboxUnavailableError("Managed Sandboxes require the platform Sandbox controller. Redeploy this application.");
+		await super.onStart();
 	}
 };
-/**
-* Resolve the platform-provided sandbox stub for the given id, optionally
-* coordinating with the platform gate to enforce per-user concurrency and
-* runtime budgets.
-*
-* When the gate binding (`__VOID_PROXY` by default) is present AND the
-* platform's `__PROJECT_ID` + `__VOID_PROXY_TOKEN` identity vars are
-* available, we POST to `https://gate/sandbox/acquire` with the HMAC-signed
-* body the shared proxy auth middleware expects. A `409` response means the
-* user has exceeded a budget — we throw `SandboxLimitError` so the caller
-* can render a clear message. Any other non-OK status (or a thrown transport
-* error from the service binding) fails closed before returning a usable
-* managed stub.
-*
-* When all reserved platform identity bindings are absent, this is a native
-* Cloudflare or local deployment and returns the upstream stub directly.
-*
-* The stub is constructed BEFORE calling the gate so we can pass its opaque,
-* namespace-specific Durable Object id (`stub.id.toString()`) as `sandboxId`.
-* The same id is available as `ctx.id.toString()` inside lifecycle hooks, so
-* acquire, heartbeat, and release use one globally unique instance identity
-* even when separate projects or deployments both request the name `default`.
-* Constructing the stub does NOT start a container — that only happens on
-* the first method call against the stub.
-*/
+/** Resolve an isolated Sandbox on the current deployment. Starts on first use. */
 async function getSandbox(id = DEFAULT_SANDBOX_ID, options) {
 	const { binding = sandboxBindingName, ...sandboxOptions } = options ?? {};
-	const namespace = requireRuntimeBinding(binding);
-	const stub = getSandbox$1(namespace, id, {
+	const runtimeEnv = getRawRuntimeEnv();
+	const service = runtimeEnv[SANDBOX_SERVICE_BINDING];
+	if (service) {
+		if (binding !== sandboxBindingName) throw new SandboxUnavailableError(`Managed Sandbox binding ${binding} is unavailable.`);
+		try {
+			return managedClient(await service.getSandbox(id, {
+				normalizeId: true,
+				...sandboxOptions
+			}));
+		} catch (error) {
+			rethrowSandboxError(error);
+		}
+	}
+	if (runtimeEnv.__PROJECT_ID !== void 0 || runtimeEnv.__VOID_PROXY !== void 0) throw new SandboxUnavailableError("This deployment has no managed Sandbox controller. Redeploy this application.");
+	return getSandbox$1(requireRuntimeBinding(binding), id, {
 		normalizeId: true,
 		...sandboxOptions
 	});
-	await acquireManagedSandbox(stub.id.toString());
-	return stub;
 }
 const sandbox = { get: getSandbox };
 //#endregion
-export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, HEARTBEAT_MS, SANDBOX_GATE_BINDING, SANDBOX_USAGE_QUEUE_BINDING, Sandbox, SandboxLimitError, SandboxUnavailableError, VoidPlatformSandbox, __setSandboxBindingName, getSandbox, sandbox };
+export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, SANDBOX_SERVICE_BINDING, Sandbox, SandboxLimitError, SandboxUnavailableError, VoidPlatformSandbox, __setSandboxBindingName, getSandbox, sandbox };

package/dist/{secret-ByhJ9AMl.mjs → secret-AcPi-FoA.mjs}

@@ -1,7 +1,7 @@
-import { A as password, C as cancel, D as log, E as intro, F as isCancel, O as note, k as outro, r as cliTitle, w as confirm } from "./output-tFQLLj26.mjs";
-import { b as readDeploymentPlatform, c as getToken, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
-import { m as validateSecretValues } from "./env-validation-ENpMy6Ez.mjs";
-import { n as PlatformClient } from "./client-Clirrol3.mjs";
+import { A as outro, C as cancel, D as log, E as intro, I as isCancel, j as password, k as note, r as cliTitle, w as confirm } from "./output-B0cfNSx5.mjs";
+import { S as readProjectConfig, l as getToken, x as readDeploymentPlatform } from "./auth-DPl6kck4.mjs";
+import { m as validateSecretValues } from "./env-validation-CF6KvTRf.mjs";
+import { n as PlatformClient } from "./client-BQBrZoCX.mjs";
 import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project--Vxawf7z.mjs";
 import { readFileSync } from "node:fs";
 //#region src/cli/secret.ts
@@ -76,7 +76,7 @@ async function runSecretCommand(root, args) {
 }
 async function runCloudflareSecretCommand(root, args) {
 	if (args.projectName) throw new Error("secret: --project selects a Void platform project and is not used for direct Cloudflare apps.");
-	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-BzWnlC1_.mjs").then((n) => n.t);
 	const context = resolveCloudflareOperationContext(root);
 	if (args.action === "list") {
 		const secrets = await listCloudflareSecrets(context);

package/dist/{skills-Q46GZMO-.mjs → skills-C0RvGjeE.mjs}

@@ -1,5 +1,5 @@
 import { c as relative, o as join } from "./dist-BrsS7cai.mjs";
-import { D as log, p as getPackageDir } from "./output-tFQLLj26.mjs";
+import { D as log, p as getPackageDir } from "./output-B0cfNSx5.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync } from "node:fs";
 //#region src/cli/skills.ts
 function parseSkills(skillsDir) {

package/dist/{subcommand-prompt-WfySCQ7S.mjs → subcommand-prompt-Bmyn5Rlc.mjs}

@@ -1,4 +1,4 @@
-import { R as wrapAnsi, S as S_STEP_SUBMIT, _ as S_CHECKBOX_INACTIVE, b as S_RADIO_INACTIVE, c as import_picocolors, g as S_CHECKBOX_ACTIVE, h as S_BAR_END, m as S_BAR, x as S_STEP_ACTIVE, y as S_RADIO_ACTIVE } from "./output-tFQLLj26.mjs";
+import { S as S_STEP_SUBMIT, _ as S_CHECKBOX_INACTIVE, b as S_RADIO_INACTIVE, c as import_picocolors, g as S_CHECKBOX_ACTIVE, h as S_BAR_END, m as S_BAR, x as S_STEP_ACTIVE, y as S_RADIO_ACTIVE, z as wrapAnsi } from "./output-B0cfNSx5.mjs";
 //#region src/cli/subcommand-prompt.ts
 function promptSubcommand(command, subcommands) {
 	return new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.20.1",
+  "version": "0.20.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -218,6 +218,11 @@
       "import": "./dist/runtime/email.mjs",
       "require": "./dist/runtime/email.mjs"
     },
+    "./_email-protocol": {
+      "types": "./dist/runtime/email-protocol.d.mts",
+      "import": "./dist/runtime/email-protocol.mjs",
+      "require": "./dist/runtime/email-protocol.mjs"
+    },
     "./email/testing": {
       "types": "./dist/runtime/email/testing.d.mts",
       "import": "./dist/runtime/email/testing.mjs",
@@ -313,11 +318,11 @@
     "@cloudflare/vite-plugin": "1.54.7",
     "@cloudflare/workers-types": "^4.20260702.1",
     "@napi-rs/keyring": "2.0.0",
-    "@void/deploy-cloudflare": "0.20.1",
-    "@void/deploy-core": "0.20.1",
-    "@void/edge": "0.20.1",
-    "@void/isr": "0.20.1",
-    "@void/platform": "0.20.1",
+    "@void/deploy-cloudflare": "0.20.3",
+    "@void/deploy-core": "0.20.3",
+    "@void/edge": "0.20.3",
+    "@void/isr": "0.20.3",
+    "@void/platform": "0.20.3",
     "better-auth": "^1.7.3",
     "better-sqlite3": "^13.0.3",
     "blake3-jit": "^1.1.0",
@@ -363,7 +368,7 @@
     "zod": "^4.6.1"
   },
   "peerDependencies": {
-    "@void/md": "0.20.1",
+    "@void/md": "0.20.3",
     "arktype": ">=2.0.0",
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",