void 0.10.13 → 0.20.1

package/dist/runtime/sandbox.d.mts

@@ -1,16 +1,15 @@
 /// <reference types="@cloudflare/workers-types" />
 import { Sandbox, SandboxOptions } from "@cloudflare/sandbox";
-
 //#region src/runtime/sandbox.d.ts
-declare const DEFAULT_SANDBOX_ID = "default";
-declare const DEFAULT_SANDBOX_BINDING = "SANDBOX";
-declare const SANDBOX_USAGE_QUEUE_BINDING = "USAGE_EVENTS_QUEUE";
-declare const SANDBOX_GATE_BINDING = "__VOID_PROXY";
-declare const HEARTBEAT_MS: number;
-type VoidSandboxOptions = SandboxOptions & {
+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 type VoidSandboxOptions = SandboxOptions & {
   binding?: string;
 };
-type SandboxUsageEvent = Readonly<{
+export type SandboxUsageEvent = Readonly<{
   requests: 0;
   responseBytes: 0;
   userId?: string;
@@ -20,28 +19,33 @@ type SandboxUsageEvent = Readonly<{
   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.
-*/
-declare class SandboxLimitError extends Error {
+ * 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);
 }
-declare function __setSandboxBindingName(bindingName: string): void;
+/** 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.
-*/
-declare class VoidPlatformSandbox<Env = unknown> extends Sandbox<Env> {
+ * 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.
+ */
+export declare class VoidPlatformSandbox<Env = unknown> extends Sandbox<Env> {
   override onStart(): Promise<void>;
   override alarm(alarmProps?: AlarmInvocationInfo): Promise<void>;
   override onStop(): Promise<void>;
@@ -49,36 +53,33 @@ declare class VoidPlatformSandbox<Env = unknown> extends Sandbox<Env> {
   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) is treated as "gate unavailable" and we
-* fall through to returning the stub so a broken gate doesn't break sandbox
-* access entirely.
-*
-* When the gate binding is absent (local dev) or the identity vars are
-* missing (partial deploy), the gate check is skipped entirely and we
-* return the stub directly.
-*
-* The stub is constructed BEFORE calling the gate so we can derive the
-* normalized DO name (`stub.id.name`) and pass it to the gate as the
-* `sandboxId`. This keeps acquire and release using the same key — without
-* it, mixed-case caller ids (e.g. `MyProject-123`) would acquire a lease
-* under the raw id but release it under the normalized lowercase form that
-* `ctx.id.name` reports inside the DO, leaking the lease until TTL.
-* Constructing the stub does NOT start a container — that only happens on
-* the first method call against the stub.
-*/
-declare function getSandbox<T extends Sandbox = Sandbox>(id?: string, options?: VoidSandboxOptions): Promise<T>;
-declare const sandbox: {
+ * 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.
+ */
+export declare function getSandbox<T extends Sandbox = Sandbox>(id?: string, options?: VoidSandboxOptions): Promise<T>;
+export declare const sandbox: {
   get: typeof getSandbox;
 };
 //#endregion
-export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, HEARTBEAT_MS, SANDBOX_GATE_BINDING, SANDBOX_USAGE_QUEUE_BINDING, Sandbox, SandboxLimitError, type SandboxOptions, SandboxUsageEvent, VoidPlatformSandbox, VoidSandboxOptions, __setSandboxBindingName, getSandbox, sandbox };
+export { Sandbox, type SandboxOptions };

package/dist/runtime/sandbox.mjs

@@ -6,7 +6,7 @@ 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 = 5 * 6e4;
+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
@@ -20,6 +20,13 @@ 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.") {
+		super(message);
+	}
+};
 let sandboxBindingName = DEFAULT_SANDBOX_BINDING;
 function __setSandboxBindingName(bindingName) {
 	sandboxBindingName = bindingName;
@@ -35,7 +42,7 @@ function getUsageContext() {
 	};
 }
 function getSandboxInstanceId(ctx) {
-	return ctx.id.name ?? ctx.id.toString();
+	return ctx.id.toString();
 }
 /**
 * Flush the accumulated runtime delta to the usage queue. No-op when the
@@ -60,20 +67,16 @@ async function emitRuntimeSeconds(ctx, sandboxRuntimeSeconds) {
 		console.error("[void/sandbox] failed to emit usage event:", error);
 	}
 }
-/**
-* Resolve the `{ gate, projectId, aiToken }` triple needed to call a gate
-* route. Returns `null` when any piece is missing — local dev (no proxy
-* binding) and partial deploys (binding present but identity vars absent)
-* both fall through to the no-op path so a missing platform setup never
-* blocks sandbox acquisition.
-*
-* Wire field is named `aiToken` because the shared proxy auth middleware
-* (packages/proxy/src/index.ts) verifies HMAC against `body.aiToken` for
-* every route. Naming it `proxyToken` here would diverge from the existing
-* AI/ISR convention without changing the on-the-wire contract.
-*/
-function resolveGateIdentity() {
-	const runtimeEnv = getRawRuntimeEnv();
+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 resolveGateIdentity(runtimeEnv = getRawRuntimeEnv()) {
 	const gate = runtimeEnv[SANDBOX_GATE_BINDING];
 	if (!gate) return null;
 	const projectId = runtimeEnv.__PROJECT_ID;
@@ -85,6 +88,30 @@ function resolveGateIdentity() {
 		aiToken
 	};
 }
+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.");
+	}
+	if (response.status === 409) {
+		const body = await response.json().catch(() => ({}));
+		throw new SandboxLimitError(body.reason === "concurrency" || body.reason === "runtime_budget" ? body.reason : "concurrency");
+	}
+	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
@@ -144,6 +171,7 @@ function notifyGateRefresh(ctx) {
 */
 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);
@@ -206,50 +234,30 @@ var VoidPlatformSandbox = class extends Sandbox {
 * 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) is treated as "gate unavailable" and we
-* fall through to returning the stub so a broken gate doesn't break sandbox
-* access entirely.
+* error from the service binding) fails closed before returning a usable
+* managed stub.
 *
-* When the gate binding is absent (local dev) or the identity vars are
-* missing (partial deploy), the gate check is skipped entirely and we
-* return the stub directly.
+* 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 derive the
-* normalized DO name (`stub.id.name`) and pass it to the gate as the
-* `sandboxId`. This keeps acquire and release using the same key — without
-* it, mixed-case caller ids (e.g. `MyProject-123`) would acquire a lease
-* under the raw id but release it under the normalized lowercase form that
-* `ctx.id.name` reports inside the DO, leaking the lease until TTL.
+* 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.
 */
 async function getSandbox(id = DEFAULT_SANDBOX_ID, options) {
 	const { binding = sandboxBindingName, ...sandboxOptions } = options ?? {};
-	const stub = getSandbox$1(requireRuntimeBinding(binding), id, {
+	const namespace = requireRuntimeBinding(binding);
+	const stub = getSandbox$1(namespace, id, {
 		normalizeId: true,
 		...sandboxOptions
 	});
-	const sandboxId = stub.id.name ?? id;
-	const identity = resolveGateIdentity();
-	if (identity) try {
-		const res = 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
-			})
-		});
-		if (res.status === 409) {
-			const body = await res.json().catch(() => ({}));
-			throw new SandboxLimitError(body.reason === "concurrency" || body.reason === "runtime_budget" ? body.reason : "concurrency");
-		}
-	} catch (error) {
-		if (error instanceof SandboxLimitError) throw error;
-	}
+	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, VoidPlatformSandbox, __setSandboxBindingName, getSandbox, sandbox };
+export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, HEARTBEAT_MS, SANDBOX_GATE_BINDING, SANDBOX_USAGE_QUEUE_BINDING, Sandbox, SandboxLimitError, SandboxUnavailableError, VoidPlatformSandbox, __setSandboxBindingName, getSandbox, sandbox };

package/dist/runtime/schema-mysql.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-orm/mysql-core";

package/dist/runtime/schema-mysql.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-orm/mysql-core";
+export {};

package/dist/runtime/seed.d.mts

@@ -1,17 +1,22 @@
+import { MySql2Database } from "drizzle-orm/mysql2";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
-
 //#region src/runtime/seed.d.ts
-type SqliteSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = {
+export type SqliteSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = {
   dialect: "sqlite";
   db: BetterSQLite3Database<TSchema>;
   schema: TSchema;
 };
-type PostgresSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = {
+export type PostgresSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = {
   dialect: "postgresql";
   db: NodePgDatabase<TSchema>;
   schema: TSchema;
 };
+export type MySqlSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = {
+  dialect: "mysql";
+  db: MySql2Database<TSchema>;
+  schema: TSchema;
+};
 type DrizzleTableForDialect<TDialect extends string> = {
   readonly _: {
     readonly config: {
@@ -22,9 +27,9 @@ type DrizzleTableForDialect<TDialect extends string> = {
 type SchemaHasTableDialect<TSchema extends Record<string, unknown>, TDialect extends string> = [Extract<TSchema[keyof TSchema], DrizzleTableForDialect<TDialect>>] extends [never] ? false : true;
 type SchemaHasSqliteTables<TSchema extends Record<string, unknown>> = SchemaHasTableDialect<TSchema, "sqlite">;
 type SchemaHasPostgresTables<TSchema extends Record<string, unknown>> = SchemaHasTableDialect<TSchema, "pg">;
-type FallbackSeedContext<TSchema extends Record<string, unknown>> = SchemaHasSqliteTables<TSchema> extends false ? SchemaHasPostgresTables<TSchema> extends false ? SqliteSeedContext<TSchema> | PostgresSeedContext<TSchema> : never : never;
-type SeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = (SchemaHasSqliteTables<TSchema> extends true ? SqliteSeedContext<TSchema> : never) | (SchemaHasPostgresTables<TSchema> extends true ? PostgresSeedContext<TSchema> : never) | FallbackSeedContext<TSchema>;
-type SeedFn<TSchema extends Record<string, unknown> = Record<string, never>> = (context: SeedContext<TSchema>) => void | Promise<void>;
-declare function defineSeed<TSchema extends Record<string, unknown> = Record<string, never>>(seed: SeedFn<TSchema>): SeedFn<TSchema>;
-//#endregion
-export { PostgresSeedContext, SeedContext, SeedFn, SqliteSeedContext, defineSeed };
+type SchemaHasMySqlTables<TSchema extends Record<string, unknown>> = SchemaHasTableDialect<TSchema, "mysql">;
+type FallbackSeedContext<TSchema extends Record<string, unknown>> = SchemaHasSqliteTables<TSchema> extends false ? SchemaHasPostgresTables<TSchema> extends false ? SchemaHasMySqlTables<TSchema> extends false ? SqliteSeedContext<TSchema> | PostgresSeedContext<TSchema> | MySqlSeedContext<TSchema> : never : never : never;
+export type SeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = (SchemaHasSqliteTables<TSchema> extends true ? SqliteSeedContext<TSchema> : never) | (SchemaHasPostgresTables<TSchema> extends true ? PostgresSeedContext<TSchema> : never) | (SchemaHasMySqlTables<TSchema> extends true ? MySqlSeedContext<TSchema> : never) | FallbackSeedContext<TSchema>;
+export type SeedFn<TSchema extends Record<string, unknown> = Record<string, never>> = (context: SeedContext<TSchema>) => void | Promise<void>;
+export declare function defineSeed<TSchema extends Record<string, unknown> = Record<string, never>>(seed: SeedFn<TSchema>): SeedFn<TSchema>;
+//#endregion

package/dist/runtime/sse-client.d.mts

@@ -1,22 +1,21 @@
 //#region src/runtime/sse-client.d.ts
-type SseClientEvent<T = unknown> = {
+export type SseClientEvent<T = unknown> = {
   data: T;
   event: string;
   id: string;
   raw: MessageEvent;
 };
-type SseEventMap = Record<string, unknown>;
-type SseClient<Events extends SseEventMap = SseEventMap> = {
+export type SseEventMap = Record<string, unknown>;
+export type SseClient<Events extends SseEventMap = SseEventMap> = {
   on<Name extends Extract<keyof Events, string>>(event: Name, handler: (event: SseClientEvent<Events[Name]>) => void): () => void;
   on<T = unknown>(event: string, handler: (event: SseClientEvent<T>) => void): () => void;
   onError(handler: (event: Event) => void): () => void;
   close(): void;
 };
-type ConnectEventStreamOptions = {
+export type ConnectEventStreamOptions = {
   withCredentials?: boolean;
   events?: Array<string>;
   parse?: "json" | "text" | ((data: string) => unknown);
 };
-declare function connectEventStream<Events extends SseEventMap = SseEventMap>(url: string | URL, options?: ConnectEventStreamOptions): SseClient<Events>;
-//#endregion
-export { ConnectEventStreamOptions, SseClient, SseClientEvent, SseEventMap, connectEventStream };
+export declare function connectEventStream<Events extends SseEventMap = SseEventMap>(url: string | URL, options?: ConnectEventStreamOptions): SseClient<Events>;
+//#endregion

package/dist/runtime/sse.d.mts

@@ -1,35 +1,34 @@
 //#region src/runtime/sse.d.ts
-type SseMessage = {
+export type SseMessage = {
   data?: unknown;
   event?: string;
   id?: string;
   retry?: number;
 };
-type SseTextMessage = Omit<SseMessage, "data"> & {
+export type SseTextMessage = Omit<SseMessage, "data"> & {
   data?: string;
 };
-type SseStream = {
+export type SseStream = {
   readonly signal: AbortSignal;
   readonly closed: Promise<void>;
   send(message: SseMessage): Promise<void>;
   comment(text?: string): Promise<void>;
   close(): Promise<void>;
 };
-type SseKeepAliveOptions = boolean | {
+export type SseKeepAliveOptions = boolean | {
   intervalMs?: number;
   comment?: string;
 };
-type EventStreamOptions = {
+export type EventStreamOptions = {
   headers?: HeadersInit;
   keepAlive?: SseKeepAliveOptions;
   signal?: AbortSignal;
 };
-declare class SseStreamClosedError extends Error {
+export declare class SseStreamClosedError extends Error {
   constructor(message?: string);
 }
-declare function formatSse(message: SseMessage): string;
-declare function formatSseText(message: SseTextMessage): string;
-declare function getLastEventId(request: Request): string | null;
-declare function eventStream(start: (stream: SseStream) => void | Promise<void>, options?: EventStreamOptions): Response;
-//#endregion
-export { EventStreamOptions, SseKeepAliveOptions, SseMessage, SseStream, SseStreamClosedError, SseTextMessage, eventStream, formatSse, formatSseText, getLastEventId };
+export declare function formatSse(message: SseMessage): string;
+export declare function formatSseText(message: SseTextMessage): string;
+export declare function getLastEventId(request: Request): string | null;
+export declare function eventStream(start: (stream: SseStream) => void | Promise<void>, options?: EventStreamOptions): Response;
+//#endregion

package/dist/runtime/storage.d.mts

@@ -1,7 +1,6 @@
 //#region src/runtime/storage.d.ts
 /** Create a storage client for a specific R2Bucket instance. */
-declare function createStorage(bucket: R2Bucket): R2Bucket;
+export declare function createStorage(bucket: R2Bucket): R2Bucket;
 /** Default storage client — resolves `STORAGE` from the active runtime environment. */
-declare const storage: R2Bucket;
-//#endregion
-export { createStorage, storage };
+export declare const storage: R2Bucket;
+//#endregion

package/dist/runtime/validator.d.mts

@@ -1,2 +1,2 @@
-import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-Cjh8uM3Y.mjs";
+import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-D1hLsObx.mjs";
 export { HandlerInput, ValidatorSlots, runValidation };

package/dist/runtime/ws-server.d.mts

@@ -1,26 +1,26 @@
-import { n as AuthState } from "../auth-qgMlYp7Z.mjs";
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-DealXecJ.mjs";
+import { n as AuthState } from "../auth-DkcFflXV.mjs";
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-DSCeohOK.mjs";
 import { AnyWebSocketDefinition } from "./ws.mjs";
-
 //#region src/runtime/ws-server.d.ts
-type WebSocketRouteMeta = {
+export type WebSocketRouteMeta = {
   pattern: string;
   params: Array<string>;
   className: string;
   bindingName: string;
 };
-type WebSocketDurableObjectInstance = {
+export type WebSocketDurableObjectInstance = {
   fetch(request: Request): Promise<Response>;
   webSocketMessage(webSocket: WebSocket, message: string | ArrayBuffer | ArrayBufferView): Promise<void>;
   webSocketClose(webSocket: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
 };
-type WebSocketDurableObjectClass = {
+export type WebSocketDurableObjectClass = {
   new (state: DurableObjectState, env: Record<string, unknown>): WebSocketDurableObjectInstance;
 };
 type ResolveVoidAuthState = (request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions) => Promise<AuthState | null>;
-declare function buildWebSocketInstanceId(route: Pick<WebSocketRouteMeta, "params">, params: Record<string, string>): string;
-declare function createWebSocketDurableObject(definition: AnyWebSocketDefinition, route: WebSocketRouteMeta, authRuntime?: VoidAuthRuntimeOptions, resolveAuthState?: ResolveVoidAuthState): WebSocketDurableObjectClass;
-declare function handleWebSocketUpgrade(request: Request, env: Record<string, unknown>, routes: Array<WebSocketRouteMeta>): Promise<Response | null>;
-declare function forwardWebSocketRequest(request: Request, env: Record<string, unknown>, route: WebSocketRouteMeta): Promise<Response>;
-//#endregion
-export { WebSocketDurableObjectClass, WebSocketDurableObjectInstance, WebSocketRouteMeta, buildWebSocketInstanceId, createWebSocketDurableObject, forwardWebSocketRequest, handleWebSocketUpgrade };
+export declare function buildWebSocketInstanceId(route: Pick<WebSocketRouteMeta, "params">, params: Record<string, string>): string;
+export declare function createWebSocketDurableObject(definition: AnyWebSocketDefinition, route: WebSocketRouteMeta, authRuntime?: VoidAuthRuntimeOptions, resolveAuthState?: ResolveVoidAuthState): WebSocketDurableObjectClass;
+/** Keep a removed WebSocket Durable Object class deployable without deleting its storage. */
+export declare function createWebSocketTombstoneDurableObject(className: string): WebSocketDurableObjectClass;
+export declare function handleWebSocketUpgrade(request: Request, env: Record<string, unknown>, routes: Array<WebSocketRouteMeta>): Promise<Response | null>;
+export declare function forwardWebSocketRequest(request: Request, env: Record<string, unknown>, route: WebSocketRouteMeta): Promise<Response>;
+//#endregion

package/dist/runtime/ws-server.mjs

@@ -1,4 +1,5 @@
 import { authContext } from "./auth.mjs";
+import { withRuntimeEnv } from "./env.mjs";
 //#region src/runtime/ws-server.ts
 function matchRoute(pattern, pathname) {
 	const patternSegments = pattern.split("/").filter(Boolean);
@@ -170,7 +171,10 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 			this.state = state;
 			this.env = env;
 		}
-		async fetch(request) {
+		fetch(request) {
+			return withRuntimeEnv(this.env, () => this.handleFetch(request));
+		}
+		async handleFetch(request) {
 			const params = getRouteMatch(request, route) ?? {};
 			const roomId = buildWebSocketInstanceId(route, params);
 			const authState = authRuntime && resolveAuthState ? await resolveAuthState(request, this.env, authRuntime) : null;
@@ -226,7 +230,10 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 			const ctx = createSocketContext(this.state, this.env, request, fakeSocket, stored, definition.messages.server);
 			return withAuthState(authState, () => definition.onRequest(ctx));
 		}
-		async webSocketMessage(webSocket, message) {
+		webSocketMessage(webSocket, message) {
+			return withRuntimeEnv(this.env, () => this.handleWebSocketMessage(webSocket, message));
+		}
+		async handleWebSocketMessage(webSocket, message) {
 			const stored = getStoredConnection(webSocket);
 			const raw = parseIncomingMessage(message);
 			let parsed;
@@ -250,7 +257,10 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 				await withAuthState(stored.authState ?? null, () => definition.onMessage?.(ctx, result.value));
 			}
 		}
-		async webSocketClose(webSocket, code, reason, wasClean) {
+		webSocketClose(webSocket, code, reason, wasClean) {
+			return withRuntimeEnv(this.env, () => this.handleWebSocketClose(webSocket, code, reason, wasClean));
+		}
+		async handleWebSocketClose(webSocket, code, reason, wasClean) {
 			const stored = getStoredConnection(webSocket);
 			const request = new Request(`https://void.local${route.pattern}`);
 			if (definition.__kind === "room") {
@@ -272,6 +282,24 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 	}
 	return VoidWebSocketDurableObject;
 }
+/** Keep a removed WebSocket Durable Object class deployable without deleting its storage. */
+function createWebSocketTombstoneDurableObject(className) {
+	return class VoidWebSocketTombstoneDurableObject {
+		state;
+		env;
+		constructor(state, env) {
+			this.state = state;
+			this.env = env;
+		}
+		async fetch() {
+			return new Response(`WebSocket route ${className} has been removed.`, { status: 410 });
+		}
+		async webSocketMessage(webSocket) {
+			webSocket.close(1012, "WebSocket route removed");
+		}
+		async webSocketClose() {}
+	};
+}
 function getStub(env, route, params) {
 	const binding = env[route.bindingName];
 	if (!binding) return null;
@@ -295,4 +323,4 @@ async function forwardWebSocketRequest(request, env, route) {
 	return stub.fetch(request);
 }
 //#endregion
-export { buildWebSocketInstanceId, createWebSocketDurableObject, forwardWebSocketRequest, handleWebSocketUpgrade };
+export { buildWebSocketInstanceId, createWebSocketDurableObject, createWebSocketTombstoneDurableObject, forwardWebSocketRequest, handleWebSocketUpgrade };