void 0.10.13 → 0.20.1

package/dist/runtime/ai.mjs

@@ -1,4 +1,4 @@
-import { t as cfAccessHeaders } from "../cf-access-Bqw81xAf.mjs";
+import { t as cfAccessHeaders } from "../cf-access-AJ1ehiFR.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 */
@@ -283,9 +283,10 @@ function resolveBackend() {
 	const token = runtimeEnv.__VOID_TOKEN;
 	const projectId = runtimeEnv.__VOID_PROJECT_ID;
 	if (typeof token === "string" && typeof projectId === "string") return makeHttpBackend(token, projectId, runtimeEnv);
-	const directAi = runtimeEnv.AI;
+	const aiBindingName = typeof runtimeEnv.__VOID_AI_BINDING === "string" ? runtimeEnv.__VOID_AI_BINDING : "AI";
+	const directAi = runtimeEnv[aiBindingName];
 	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.");
+	throw new Error(`ai: Not available. Run \`void auth login\` and \`void project link\` first, or bind Workers AI (env.${aiBindingName}) for self-hosted deploys.`);
 }
 function unsupported(method) {
 	return () => {
@@ -381,7 +382,7 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 	const headers = {
 		"content-type": "application/json",
 		authorization: `Bearer ${token}`,
-		...cfAccessHeaders(runtimeEnv)
+		...cfAccessHeaders(runtimeEnv, base)
 	};
 	async function proxyFetch(action, body, options = {}) {
 		const res = await fetch(`${base}/${action}`, {

package/dist/runtime/auth-client-react.d.mts

@@ -1,8 +1,6 @@
 import { createAuthClient as createAuthClient$1 } from "better-auth/react";
-
 //#region src/runtime/auth-client-react.d.ts
-declare const createAuthClient: typeof createAuthClient$1;
+export declare const createAuthClient: typeof createAuthClient$1;
 type BetterAuthClientInstance = ReturnType<typeof createAuthClient>;
-declare const auth: BetterAuthClientInstance;
-//#endregion
-export { auth, createAuthClient };
+export declare const auth: BetterAuthClientInstance;
+//#endregion

package/dist/runtime/auth-client-solid.d.mts

@@ -1,8 +1,6 @@
 import { createAuthClient as createAuthClient$1 } from "better-auth/solid";
-
 //#region src/runtime/auth-client-solid.d.ts
-declare const createAuthClient: typeof createAuthClient$1;
+export declare const createAuthClient: typeof createAuthClient$1;
 type BetterAuthClientInstance = ReturnType<typeof createAuthClient>;
-declare const auth: BetterAuthClientInstance;
-//#endregion
-export { auth, createAuthClient };
+export declare const auth: BetterAuthClientInstance;
+//#endregion

package/dist/runtime/auth-client-svelte.d.mts

@@ -1,8 +1,6 @@
 import { createAuthClient as createAuthClient$1 } from "better-auth/svelte";
-
 //#region src/runtime/auth-client-svelte.d.ts
-declare const createAuthClient: typeof createAuthClient$1;
+export declare const createAuthClient: typeof createAuthClient$1;
 type BetterAuthClientInstance = ReturnType<typeof createAuthClient>;
-declare const auth: BetterAuthClientInstance;
-//#endregion
-export { auth, createAuthClient };
+export declare const auth: BetterAuthClientInstance;
+//#endregion

package/dist/runtime/auth-client-vue.d.mts

@@ -1,8 +1,6 @@
 import { createAuthClient as createAuthClient$1 } from "better-auth/vue";
-
 //#region src/runtime/auth-client-vue.d.ts
-declare const createAuthClient: typeof createAuthClient$1;
+export declare const createAuthClient: typeof createAuthClient$1;
 type BetterAuthClientInstance = ReturnType<typeof createAuthClient>;
-declare const auth: BetterAuthClientInstance;
-//#endregion
-export { auth, createAuthClient };
+export declare const auth: BetterAuthClientInstance;
+//#endregion

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

@@ -1,8 +1,6 @@
 import { createAuthClient as createAuthClient$1 } from "better-auth/client";
-
 //#region src/runtime/auth-client.d.ts
-declare const createAuthClient: typeof createAuthClient$1;
+export declare const createAuthClient: typeof createAuthClient$1;
 type BetterAuthClientInstance = ReturnType<typeof createAuthClient>;
-declare const auth: BetterAuthClientInstance;
-//#endregion
-export { auth, createAuthClient };
+export declare const auth: BetterAuthClientInstance;
+//#endregion

package/dist/runtime/auth.d.mts

@@ -1,2 +1,2 @@
-import { a as VoidAuthConfigContext, c as getSession, i as VoidAuthConfig, l as getUser, n as AuthState, o as authContext, r as AuthUser, s as defineAuth, t as AuthSession, u as requireAuth } from "../auth-qgMlYp7Z.mjs";
+import { a as VoidAuthConfigContext, c as getSession, i as VoidAuthConfig, l as getUser, n as AuthState, o as authContext, r as AuthUser, s as defineAuth, t as AuthSession, u as requireAuth } from "../auth-DkcFflXV.mjs";
 export { AuthSession, AuthState, AuthUser, VoidAuthConfig, VoidAuthConfigContext, authContext, defineAuth, getSession, getUser, requireAuth };

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

@@ -0,0 +1,10 @@
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DSCeohOK.mjs";
+//#region src/runtime/better-auth-mysql.d.ts
+export declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
+export declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
+export declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
+export declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
+export declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
+export declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
+//#endregion
+export type { VoidAuthDialect, VoidAuthEnv, VoidAuthRuntimeOptions };

package/dist/runtime/better-auth-mysql.mjs

@@ -0,0 +1,49 @@
+import { t as applyMySqlAuthMigrations } from "../auth-migrations-9vif1uj8.mjs";
+import { t as createVoidAuthRuntime } from "../better-auth-shared-CYw1T3k4.mjs";
+//#region src/runtime/better-auth-mysql.ts
+function resolveConnectionString(env) {
+	const connectionString = typeof env.DATABASE_URL === "string" && env.DATABASE_URL.length > 0 ? env.DATABASE_URL : typeof env.HYPERDRIVE?.connectionString === "string" && env.HYPERDRIVE.connectionString.length > 0 ? env.HYPERDRIVE.connectionString : void 0;
+	if (!connectionString) throw new Error("auth: Better Auth requires DATABASE_URL for local MySQL dev or HYPERDRIVE in production.");
+	return connectionString;
+}
+async function resolveDatabase(env) {
+	const { createPool } = await import("mysql2/promise");
+	const pool = createPool({
+		uri: resolveConnectionString(env),
+		connectionLimit: 1
+	});
+	return {
+		database: pool,
+		async dispose() {
+			await pool.end();
+		}
+	};
+}
+async function runMySqlAuthMigrations(_request, env, runtime, migrationSchema) {
+	if (!migrationSchema) throw new Error("auth: Migration schema is unavailable.");
+	if (runtime.dialect !== "mysql" || migrationSchema.dialect !== "mysql") throw new Error("auth: Runtime mismatch. Expected mysql.");
+	const { createConnection } = await import("mysql2/promise");
+	const connection = await createConnection(resolveConnectionString(env));
+	try {
+		await applyMySqlAuthMigrations({
+			async all(sql, params) {
+				const [rows] = await connection.query(sql, params);
+				return rows;
+			},
+			async run(sql, params) {
+				await connection.query(sql, params);
+			}
+		}, migrationSchema);
+	} finally {
+		await connection.end();
+	}
+}
+const runtime = createVoidAuthRuntime("mysql", resolveDatabase, runMySqlAuthMigrations);
+const resolveVoidAuthOptions = runtime.resolveVoidAuthOptions;
+const createVoidAuth = runtime.createVoidAuth;
+const resolveVoidAuthState = runtime.resolveVoidAuthState;
+const runVoidAuthMiddleware = runtime.runVoidAuthMiddleware;
+const handleVoidAuthRequest = runtime.handleVoidAuthRequest;
+const runVoidAuthMigrations = runtime.runVoidAuthMigrations;
+//#endregion
+export { createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };

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

@@ -1,11 +1,10 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DealXecJ.mjs";
-
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DSCeohOK.mjs";
 //#region src/runtime/better-auth-pg.d.ts
-declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
-declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
-declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
-declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
-declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
-declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
+export declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
+export declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
+export declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
+export declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
+export declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
+export declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
 //#endregion
-export { type VoidAuthDialect, type VoidAuthEnv, type VoidAuthRuntimeOptions, createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };
+export type { VoidAuthDialect, VoidAuthEnv, VoidAuthRuntimeOptions };

package/dist/runtime/better-auth-pg.mjs

@@ -1,5 +1,5 @@
-import { t as applyPgAuthMigrations } from "../auth-migrations-BTZ-ATvQ.mjs";
-import { t as createVoidAuthRuntime } from "../better-auth-shared-BQooDxbw.mjs";
+import { n as applyPgAuthMigrations } from "../auth-migrations-9vif1uj8.mjs";
+import { t as createVoidAuthRuntime } from "../better-auth-shared-CYw1T3k4.mjs";
 import { t as disablePgPassFallback } from "../pg-J2HbZIkX.mjs";
 //#region src/runtime/better-auth-pg.ts
 function resolveConnectionString(env) {

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

@@ -1,11 +1,10 @@
-import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DealXecJ.mjs";
-
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-DSCeohOK.mjs";
 //#region src/runtime/better-auth.d.ts
-declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
-declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
-declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
-declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
-declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
-declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
+export declare const resolveVoidAuthOptions: VoidAuthRuntimeApi["resolveVoidAuthOptions"];
+export declare const createVoidAuth: VoidAuthRuntimeApi["createVoidAuth"];
+export declare const resolveVoidAuthState: VoidAuthRuntimeApi["resolveVoidAuthState"];
+export declare const runVoidAuthMiddleware: VoidAuthRuntimeApi["runVoidAuthMiddleware"];
+export declare const handleVoidAuthRequest: VoidAuthRuntimeApi["handleVoidAuthRequest"];
+export declare const runVoidAuthMigrations: VoidAuthRuntimeApi["runVoidAuthMigrations"];
 //#endregion
-export { type VoidAuthDialect, type VoidAuthEnv, type VoidAuthRuntimeOptions, createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };
+export type { VoidAuthDialect, VoidAuthEnv, VoidAuthRuntimeOptions };

package/dist/runtime/better-auth.mjs

@@ -1,5 +1,5 @@
-import { n as applySqliteAuthMigrations } from "../auth-migrations-BTZ-ATvQ.mjs";
-import { t as createVoidAuthRuntime } from "../better-auth-shared-BQooDxbw.mjs";
+import { r as applySqliteAuthMigrations } from "../auth-migrations-9vif1uj8.mjs";
+import { t as createVoidAuthRuntime } from "../better-auth-shared-CYw1T3k4.mjs";
 //#region src/runtime/better-auth.ts
 async function resolveDatabase(env) {
 	if (!env.DB) throw new Error("auth: Better Auth requires the \"DB\" D1 binding for sqlite apps.");

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

@@ -1,4 +1,4 @@
-import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-qgMlYp7Z.mjs";
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-DkcFflXV.mjs";
 import { auth, createAuthClient } from "./auth-client-react.mjs";
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { fetch } from "./fetch.mjs";

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

@@ -1,4 +1,4 @@
-import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-qgMlYp7Z.mjs";
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-DkcFflXV.mjs";
 import { auth, createAuthClient } from "./auth-client-solid.mjs";
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { fetch } from "./fetch.mjs";

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

@@ -1,4 +1,4 @@
-import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-qgMlYp7Z.mjs";
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-DkcFflXV.mjs";
 import { auth, createAuthClient } from "./auth-client-svelte.mjs";
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { fetch } from "./fetch.mjs";

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

@@ -1,4 +1,4 @@
-import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-qgMlYp7Z.mjs";
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-DkcFflXV.mjs";
 import { auth, createAuthClient } from "./auth-client-vue.mjs";
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { fetch } from "./fetch.mjs";

package/dist/runtime/client.d.mts

@@ -1,4 +1,4 @@
-import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-qgMlYp7Z.mjs";
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-DkcFflXV.mjs";
 import { auth, createAuthClient } from "./auth-client.mjs";
 import { t as FetchError } from "../fetch-error-Sp1R4mZv.mjs";
 import { fetch } from "./fetch.mjs";

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

@@ -0,0 +1,2 @@
+import { MySql2Database } from "drizzle-orm/mysql2";
+export type { MySql2Database };

package/dist/runtime/db-mysql.mjs

@@ -0,0 +1 @@
+export {};

package/dist/runtime/db.d.mts

@@ -1,17 +1,16 @@
 import { DrizzleD1Database, DrizzleD1Database as DrizzleD1Database$1 } from "drizzle-orm/d1";
 import { and, asc, avg, between, count, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum } from "drizzle-orm";
-
 //#region src/runtime/db.d.ts
 /**
-* Create a Drizzle D1 instance from a custom D1 binding.
-* Use this when you have multiple D1 databases or need a non-default binding.
-*/
-declare function createDb(d1: D1Database): DrizzleD1Database$1;
+ * Create a Drizzle D1 instance from a custom D1 binding.
+ * Use this when you have multiple D1 databases or need a non-default binding.
+ */
+export declare function createDb(d1: D1Database): DrizzleD1Database$1;
 /**
-* Default Drizzle D1 instance — resolves the `DB` binding from the runtime
-* environment. When the Void plugin is active, this is replaced with a
-* schema-aware instance via virtual module.
-*/
-declare const db: DrizzleD1Database$1;
+ * Default Drizzle D1 instance — resolves the `DB` binding from the runtime
+ * environment. When the Void plugin is active, this is replaced with a
+ * schema-aware instance via virtual module.
+ */
+export declare const db: DrizzleD1Database$1;
 //#endregion
-export { type DrizzleD1Database, and, asc, avg, between, count, createDb, db, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum };
+export { type DrizzleD1Database, and, asc, avg, between, count, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum };

package/dist/runtime/durable.d.mts

@@ -0,0 +1,47 @@
+//#region src/runtime/durable.d.ts
+export type DurableStateContext<TState, TEnv extends Record<string, unknown>> = {
+  state: TState;
+  readonly env: TEnv;
+  readonly id: DurableObjectId;
+  readonly storage: DurableObjectStorage;
+  setAlarm(scheduledTime: number | Date): Promise<void>;
+  deleteAlarm(): Promise<void>;
+};
+export type DurableStateMethod<TState, TEnv extends Record<string, unknown>, TArgs extends Array<unknown> = Array<unknown>, TResult = unknown> = (context: DurableStateContext<TState, TEnv>, ...args: TArgs) => TResult | Promise<TResult>;
+export type DurableStateMethods<TState, TEnv extends Record<string, unknown>> = Record<string, DurableStateMethod<TState, TEnv, Array<never>, unknown>>;
+export type DurableStateMigration<TState> = {
+  /** State version produced by this migration. Versions must be contiguous and start at 1. */
+  version: number;
+  migrate(state: unknown): TState | Promise<TState>;
+};
+type MethodArguments<TMethod> = TMethod extends ((context: infer _TContext, ...args: infer TArgs) => infer _TResult) ? TArgs : never;
+type MethodResult<TMethod> = TMethod extends ((...args: infer _TArgs) => infer TResult) ? Awaited<TResult> : never;
+export type DurableStateRpc<TMethods> = { [TName in keyof TMethods]: (...args: MethodArguments<TMethods[TName]>) => Promise<MethodResult<TMethods[TName]>>; };
+export type TypedDurableObjectStub<TMethods> = DurableObjectStub & DurableStateRpc<TMethods>;
+export type DurableStateClass<TMethods> = {
+  new (state: DurableObjectState, env: Record<string, unknown>): DurableObject & DurableStateRpc<TMethods> & {
+    fetch(request: Request): Promise<Response>;
+    alarm(): Promise<void>;
+  };
+};
+export type DurableStateDefinition<TState, TEnv extends Record<string, unknown>, TMethods extends DurableStateMethods<TState, TEnv>> = {
+  initialState: TState | ((env: TEnv) => TState | Promise<TState>);
+  /** Current persisted state version. Defaults to 0. */
+  version?: number;
+  migrations?: ReadonlyArray<DurableStateMigration<TState>>;
+  methods: TMethods;
+  fetch?: DurableStateMethod<TState, TEnv, [request: Request], Response>;
+  alarm?: DurableStateMethod<TState, TEnv, [], void>;
+  storageKey?: string;
+};
+export type DurableStateApi<TMethods> = {
+  class: DurableStateClass<TMethods>;
+  /** @internal Called by Void's generated worker entry. */
+  __bind(bindingName: string): void;
+  get(name: string): TypedDurableObjectStub<TMethods>;
+  get(namespace: DurableObjectNamespace, name: string): TypedDurableObjectStub<TMethods>;
+  getById(id: DurableObjectId): TypedDurableObjectStub<TMethods>;
+  getById(namespace: DurableObjectNamespace, id: DurableObjectId): TypedDurableObjectStub<TMethods>;
+};
+export declare function defineDurableState<TState, TEnv extends Record<string, unknown> = Record<string, unknown>, const TMethods extends DurableStateMethods<TState, TEnv> = DurableStateMethods<TState, TEnv>>(definition: DurableStateDefinition<TState, TEnv, TMethods>): DurableStateApi<TMethods>;
+//#endregion

package/dist/runtime/durable.mjs

@@ -0,0 +1,146 @@
+import { requireRuntimeBinding, withRuntimeEnv } from "./env.mjs";
+import { DurableObject } from "cloudflare:workers";
+//#region src/runtime/durable.ts
+const DEFAULT_STORAGE_KEY = "__void_durable_state";
+function cloneInitialState(state) {
+	return structuredClone(state);
+}
+function assertMigrations(version, migrations) {
+	const byVersion = /* @__PURE__ */ new Map();
+	for (const migration of migrations) {
+		if (!Number.isInteger(migration.version) || migration.version < 1) throw new Error("durable: migration versions must be positive integers.");
+		if (migration.version > version) throw new Error(`durable: migration version ${migration.version} exceeds the current state version ${version}.`);
+		if (byVersion.has(migration.version)) throw new Error(`durable: duplicate migration version ${migration.version}.`);
+		byVersion.set(migration.version, migration);
+	}
+	for (let expected = 1; expected <= version; expected++) if (!byVersion.has(expected)) throw new Error(`durable: missing state migration for version ${expected}.`);
+	return byVersion;
+}
+function defineDurableState(definition) {
+	const version = definition.version ?? 0;
+	if (!Number.isInteger(version) || version < 0) throw new Error("durable: version must be a non-negative integer.");
+	const migrations = assertMigrations(version, definition.migrations ?? []);
+	const storageKey = definition.storageKey ?? DEFAULT_STORAGE_KEY;
+	let bindingName;
+	function boundNamespace() {
+		if (!bindingName) throw new Error("durable: this state definition is not bound. Default-export it from a file in durable-objects/.");
+		return requireRuntimeBinding(bindingName);
+	}
+	class VoidDurableState extends DurableObject {
+		#value;
+		#ready;
+		#queue = Promise.resolve();
+		#objectState;
+		#runtimeEnv;
+		constructor(objectState, env) {
+			super(objectState, env);
+			this.#objectState = objectState;
+			this.#runtimeEnv = env;
+			this.#ready = objectState.blockConcurrencyWhile(() => withRuntimeEnv(this.#runtimeEnv, () => this.#load()));
+		}
+		async #load() {
+			const stored = await this.#objectState.storage.get(storageKey);
+			if (!stored) {
+				const initial = typeof definition.initialState === "function" ? await definition.initialState(this.#runtimeEnv) : cloneInitialState(definition.initialState);
+				this.#value = initial;
+				await this.#persist();
+				return;
+			}
+			if (stored.__voidDurableState !== true || !Number.isInteger(stored.version)) throw new Error(`durable: invalid state record at storage key '${storageKey}'.`);
+			if (stored.version > version) throw new Error(`durable: stored state version ${stored.version} is newer than supported version ${version}.`);
+			let value = stored.value;
+			for (let nextVersion = stored.version + 1; nextVersion <= version; nextVersion++) {
+				const migration = migrations.get(nextVersion);
+				if (!migration) throw new Error(`durable: missing state migration for version ${nextVersion}.`);
+				value = await migration.migrate(value);
+			}
+			this.#value = value;
+			if (stored.version !== version) await this.#persist();
+		}
+		#persist() {
+			return this.#objectState.storage.put(storageKey, {
+				__voidDurableState: true,
+				version,
+				value: this.#value
+			});
+		}
+		#context() {
+			const instance = this;
+			return {
+				get state() {
+					return instance.#value;
+				},
+				set state(value) {
+					instance.#value = value;
+				},
+				env: this.#runtimeEnv,
+				id: this.#objectState.id,
+				storage: this.#objectState.storage,
+				setAlarm: (scheduledTime) => this.#objectState.storage.setAlarm(scheduledTime),
+				deleteAlarm: () => this.#objectState.storage.deleteAlarm()
+			};
+		}
+		#run(operation) {
+			return withRuntimeEnv(this.#runtimeEnv, () => {
+				const result = this.#queue.then(async () => {
+					await this.#ready;
+					const previousValue = structuredClone(this.#value);
+					try {
+						const operationResult = await operation();
+						await this.#persist();
+						return operationResult;
+					} catch (error) {
+						this.#value = previousValue;
+						throw error;
+					}
+				});
+				this.#queue = result.then(() => void 0, () => void 0);
+				return result;
+			});
+		}
+		fetch(request) {
+			if (!definition.fetch) return Promise.resolve(new Response("Not Found", { status: 404 }));
+			return this.#run(async () => {
+				return definition.fetch(this.#context(), request);
+			});
+		}
+		alarm() {
+			if (!definition.alarm) return Promise.resolve();
+			return this.#run(async () => {
+				await definition.alarm(this.#context());
+			});
+		}
+		static {
+			for (const [name, method] of Object.entries(definition.methods)) {
+				if (name === "fetch" || name === "alarm" || name === "constructor") throw new Error(`durable: method name '${name}' is reserved.`);
+				Object.defineProperty(this.prototype, name, {
+					enumerable: false,
+					value(...args) {
+						return this.#run(async () => {
+							return method(this.#context(), ...args);
+						});
+					}
+				});
+			}
+		}
+	}
+	return {
+		class: VoidDurableState,
+		__bind(name) {
+			if (bindingName && bindingName !== name) throw new Error(`durable: state definition is already bound to '${bindingName}' and cannot also bind to '${name}'.`);
+			bindingName = name;
+		},
+		get(namespaceOrName, maybeName) {
+			const namespace = typeof namespaceOrName === "string" ? boundNamespace() : namespaceOrName;
+			const name = typeof namespaceOrName === "string" ? namespaceOrName : maybeName;
+			return namespace.get(namespace.idFromName(name));
+		},
+		getById(namespaceOrId, maybeId) {
+			const namespace = maybeId ? namespaceOrId : boundNamespace();
+			const id = maybeId ?? namespaceOrId;
+			return namespace.get(id);
+		}
+	};
+}
+//#endregion
+export { defineDurableState };

package/dist/runtime/email/testing.d.mts

@@ -0,0 +1,112 @@
+/// <reference types="@cloudflare/workers-types" />
+import { r as EmailHandler } from "../../inbound-afAcWeQ9.mjs";
+//#region src/runtime/email/dev-inbox.d.ts
+interface CapturedMessage {
+  id: string;
+  capturedAt: number;
+  raw: Uint8Array;
+  messageId: string;
+  from: {
+    email: string;
+    name?: string;
+  };
+  to: Array<{
+    email: string;
+    name?: string;
+  }>;
+  cc: Array<{
+    email: string;
+    name?: string;
+  }>;
+  bcc: Array<{
+    email: string;
+    name?: string;
+  }>;
+  replyTo?: {
+    email: string;
+    name?: string;
+  };
+  subject: string;
+  text?: string;
+  html?: string;
+  headers: Record<string, string>;
+  attachments: Array<{
+    filename: string;
+    contentType: string;
+    size: number;
+    contentId?: string;
+    disposition: "attachment" | "inline";
+  }>;
+}
+//#endregion
+//#region src/runtime/email/testing.d.ts
+export interface EmailTestHarness {
+  /** Messages captured since the harness was created (or since the last clear). */
+  readonly messages: ReadonlyArray<CapturedMessage>;
+  /** Discard captured messages. */
+  clear(): void;
+  /** Stop intercepting sends. After dispose, real binding sends resume. */
+  dispose(): void;
+}
+export declare function createEmailTestHarness(): EmailTestHarness;
+export interface InboundDeliverOptions {
+  from: string;
+  to: string;
+  subject?: string;
+  text?: string;
+  html?: string;
+  headers?: Record<string, string>;
+  /** Override the constructed MIME body. Bytes preferred; strings encoded as UTF-8. */
+  raw?: string | Uint8Array;
+}
+export interface InboundReplyCapture {
+  from: string;
+  to: string;
+  raw: Uint8Array;
+}
+export interface InboundForwardCapture {
+  to: string;
+  headers?: Headers;
+}
+export interface InboundDeliveryResult {
+  /** Which handler key matched. `undefined` if the message was not handled. */
+  handler?: string;
+  params: Record<string, string>;
+}
+export interface InboundTestHarness {
+  readonly replies: ReadonlyArray<InboundReplyCapture>;
+  readonly forwards: ReadonlyArray<InboundForwardCapture>;
+  readonly rejects: ReadonlyArray<string>;
+  readonly deliveries: ReadonlyArray<InboundDeliveryResult>;
+  deliver(opts: InboundDeliverOptions): Promise<InboundDeliveryResult>;
+  clear(): void;
+}
+export interface InboundTestHarnessOptions {
+  /**
+   * Address pattern → handler. Pattern syntax matches the file-based
+   * convention: `support`, `support+[ticket]`, `[user]`, `[user]+[tag]`.
+   * Reserved key: `_default` (fallback handler, mirrors email/_default.ts).
+   */
+  routes: Record<string, EmailHandler>;
+  /** Forwarded as the second arg to handlers. Defaults to `{}`. */
+  env?: unknown;
+  /**
+   * Project slug used to strip the platform-injected `<slug>+` prefix from
+   * `message.to` before handlers see it (mirrors production: the dispatched
+   * `message.to` is `<tag>@<domain>`, never `<slug>+<tag>@<domain>`). When
+   * omitted, the harness infers the slug from each delivery's recipient
+   * (everything before the first `+` in the local-part) so existing tests
+   * with synthetic `slug+tag@domain` recipients keep working without
+   * configuration.
+   *
+   * `null` means NO platform prefix at all — a worker deployed on your own
+   * Cloudflare account (`void deploy --platform cloudflare`) receives the
+   * address the handler author wrote, and the dispatcher matches the full
+   * local part: `support@mail.acme.com` reaches `support`, and
+   * `support+T-42@mail.acme.com` reaches `support+[ticket]` with `T-42`.
+   */
+  slug?: string | null;
+}
+export declare function createInboundTestHarness(opts: InboundTestHarnessOptions): InboundTestHarness;
+//#endregion
+export type { CapturedMessage };