void 0.25.0 → 0.26.1

package/dist/{requests-B3PBuGlX.mjs → requests-DFAqyYy8.mjs}

@@ -1,8 +1,8 @@
-import { r as readProjectConfig } from "./project-BkbfDs0V.mjs";
-import { c as getToken } from "./auth-7wuZ5ob8.mjs";
-import { H as outro, L as log } from "./prompts-6OSVA7DJ.mjs";
-import { r as PlatformClient } from "./client-RsPo8wsP.mjs";
-import { c as import_picocolors, i as dim } from "./output-BBsUwdyT.mjs";
+import { r as readProjectConfig } from "./project-DQstYTxO.mjs";
+import { c as getToken } from "./auth-B5_tZLxT.mjs";
+import { H as outro, L as log } from "./dist-D3m88sjf.mjs";
+import { i as dim, l as import_picocolors } from "./output-C50ag2r3.mjs";
+import { r as PlatformClient } from "./client-C2Prx_Bi.mjs";
 //#region src/cli/requests.ts
 async function runRequestsCommand(root, range, status) {
 	console.log();

package/dist/resolve-project-BIeYs9Cw.mjs

@@ -0,0 +1,2 @@
+import { n as inferDefaultSlug } from "./resolve-project-CP8rZs_p.mjs";
+export { inferDefaultSlug };

package/dist/{resolve-project-BG5ORGID.mjs → resolve-project-CP8rZs_p.mjs}

@@ -15,9 +15,14 @@ function resolveProjectBySlug(projects, slug) {
 		slug: project.slug
 	} : null;
 }
+async function requireProjectBySlug(client, slug) {
+	const project = resolveProjectBySlug(await client.listProjects(), slug);
+	if (!project) throw new Error(`project: No project found with slug '${slug}'.`);
+	return project;
+}
 function inferDefaultSlug(root) {
 	const pkgPath = join(root, "package.json");
 	return (JSON.parse(readFileSync(pkgPath, "utf-8")).name ?? "my-app").replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]/g, "-");
 }
 //#endregion
-export { inferDefaultSlug as n, resolveProjectBySlug as r, getRequestedProjectSlug as t };
+export { resolveProjectBySlug as i, inferDefaultSlug as n, requireProjectBySlug as r, getRequestedProjectSlug as t };

package/dist/{rollback-DDub9GsO.mjs → rollback-BKYXBduI.mjs}

@@ -1,8 +1,8 @@
-import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-BkbfDs0V.mjs";
-import { c as getToken } from "./auth-7wuZ5ob8.mjs";
-import { A as confirm, H as outro, K as select, L as log, O as cancel, tt as isCancel } from "./prompts-6OSVA7DJ.mjs";
-import { r as PlatformClient } from "./client-RsPo8wsP.mjs";
-import { a as ensureUtc, c as import_picocolors, i as dim, o as formatCount, r as createSpinner } from "./output-BBsUwdyT.mjs";
+import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-DQstYTxO.mjs";
+import { c as getToken } from "./auth-B5_tZLxT.mjs";
+import { A as confirm, H as outro, K as select, L as log, O as cancel, tt as isCancel } from "./dist-D3m88sjf.mjs";
+import { a as ensureUtc, d as printSuccess, i as dim, r as createSpinner, s as formatCount } from "./output-C50ag2r3.mjs";
+import { r as PlatformClient } from "./client-C2Prx_Bi.mjs";
 //#region src/cli/rollback.ts
 async function runRollbackCommand(root, deployId) {
 	console.log();
@@ -54,23 +54,16 @@ async function runRollbackCommand(root, deployId) {
 	const currentMigrations = active?.applied_migrations ? JSON.parse(active.applied_migrations) : [];
 	const targetMigrations = target.applied_migrations ? JSON.parse(target.applied_migrations) : [];
 	const migrationDiff = currentMigrations.filter((m) => !targetMigrations.includes(m));
-	if (migrationDiff.length > 0) {
-		log.warn(`The current database has ${formatCount(migrationDiff.length, "migration")} applied after this deployment:`);
-		for (const m of migrationDiff) log.message(`  ${dim("•")} ${m}`);
-		log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
-		const proceed = await confirm({ message: "Proceed with rollback?" });
-		if (isCancel(proceed) || !proceed) {
-			cancel("Rollback cancelled.");
-			process.exit(0);
-		}
-	}
+	await confirmUnrevertedMigrations(migrationDiff, "deployment");
 	const s = createSpinner();
 	s.start("Rolling back...");
 	try {
 		const result = await client.rollback(linked.projectId, targetId, { allowDestructive: migrationDiff.length > 0 ? migrationDiff : void 0 });
 		s.stop("Rollback complete.");
-		if (result.ok) log.success(`Rolled back to ${import_picocolors.default.bold(targetId)}`);
-		else {
+		if (result.ok) {
+			log.info("Traffic is now serving the rolled-back deployment.");
+			printSuccess(`Rolled back to ${targetId}.`);
+		} else {
 			log.error(result.error ?? "Rollback failed.");
 			process.exit(1);
 		}
@@ -79,10 +72,9 @@ async function runRollbackCommand(root, deployId) {
 		log.error(err instanceof Error ? err.message : String(err));
 		process.exit(1);
 	}
-	outro(dim("Traffic is now serving the rolled-back deployment."));
 }
 async function runCloudflareRollback(root, deployId) {
-	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BhbK6yTq.mjs");
+	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BlYLlowZ.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	const status = await readCloudflareWorkerStatus(context);
 	const deployedVersionIds = new Set(status.deployedVersionIds);
@@ -121,24 +113,10 @@ async function runCloudflareRollback(root, deployId) {
 	if (target.metadata?.schema !== 2 || current?.metadata?.schema !== 2 || target.metadata.triggerConfig.preserve || current.metadata.triggerConfig.preserve) log.info("This rollback keeps the current domains, routes, and schedules. The selected version has no complete trigger snapshot.");
 	if (!current?.metadata || !target.metadata) {
 		log.warn("Void migration metadata is unavailable for one of these versions. Database migrations are forward-only and will not be reverted.");
-		const proceed = await confirm({ message: "Proceed with rollback?" });
-		if (isCancel(proceed) || !proceed) {
-			cancel("Rollback cancelled.");
-			process.exit(0);
-		}
+		await confirmRollbackOrExit();
 	} else {
 		const targetSet = new Set(target.metadata.migrations);
-		const migrationDiff = current.metadata.migrations.filter((migration) => !targetSet.has(migration));
-		if (migrationDiff.length > 0) {
-			log.warn(`The current database has ${formatCount(migrationDiff.length, "migration")} applied after this version:`);
-			for (const migration of migrationDiff) log.message(`  ${dim("•")} ${migration}`);
-			log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
-			const proceed = await confirm({ message: "Proceed with rollback?" });
-			if (isCancel(proceed) || !proceed) {
-				cancel("Rollback cancelled.");
-				process.exit(0);
-			}
-		}
+		await confirmUnrevertedMigrations(current.metadata.migrations.filter((migration) => !targetSet.has(migration)), "version");
 	}
 	const spinner = createSpinner();
 	spinner.start("Rolling back...");
@@ -150,8 +128,23 @@ async function runCloudflareRollback(root, deployId) {
 		log.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
-	log.success(`Rolled back to ${import_picocolors.default.bold(target.id)}`);
-	outro(dim("Traffic is now serving the selected Cloudflare Worker Version."));
+	log.info("Traffic is now serving the selected Cloudflare Worker Version.");
+	printSuccess(`Rolled back to ${target.id}.`);
+}
+async function confirmRollbackOrExit() {
+	const proceed = await confirm({ message: "Proceed with rollback?" });
+	if (isCancel(proceed) || !proceed) {
+		cancel("Rollback cancelled.");
+		process.exit(0);
+	}
+}
+/** List migrations the rollback will not revert and ask before continuing. */
+async function confirmUnrevertedMigrations(migrationDiff, noun) {
+	if (migrationDiff.length === 0) return;
+	log.warn(`The current database has ${formatCount(migrationDiff.length, "migration")} applied after this ${noun}:`);
+	for (const migration of migrationDiff) log.message(`  ${dim("•")} ${migration}`);
+	log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
+	await confirmRollbackOrExit();
 }
 function formatAge(deployedAt) {
 	if (!deployedAt) return "";

package/dist/{route-types-Clm4WD0B.mjs → route-types-CbtsIeFn.mjs}

@@ -1,5 +1,5 @@
 import { a as join, l as relative } from "./dist-BVqXeR_h.mjs";
-import { r as writeFileIfChanged } from "./project-tsconfig-B8GeM0RM.mjs";
+import { r as writeFileIfChanged } from "./project-tsconfig-CVJhNMxs.mjs";
 import { mkdirSync } from "node:fs";
 //#region src/codegen/db-types.ts
 const DRIZZLE_OPERATORS = "sql, eq, ne, gt, gte, lt, lte, and, or, not, desc, asc, like, ilike, notLike, inArray, notInArray, isNull, isNotNull, between, notBetween, exists, notExists, count, sum, avg, min, max";

package/dist/route-url-BgPja1GS.d.mts

@@ -0,0 +1,5 @@
+//#region src/runtime/route-url.d.ts
+/** Expand complete route tokens without changing query strings or fragments. */
+declare function interpolateRouteParams(path: string, params?: Record<string, string>): string;
+//#endregion
+export { interpolateRouteParams as t };

package/dist/route-url-BjGv_KKY.mjs

@@ -0,0 +1,28 @@
+//#region src/runtime/route-url.ts
+/**
+* Encode one path segment of a route param. `encodeURIComponent` keeps dots, and
+* URL parsing resolves `.`/`..` (even as `%2e`), so such a segment would move the
+* request to another path instead of reaching this route.
+*/
+function encodeSegment(name, segment) {
+	if (segment === "." || segment === "..") throw new TypeError(`Route param "${name}" cannot be "${segment}"; it would change the request path.`);
+	return encodeURIComponent(segment);
+}
+/** Expand complete route tokens without changing query strings or fragments. */
+function interpolateRouteParams(path, params) {
+	if (!params) return path;
+	const suffixIndex = path.search(/[?#]/);
+	const pathname = suffixIndex === -1 ? path : path.slice(0, suffixIndex);
+	const suffix = suffixIndex === -1 ? "" : path.slice(suffixIndex);
+	let leadingName;
+	const replaced = pathname.replace(/(^|\/):([^/{}]+)(\{\.\+\})?(?=\/|$)/g, (token, prefix, name, catchAll, offset) => {
+		if (!Object.hasOwn(params, name)) return token;
+		if (offset === 0) leadingName = name;
+		const value = params[name];
+		return prefix + (catchAll ? value.split("/").map((segment) => encodeSegment(name, segment)).join("/") : encodeSegment(name, value));
+	});
+	if (replaced.startsWith("//") && !pathname.startsWith("//")) throw new TypeError(`Route param "${leadingName ?? ""}" would make the request path start with "//", which changes the request host.`);
+	return replaced + suffix;
+}
+//#endregion
+export { interpolateRouteParams as t };

package/dist/runner-9wjsSZx-.mjs

@@ -0,0 +1,2 @@
+import { a as runMigrations, i as openSqliteDatabase, n as getAppliedMigrations, r as getMiniflareDatabasePath, t as getApplicationTables } from "./runner-DMBKSrRk.mjs";
+export { getApplicationTables, getAppliedMigrations, getMiniflareDatabasePath, openSqliteDatabase, runMigrations };

package/dist/{runner-Ol0TNjk6.mjs → runner-DMBKSrRk.mjs}

@@ -1,7 +1,7 @@
 import { a as join, n as dirname } from "./dist-BVqXeR_h.mjs";
 import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
 import { n as hasPackageDependency, r as readNearestPackageJson } from "./package-json-DXfiT1jV.mjs";
-import { r as classifyMigration } from "./plan-NPpwZ_kc.mjs";
+import { r as classifyMigration } from "./plan-BhLO2p4w.mjs";
 import { existsSync, mkdirSync } from "node:fs";
 import { createHash, createHmac } from "node:crypto";
 //#region src/migrations/runner.ts
@@ -171,4 +171,4 @@ async function runMigrations(migrationsDir, dbPath) {
 	}
 }
 //#endregion
-export { projectUsesVitePlus as a, openSqliteDatabase as i, getAppliedMigrations as n, runMigrations as o, getMiniflareDatabasePath as r, toBetterSqlite3Error as s, getApplicationTables as t };
+export { runMigrations as a, openSqliteDatabase as i, getAppliedMigrations as n, toBetterSqlite3Error as o, getMiniflareDatabasePath as r, getApplicationTables as t };

package/dist/{runner-mysql-DmWchSWJ.mjs → runner-mysql-CEzKtmFb.mjs}

@@ -9,14 +9,17 @@ async function readMySqlAppliedMigrations(client) {
 		throw error;
 	}
 }
+function toMySqlClient(connection) {
+	return { async query(sql, params) {
+		const [rows] = await connection.query(sql, params);
+		return Array.isArray(rows) ? rows : [];
+	} };
+}
 async function getMySqlAppliedMigrations(url) {
 	const { createConnection } = await import("mysql2/promise");
 	const connection = await createConnection(url);
 	try {
-		return await readMySqlAppliedMigrations({ async query(sql, params) {
-			const [rows] = await connection.query(sql, params);
-			return Array.isArray(rows) ? rows : [];
-		} });
+		return await readMySqlAppliedMigrations(toMySqlClient(connection));
 	} finally {
 		await connection.end();
 	}
@@ -42,10 +45,7 @@ async function runMySqlMigrations(migrationsDir, url) {
 		multipleStatements: true
 	});
 	try {
-		return await applyMySqlMigrations({ async query(sql, params) {
-			const [rows] = await connection.query(sql, params);
-			return Array.isArray(rows) ? rows : [];
-		} }, migrations);
+		return await applyMySqlMigrations(toMySqlClient(connection), migrations);
 	} finally {
 		await connection.end();
 	}

package/dist/{runner-mysql-CEG5JozK.mjs → runner-mysql-CkFqZ6CE.mjs}

@@ -1,2 +1,2 @@
-import { i as runMySqlMigrations, n as getMySqlAppliedMigrations, t as applyMySqlMigrations } from "./runner-mysql-DmWchSWJ.mjs";
+import { i as runMySqlMigrations, n as getMySqlAppliedMigrations, t as applyMySqlMigrations } from "./runner-mysql-CEzKtmFb.mjs";
 export { applyMySqlMigrations, getMySqlAppliedMigrations, runMySqlMigrations };

package/dist/{runner-pg-Bh4AgZdj.mjs → runner-pg-BGYRFdRp.mjs}

@@ -1,2 +1,2 @@
-import { i as runPgMigrations, n as getPgAppliedMigrations, t as applyPgMigrations } from "./runner-pg-D4OPlil-.mjs";
+import { i as runPgMigrations, n as getPgAppliedMigrations, t as applyPgMigrations } from "./runner-pg-DV8p_zjA.mjs";
 export { applyPgMigrations, getPgAppliedMigrations, runPgMigrations };

package/dist/runtime/ai.d.mts

@@ -1,4 +1,3 @@
-import { n as LimitOperation } from "../limits-Bq5LG8Id.mjs";
 //#region src/runtime/ai-types.d.ts
 type AiProviderName = "openai" | "anthropic" | "google-ai-studio" | "groq" | "mistral" | "grok" | "deepseek" | "openrouter" | "perplexity" | "cohere" | "cerebras" | "huggingface" | "replicate" | "baseten" | "cartesia" | "deepgram" | "elevenlabs" | "fal" | "ideogram" | "parallel";
 type AiProvider = AiProviderName | (string & {});
@@ -26,25 +25,25 @@ type AiProviderFetchInit = {
  * in a `Response` with SSE headers — ready to return from a route handler.
  */
 export type VoidAi = {
-  models(...args: Parameters<Ai["models"]>): LimitOperation<Awaited<ReturnType<Ai["models"]>>>;
-  toMarkdown(files: Array<Parameters<Ai["toMarkdown"]>[0]>, options?: Parameters<Ai["toMarkdown"]>[1]): LimitOperation<Array<Awaited<ReturnType<Ai["toMarkdown"]>>>>;
-  toMarkdown(...args: Parameters<Ai["toMarkdown"]>): LimitOperation<Awaited<ReturnType<Ai["toMarkdown"]>>>;
-  /** Workers AI inference (existing) */
-  run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): LimitOperation<AiModels[Name]["postProcessedOutputs"]>;
+  models(...args: Parameters<Ai["models"]>): Promise<Awaited<ReturnType<Ai["models"]>>>;
+  toMarkdown(files: Array<Parameters<Ai["toMarkdown"]>[0]>, options?: Parameters<Ai["toMarkdown"]>[1]): Promise<Array<Awaited<ReturnType<Ai["toMarkdown"]>>>>;
+  toMarkdown(...args: Parameters<Ai["toMarkdown"]>): Promise<Awaited<ReturnType<Ai["toMarkdown"]>>>;
+  /** Workers AI inference. */
+  run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>;
   /** Cloudflare AI Gateway model inference. Accepts Cloudflare model IDs unchanged. */
-  run(model: string, inputs: unknown, options?: AiOptions): LimitOperation<unknown>;
+  run(model: string, inputs: unknown, options?: AiOptions): Promise<unknown>;
   /** Image generation. Returns the proxy response so callers can return or parse it. */
-  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): LimitOperation<Response>;
+  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<Response>;
   /** Cloudflare AI Gateway model inference returned as a Response. */
-  image(model: string, inputs: unknown, options?: AiOptions): LimitOperation<Response>;
+  image(model: string, inputs: unknown, options?: AiOptions): Promise<Response>;
   /** Provider-native AI Gateway requests using a project secret for the provider API key. */
   provider(provider: AiProvider, options?: AiProviderOptions): {
-    fetch(path: string, init?: AiProviderFetchInit): LimitOperation<Response>;
+    fetch(path: string, init?: AiProviderFetchInit): Promise<Response>;
   };
   /** Stream Workers AI response as SSE */
-  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): LimitOperation<Response>;
+  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>;
   /** Stream any Cloudflare AI Gateway model response as SSE */
-  stream(model: string, inputs: Record<string, unknown>, options?: AiOptions): LimitOperation<Response>;
+  stream(model: string, inputs: Record<string, unknown>, options?: AiOptions): Promise<Response>;
 };
 export declare const ai: VoidAi;
 //#endregion

package/dist/runtime/ai.mjs

@@ -1,6 +1,6 @@
 import { t as cfAccessHeaders } from "../cf-access-TWNzXltp.mjs";
-import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
-import { a as readUsageLimit, i as limitOperation, r as limitFromResponse, t as UsageLimit } from "../limits-Cjuk2VPm.mjs";
+import { a as getRawRuntimeEnv } from "../env-raw-jZpP5n47.mjs";
+import { r as limitFromResponse, t as UsageLimit } from "../limits-D0vD1M9A.mjs";
 //#region src/runtime/ai-types.ts
 /** Maps provider prefix to expected env var name for the API key */
 const PROVIDER_KEY_MAP = {
@@ -143,9 +143,6 @@ async function serializeProxyValue(value, serializeDataObjectAsFile = false) {
 	}
 	return value;
 }
-function formFileName(value, fallback) {
-	return fileNameFromBlob(value) ?? fallback;
-}
 async function serializeFormData(form) {
 	const entries = [];
 	for (const [name, value] of form.entries()) {
@@ -161,7 +158,7 @@ async function serializeFormData(form) {
 			value: {
 				[VOID_FILE_MARKER]: true,
 				data: arrayBufferToBase64(await value.arrayBuffer()),
-				name: formFileName(value, name),
+				name: fileNameFromBlob(value) ?? name,
 				type: value.type || void 0
 			}
 		});
@@ -260,7 +257,7 @@ function isUnsafeProviderPath(path) {
 	return false;
 }
 /**
-* Build a real outgoing HTTP body for the user's own AI Gateway (P3 self-host).
+* Build a real outgoing HTTP body for the user's own AI Gateway (self-host).
 *
 * Unlike `serializeProviderBody`/`providerRequestBody` (which build the proxy
 * envelope decoded on the proxy side), this emits an actual `BodyInit` +
@@ -304,16 +301,10 @@ async function providerRequestBody(provider, path, init, options, runtimeEnv) {
 		apiKeyPrefix: options?.apiKeyPrefix
 	};
 }
-function makeServiceBindingBackend(proxy, runtimeEnv) {
-	async function proxyFetch(action, body, options = {}) {
-		const res = await proxy.fetch(`https://ai-proxy/ai/${action}`, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				action,
-				...body
-			})
-		});
+/** Backend for the Void platform proxy, reached by service binding or HTTPS. */
+function makeProxyBackend(send, runtimeEnv) {
+	async function proxyFetch(action, payload, options = {}) {
+		const res = await send(action, payload);
 		const limit = await limitFromResponse(res, "ai");
 		if (limit) throw limit;
 		if (options.throwOnError !== false && !res.ok) {
@@ -324,60 +315,48 @@ function makeServiceBindingBackend(proxy, runtimeEnv) {
 	}
 	return {
 		async run(model, inputs, options) {
-			const projectId = runtimeEnv.__PROJECT_ID;
-			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
 			const res = await proxyFetch("run", {
 				model,
 				inputs,
-				options,
-				projectId,
-				aiToken
+				options
 			});
 			if (hasStreamFlag(inputs) && inputs.stream) return res.body;
 			return readProxyResult(res);
 		},
 		async image(model, inputs, options) {
-			const projectId = runtimeEnv.__PROJECT_ID;
-			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
 			const { runOptions } = splitImageOptions(options);
 			return proxyFetch("run", {
 				model,
 				inputs,
-				options: runOptions,
-				projectId,
-				aiToken
+				options: runOptions
 			});
 		},
 		async providerFetch(provider, path, init, options) {
-			const projectId = runtimeEnv.__PROJECT_ID;
-			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
-			return proxyFetch("provider", {
-				...await providerRequestBody(provider, path, init, options, runtimeEnv),
-				projectId,
-				aiToken
-			}, { throwOnError: false });
+			return proxyFetch("provider", await providerRequestBody(provider, path, init, options, runtimeEnv), { throwOnError: false });
 		},
 		async models(params) {
-			const projectId = runtimeEnv.__PROJECT_ID;
-			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
-			return (await proxyFetch("models", {
-				inputs: params,
-				projectId,
-				aiToken
-			})).json();
+			return (await proxyFetch("models", { inputs: params })).json();
 		},
 		async toMarkdown(items, options) {
-			const projectId = runtimeEnv.__PROJECT_ID;
-			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
 			return (await proxyFetch("toMarkdown", {
 				inputs: items,
-				options,
-				projectId,
-				aiToken
+				options
 			})).json();
 		}
 	};
 }
+function makeServiceBindingBackend(proxy, runtimeEnv) {
+	return makeProxyBackend((action, payload) => proxy.fetch(`https://ai-proxy/ai/${action}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			action,
+			...payload,
+			projectId: runtimeEnv.__PROJECT_ID,
+			aiToken: runtimeEnv.__VOID_PROXY_TOKEN
+		})
+	}), runtimeEnv);
+}
 function makeHttpBackend(token, projectId, runtimeEnv) {
 	const base = getProxyUrl(runtimeEnv);
 	const headers = {
@@ -385,56 +364,16 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 		authorization: `Bearer ${token}`,
 		...cfAccessHeaders(runtimeEnv, base)
 	};
-	async function proxyFetch(action, body, options = {}) {
-		const res = await fetch(`${base}/${action}`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify({
-				action,
-				...body,
-				projectId
-			}),
-			redirect: "manual"
-		});
-		const limit = await limitFromResponse(res, "ai");
-		if (limit) throw limit;
-		if (options.throwOnError !== false && !res.ok) {
-			const text = await res.text();
-			throw new Error(`ai: Proxy request failed with ${res.status}: '${text}'.`);
-		}
-		return res;
-	}
-	return {
-		async run(model, inputs, options) {
-			const res = await proxyFetch("run", {
-				model,
-				inputs,
-				options
-			});
-			if (hasStreamFlag(inputs) && inputs.stream) return res.body;
-			return readProxyResult(res);
-		},
-		async image(model, inputs, options) {
-			const { runOptions } = splitImageOptions(options);
-			return proxyFetch("run", {
-				model,
-				inputs,
-				options: runOptions
-			});
-		},
-		async providerFetch(provider, path, init, options) {
-			return proxyFetch("provider", await providerRequestBody(provider, path, init, options, runtimeEnv), { throwOnError: false });
-		},
-		async models(params) {
-			return (await proxyFetch("models", { inputs: params })).json();
-		},
-		async toMarkdown(items, options) {
-			return (await proxyFetch("toMarkdown", {
-				inputs: items,
-				options
-			})).json();
-		}
-	};
+	return makeProxyBackend((action, payload) => fetch(`${base}/${action}`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			action,
+			...payload,
+			projectId
+		}),
+		redirect: "manual"
+	}), runtimeEnv);
 }
 function makeDirectBackend(directAi, runtimeEnv, gatewayId) {
 	const run = async (model, inputs, options) => {
@@ -491,19 +430,20 @@ function backend() {
 	return _backend ??= resolveBackend();
 }
 /** Normalize provider 429 responses and binding quota failures before they reach callers. */
-function aiOperation(execute, rawStream = false) {
-	return limitOperation(async () => {
-		const value = await execute();
+async function aiOperation(execute, rawStream = false) {
+	let value;
+	try {
+		value = await execute();
 		if (value instanceof Response) {
 			const limit = await limitFromResponse(value, "ai");
 			if (limit) throw limit;
 		}
-		return value;
-	}, classifyAiLimit, (value, limited) => {
-		if (value instanceof Response && value.body && value.headers.get("content-type")?.includes("text/event-stream")) return new Response(streamResponse(value.body, limited).body, value);
-		if (rawStream && value instanceof ReadableStream) return streamResponse(value, limited).body;
-		return value;
-	});
+	} catch (error) {
+		throw classifyAiLimit(error) ?? error;
+	}
+	if (value instanceof Response && value.body && value.headers.get("content-type")?.includes("text/event-stream")) return new Response(streamResponse(value.body).body, value);
+	if (rawStream && value instanceof ReadableStream) return streamResponse(value).body;
+	return value;
 }
 function classifyAiLimit(error) {
 	if (error instanceof UsageLimit) return error;
@@ -515,7 +455,7 @@ function classifyAiLimit(error) {
 	}) : null;
 }
 /** Streaming failures after headers are sent end with an explicit terminal SSE event. */
-function streamResponse(body, limited) {
+function streamResponse(body) {
 	const reader = body.getReader();
 	return new Response(new ReadableStream({
 		async pull(controller) {
@@ -526,13 +466,7 @@ function streamResponse(body, limited) {
 			} catch (error) {
 				const limit = classifyAiLimit(error);
 				let data = { message: "Generation was interrupted. Please try again." };
-				if (limit) {
-					data = await limit.response().json();
-					try {
-						const fallback = await limited(limit);
-						if (fallback instanceof Response) data = readUsageLimit(await fallback.json().catch(() => null)) ?? data;
-					} catch {}
-				}
+				if (limit) data = await limit.response().json();
 				controller.enqueue(new TextEncoder().encode(`event: ${limit ? "void:limit" : "void:error"}\ndata: ${JSON.stringify(data)}\n\n`));
 				controller.close();
 			}

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

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

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

@@ -1,15 +1,10 @@
-import { t as applyMySqlAuthMigrations } from "../auth-migrations-9vif1uj8.mjs";
-import { t as createVoidAuthRuntime } from "../better-auth-shared-hy6RPh9W.mjs";
+import { t as applyMySqlAuthMigrations } from "../auth-migrations-BwHgeEsD.mjs";
+import { n as createVoidAuthRuntime, r as resolveConnectionString } from "../better-auth-shared-DPpj8zxc.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),
+		uri: resolveConnectionString(env, "MySQL"),
 		connectionLimit: 1
 	});
 	return {
@@ -23,7 +18,7 @@ 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));
+	const connection = await createConnection(resolveConnectionString(env, "MySQL"));
 	try {
 		await applyMySqlAuthMigrations({
 			async all(sql, params) {

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

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

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

@@ -1,15 +1,10 @@
-import { n as applyPgAuthMigrations } from "../auth-migrations-9vif1uj8.mjs";
-import { t as createVoidAuthRuntime } from "../better-auth-shared-hy6RPh9W.mjs";
+import { n as applyPgAuthMigrations } from "../auth-migrations-BwHgeEsD.mjs";
+import { n as createVoidAuthRuntime, r as resolveConnectionString, t as assertRuntimeDialect } from "../better-auth-shared-DPpj8zxc.mjs";
 import { t as disablePgPassFallback } from "../pg-J2HbZIkX.mjs";
 //#region src/runtime/better-auth-pg.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 PostgreSQL dev or HYPERDRIVE in production.");
-	return connectionString;
-}
 async function resolveDatabase(env) {
 	const { default: pg } = await import("pg");
-	const connectionString = resolveConnectionString(env);
+	const connectionString = resolveConnectionString(env, "PostgreSQL");
 	const pool = new pg.Pool({
 		connectionString,
 		max: 1
@@ -23,10 +18,10 @@ async function resolveDatabase(env) {
 }
 async function runPostgresAuthMigrations(_request, env, runtime, migrationSchema) {
 	if (!migrationSchema) throw new Error("auth: Migration schema is unavailable.");
-	if (runtime.dialect !== "postgresql") throw new Error(`auth: Runtime mismatch. Expected postgresql, received '${runtime.dialect}'.`);
+	assertRuntimeDialect(runtime, "postgresql");
 	if (migrationSchema.dialect !== "postgresql") throw new Error(`auth: Runtime mismatch. Expected postgresql, received '${migrationSchema.dialect}'.`);
 	const { Client } = await import("pg");
-	const client = new Client({ connectionString: resolveConnectionString(env) });
+	const client = new Client({ connectionString: resolveConnectionString(env, "PostgreSQL") });
 	disablePgPassFallback(client);
 	await client.connect();
 	try {

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

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