void 0.20.2 → 0.21.0

package/dist/runtime/migration-handler-mysql.d.mts

@@ -1,4 +1,4 @@
-import { MigrationEntry } from "./migration-handler.mjs";
+import { t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
 //#region src/runtime/migration-handler-mysql.d.ts
 export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
 //#endregion

package/dist/runtime/migration-handler-pg.d.mts

@@ -1,4 +1,4 @@
-import { MigrationEntry } from "./migration-handler.mjs";
+import { t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
 //#region src/runtime/migration-handler-pg.d.ts
 export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
 //#endregion

package/dist/runtime/migration-handler.d.mts

@@ -1,50 +1,2 @@
-//#region src/runtime/migration-handler.d.ts
-export type MigrationEntry = {
-  name: string;
-  sql: string;
-};
-export type MigrationResult = {
-  name: string;
-  applied: boolean;
-  durationMs: number;
-  error?: string;
-  status?: "applied" | "skipped" | "failed";
-  stability?: "stable" | "legacy";
-};
-export type MigrationResponse = {
-  ok: boolean;
-  migrations: Array<MigrationResult>;
-  error?: string;
-  protocolVersion?: 2;
-  attemptId?: string;
-  confirmedApplied?: Array<string>;
-  confirmedSkipped?: Array<string>;
-  stability?: "stable" | "legacy";
-  warnings?: Array<string>;
-};
-type MigrationExecutionPlan = {
-  name: string;
-  dialect: "sqlite";
-  classifierVersion: number;
-  sqlHash: string;
-  planHash: string;
-  stability: "stable" | "legacy";
-  warnings?: Array<string>;
-} & ({
-  kind: "single-statement";
-} | {
-  kind: "breakpoint-framed";
-  statements: Array<string>;
-} | {
-  kind: "legacy-unsplit-multi-statement";
-  allowLegacy: boolean;
-});
-type MigrationPlanBundle = {
-  protocolVersion: 2;
-  classifierVersion: number;
-  migrationListHash: string;
-  destructiveValidation: "passed";
-  plans: Array<MigrationExecutionPlan>;
-};
-export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry> | undefined, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>, planBundle?: MigrationPlanBundle): (request: Request) => Promise<Response>;
-//#endregion
+import { i as createMigrationHandler, n as MigrationResponse, r as MigrationResult, t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
+export { MigrationEntry, MigrationResponse, MigrationResult, createMigrationHandler };

package/dist/runtime/queues.d.mts

@@ -1,6 +1,2 @@
-//#region src/runtime/queues.d.ts
-/** Stub interface augmented by generated .void/queues.d.ts */
-export interface QueueMap {}
-/** Typed queue producers — resolves `QUEUE_*` bindings from the active runtime environment. */
-export declare const queues: QueueMap;
-//#endregion
+import { n as queues, t as QueueMap } from "../queues-BWKt1Xo4.mjs";
+export { QueueMap, queues };

package/dist/runtime/queues.mjs

@@ -1,4 +1,4 @@
-import { requireRuntimeBinding } from "./env.mjs";
+import { a as requireRuntimeBinding } from "../env-Yz4HcvHs.mjs";
 //#region src/runtime/queues.ts
 /** Typed queue producers — resolves `QUEUE_*` bindings from the active runtime environment. */
 const queues = new Proxy({}, { get(_, name) {

package/dist/runtime/remote/index.mjs

@@ -1,6 +1,53 @@
 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).
 *
@@ -37,10 +84,7 @@ var ProxyClient = class {
 			}),
 			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;
 	}
 	/**
@@ -66,10 +110,7 @@ var ProxyClient = class {
 			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/response.mjs

@@ -1,30 +1,2 @@
-//#region src/runtime/response.ts
-/**
-* Tracks responses created by convertReturnValue (as opposed to responses
-* explicitly constructed by user code). Used by handlePageGet to decide
-* whether a Response should be passed through or unwrapped as page props.
-*/
-const convertedResponses = /* @__PURE__ */ new WeakSet();
-/** Returns true if the value is a Response that was created by convertReturnValue. */
-function isConvertedResponse(value) {
-	return value instanceof Response && convertedResponses.has(value);
-}
-/**
-* Convert a handler's return value to a Web Response.
-*
-* - Response → passthrough
-* - null/undefined → 204 No Content
-* - string → text/html
-* - object/array → JSON
-*/
-function convertReturnValue(value) {
-	if (value instanceof Response) return value;
-	let response;
-	if (value === null || value === void 0) response = new Response(null, { status: 204 });
-	else if (typeof value === "string") response = new Response(value, { headers: { "Content-Type": "text/html; charset=utf-8" } });
-	else response = Response.json(value);
-	convertedResponses.add(response);
-	return response;
-}
-//#endregion
+import { n as isConvertedResponse, t as convertReturnValue } from "../response-Tn7rU0MV.mjs";
 export { convertReturnValue, isConvertedResponse };

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

@@ -1,17 +1,10 @@
 import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
-import { requireRuntimeBinding } from "./env.mjs";
+import { a as requireRuntimeBinding } from "../env-Yz4HcvHs.mjs";
 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 };