void 0.1.6 → 0.7.0

package/dist/runtime/ai.d.mts

@@ -0,0 +1,127 @@
+//#region src/runtime/ai-types.d.ts
+type ThirdPartyProvider = "openai" | "anthropic" | "google-ai-studio" | "groq" | "mistral" | "grok" | "deepseek" | "openrouter" | "perplexity" | "cohere" | "cerebras" | "huggingface" | "replicate" | "baseten" | "cartesia" | "deepgram" | "elevenlabs" | "fal" | "ideogram" | "parallel";
+type ThirdPartyModel = `${ThirdPartyProvider}/${string}`;
+type ChatContent = string | Array<{
+  type: "text";
+  text: string;
+} | {
+  type: "image_url";
+  image_url: {
+    url: string;
+    detail?: "auto" | "low" | "high";
+  };
+}>;
+interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: ChatContent;
+}
+interface ChatCompletionInputs {
+  messages: Array<ChatMessage>;
+  temperature?: number;
+  max_tokens?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string | Array<string>;
+  stream?: boolean;
+}
+interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<ChatCompletionChoice>;
+  usage: ChatCompletionUsage;
+}
+interface ChatCompletionChoice {
+  index: number;
+  message: ChatMessage;
+  finish_reason: string;
+}
+interface ChatCompletionUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}
+interface ChatCompletionChunk {
+  id: string;
+  choices: Array<{
+    index: number;
+    delta: {
+      role?: string;
+      content?: string;
+    };
+    finish_reason: string | null;
+  }>;
+}
+type ImageGatewayEndpoint = "images/generations" | "images/edits";
+type ImageFileInput = Blob | ArrayBuffer | ArrayBufferView | {
+  data: string;
+  name?: string;
+  type?: string;
+};
+interface ImageGenerationInputs {
+  prompt: string;
+  n?: number;
+  size?: string;
+  quality?: string;
+  response_format?: "url" | "b64_json";
+  user?: string;
+  [key: string]: unknown;
+}
+interface ImageGenerationData {
+  url?: string;
+  b64_json?: string;
+  revised_prompt?: string;
+}
+interface ImageGenerationResponse {
+  created?: number;
+  data: Array<ImageGenerationData>;
+  usage?: unknown;
+  [key: string]: unknown;
+}
+interface ImageGenerationOptions {
+  endpoint?: "images/generations";
+  [key: string]: unknown;
+}
+interface ImageEditOptions {
+  endpoint: "images/edits";
+  [key: string]: unknown;
+}
+interface ImageEditInputs {
+  prompt: string;
+  image: ImageFileInput | Array<ImageFileInput>;
+  mask?: ImageFileInput;
+  n?: number;
+  size?: string;
+  response_format?: "url" | "b64_json";
+  user?: string;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/runtime/ai.d.ts
+/**
+* Extended AI interface with a convenience `stream()` method.
+*
+* `stream()` calls `ai.run()` with `stream: true` and wraps the result
+* in a `Response` with SSE headers — ready to return from a route handler.
+*/
+interface VoidAi extends Omit<Ai, "run"> {
+  /** Workers AI inference (existing) */
+  run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>;
+  /** Third-party chat completions (OpenAI, Anthropic, etc.) */
+  run(model: ThirdPartyModel, inputs: ChatCompletionInputs, options?: AiOptions): Promise<ChatCompletionResponse>;
+  /** 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?: ImageGenerationOptions): Promise<Response>;
+  /** Third-party image generation or editing through AI Gateway. */
+  image(model: ThirdPartyModel, inputs: ImageEditInputs, options: ImageEditOptions): Promise<Response>;
+  /** Third-party image generation through AI Gateway. */
+  image(model: ThirdPartyModel, inputs: ImageGenerationInputs, options?: ImageGenerationOptions): Promise<Response>;
+  /** Stream Workers AI response as SSE */
+  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>;
+  /** Stream third-party chat completions as SSE */
+  stream(model: ThirdPartyModel, inputs: Omit<ChatCompletionInputs, "stream">, options?: AiOptions): Promise<Response>;
+}
+declare const ai: VoidAi;
+//#endregion
+export { type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionInputs, type ChatCompletionResponse, type ChatCompletionUsage, type ChatContent, type ChatMessage, type ImageEditInputs, type ImageEditOptions, type ImageFileInput, type ImageGatewayEndpoint, type ImageGenerationData, type ImageGenerationInputs, type ImageGenerationOptions, type ImageGenerationResponse, type ThirdPartyModel, type ThirdPartyProvider, VoidAi, ai };

package/dist/runtime/ai.mjs

@@ -0,0 +1,348 @@
+import { t as cfAccessHeaders } from "../cf-access-Dee5cXxL.mjs";
+import { i as getRawRuntimeEnv } from "../env-raw-BDL4TvdN.mjs";
+//#region src/runtime/ai-types.ts
+/** Maps provider prefix to expected env var name for the API key */
+const PROVIDER_KEY_MAP = {
+	openai: "OPENAI_API_KEY",
+	anthropic: "ANTHROPIC_API_KEY",
+	"google-ai-studio": "GOOGLE_API_KEY",
+	groq: "GROQ_API_KEY",
+	mistral: "MISTRAL_API_KEY",
+	grok: "GROK_API_KEY",
+	deepseek: "DEEPSEEK_API_KEY",
+	openrouter: "OPENROUTER_API_KEY",
+	perplexity: "PERPLEXITY_API_KEY",
+	cohere: "COHERE_API_KEY",
+	cerebras: "CEREBRAS_API_KEY",
+	huggingface: "HUGGINGFACE_API_KEY",
+	replicate: "REPLICATE_API_KEY",
+	baseten: "BASETEN_API_KEY",
+	cartesia: "CARTESIA_API_KEY",
+	deepgram: "DEEPGRAM_API_KEY",
+	elevenlabs: "ELEVENLABS_API_KEY",
+	fal: "FAL_API_KEY",
+	ideogram: "IDEOGRAM_API_KEY",
+	parallel: "PARALLEL_API_KEY"
+};
+//#endregion
+//#region src/runtime/ai.ts
+const PROXY_URL = "https://proxy.void.cloud/ai";
+const STAGING_PROXY_URL = "https://proxy.staging.void.cloud/ai";
+const VOID_FILE_MARKER = "__voidFile";
+function hasStreamFlag(value) {
+	return typeof value === "object" && value !== null && "stream" in value;
+}
+function isThirdPartyModel(model) {
+	return model.split("/")[0] in PROVIDER_KEY_MAP;
+}
+function mediaTypeFromContentType(contentType) {
+	if (!contentType) return null;
+	const [mediaType] = contentType.split(";", 1);
+	return mediaType?.trim().toLowerCase() || null;
+}
+function isJsonMediaType(mediaType) {
+	if (mediaType === "application/json") return true;
+	const slash = mediaType?.indexOf("/") ?? -1;
+	return Boolean(mediaType && slash >= 0 && mediaType.slice(slash + 1).endsWith("+json"));
+}
+async function readProxyResult(response) {
+	if (isJsonMediaType(mediaTypeFromContentType(response.headers.get("content-type")))) return response.json();
+	return response.blob();
+}
+function hasResponseMethod(value) {
+	return typeof value === "object" && value !== null && "response" in value && typeof value.response === "function";
+}
+function isBinaryView(value) {
+	return ArrayBuffer.isView(value);
+}
+function copyBinaryView(value) {
+	const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+function bytesToBase64(bytes) {
+	let binary = "";
+	const chunkSize = 32768;
+	for (let i = 0; i < bytes.length; i += chunkSize) binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+	return btoa(binary);
+}
+function arrayBufferToBase64(buffer) {
+	return bytesToBase64(new Uint8Array(buffer));
+}
+function isFileLikeRecord(value) {
+	return typeof value.data === "string" && (value.name === void 0 || typeof value.name === "string") && (value.type === void 0 || typeof value.type === "string");
+}
+function fileNameFromBlob(value) {
+	const name = value.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+async function serializeProxyValue(value, serializeDataObjectAsFile = false) {
+	if (value instanceof Blob) return {
+		[VOID_FILE_MARKER]: true,
+		data: arrayBufferToBase64(await value.arrayBuffer()),
+		name: fileNameFromBlob(value),
+		type: value.type || void 0
+	};
+	if (value instanceof ArrayBuffer) return {
+		[VOID_FILE_MARKER]: true,
+		data: arrayBufferToBase64(value),
+		type: "application/octet-stream"
+	};
+	if (isBinaryView(value)) return {
+		[VOID_FILE_MARKER]: true,
+		data: arrayBufferToBase64(copyBinaryView(value)),
+		type: "application/octet-stream"
+	};
+	if (Array.isArray(value)) return Promise.all(value.map((item) => serializeProxyValue(item, serializeDataObjectAsFile)));
+	if (typeof value === "object" && value !== null) {
+		const record = value;
+		if (serializeDataObjectAsFile && isFileLikeRecord(record)) return {
+			[VOID_FILE_MARKER]: true,
+			data: record.data,
+			name: record.name,
+			type: record.type
+		};
+		const serialized = {};
+		for (const [key, nestedValue] of Object.entries(record)) serialized[key] = await serializeProxyValue(nestedValue, key === "image" || key === "mask");
+		return serialized;
+	}
+	return value;
+}
+async function serializeImageInputs(inputs, endpoint) {
+	return endpoint === "images/edits" ? serializeProxyValue(inputs) : inputs;
+}
+async function responseFromResult(result) {
+	if (result instanceof Response) return result;
+	if (hasResponseMethod(result)) return result.response();
+	if (result instanceof Blob) return new Response(result, { headers: result.type ? { "content-type": result.type } : void 0 });
+	if (result instanceof ReadableStream) return new Response(result, { headers: { "content-type": "application/octet-stream" } });
+	if (result instanceof ArrayBuffer) return new Response(result, { headers: { "content-type": "application/octet-stream" } });
+	if (isBinaryView(result)) return new Response(copyBinaryView(result), { headers: { "content-type": "application/octet-stream" } });
+	return Response.json(result);
+}
+function splitImageOptions(options) {
+	if (typeof options !== "object" || options === null) return {
+		endpoint: "images/generations",
+		runOptions: void 0
+	};
+	const { endpoint, ...runOptions } = options;
+	return {
+		endpoint: typeof endpoint === "string" ? endpoint : "images/generations",
+		runOptions: Object.keys(runOptions).length > 0 ? runOptions : void 0
+	};
+}
+function resolveProviderKey(model, runtimeEnv) {
+	const provider = model.split("/")[0];
+	const envVar = PROVIDER_KEY_MAP[provider];
+	if (!envVar) throw new Error(`ai: Unknown provider '${provider}'. Use one of: ${Object.keys(PROVIDER_KEY_MAP).join(", ")}.`);
+	const key = runtimeEnv[envVar];
+	if (typeof key !== "string" || key.length === 0) throw new Error(`ai: Missing ${envVar} secret. Add it as a project secret for provider '${provider}'.`);
+	return key;
+}
+function getProxyUrl(runtimeEnv) {
+	const custom = runtimeEnv.__VOID_PROXY_URL;
+	if (typeof custom === "string" && custom.length > 0) return custom + "/ai";
+	return runtimeEnv.__VOID_STAGING ? STAGING_PROXY_URL : PROXY_URL;
+}
+function resolveBackend() {
+	const runtimeEnv = getRawRuntimeEnv();
+	const proxy = runtimeEnv.__VOID_PROXY;
+	if (proxy) return makeServiceBindingBackend(proxy, runtimeEnv);
+	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;
+	if (directAi) return {
+		run: directAi.run.bind(directAi),
+		async image(model, inputs, options) {
+			const { runOptions } = splitImageOptions(options);
+			return responseFromResult(await directAi.run(model, inputs, runOptions));
+		},
+		models: directAi.models.bind(directAi),
+		toMarkdown: directAi.toMarkdown?.bind(directAi) ?? unsupported("toMarkdown")
+	};
+	throw new Error("ai: Not available. Run `void auth login` and `void project link` first.");
+}
+function unsupported(method) {
+	return () => {
+		throw new Error(`ai: ai.${method}() is not supported in this environment.`);
+	};
+}
+function makeServiceBindingBackend(proxy, runtimeEnv) {
+	async function proxyFetch(action, body) {
+		const res = await proxy.fetch(`https://ai-proxy/ai/${action}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				action,
+				...body
+			})
+		});
+		if (!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 projectId = runtimeEnv.__PROJECT_ID;
+			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
+			if (isThirdPartyModel(model)) {
+				const res = await proxyFetch("gateway", {
+					model,
+					inputs,
+					providerKey: resolveProviderKey(model, runtimeEnv),
+					projectId,
+					aiToken
+				});
+				if (hasStreamFlag(inputs) && inputs.stream) return res.body;
+				return readProxyResult(res);
+			}
+			const res = await proxyFetch("run", {
+				model,
+				inputs,
+				options,
+				projectId,
+				aiToken
+			});
+			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 { endpoint, runOptions } = splitImageOptions(options);
+			if (isThirdPartyModel(model)) {
+				const providerKey = resolveProviderKey(model, runtimeEnv);
+				return proxyFetch("gateway", {
+					model,
+					endpoint,
+					inputs: await serializeImageInputs(inputs, endpoint),
+					providerKey,
+					projectId,
+					aiToken
+				});
+			}
+			return proxyFetch("run", {
+				model,
+				inputs,
+				options: runOptions,
+				projectId,
+				aiToken
+			});
+		},
+		async models(params) {
+			const projectId = runtimeEnv.__PROJECT_ID;
+			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
+			return (await proxyFetch("models", {
+				inputs: params,
+				projectId,
+				aiToken
+			})).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
+			})).json();
+		}
+	};
+}
+function makeHttpBackend(token, projectId, runtimeEnv) {
+	const base = getProxyUrl(runtimeEnv);
+	const headers = {
+		"content-type": "application/json",
+		authorization: `Bearer ${token}`,
+		...cfAccessHeaders(runtimeEnv)
+	};
+	async function proxyFetch(action, body) {
+		const res = await fetch(`${base}/${action}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				action,
+				...body,
+				projectId
+			})
+		});
+		if (!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) {
+			if (isThirdPartyModel(model)) {
+				const res = await proxyFetch("gateway", {
+					model,
+					inputs,
+					providerKey: resolveProviderKey(model, runtimeEnv)
+				});
+				if (hasStreamFlag(inputs) && inputs.stream) return res.body;
+				return readProxyResult(res);
+			}
+			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 { endpoint, runOptions } = splitImageOptions(options);
+			if (isThirdPartyModel(model)) {
+				const providerKey = resolveProviderKey(model, runtimeEnv);
+				return proxyFetch("gateway", {
+					model,
+					endpoint,
+					inputs: await serializeImageInputs(inputs, endpoint),
+					providerKey
+				});
+			}
+			return proxyFetch("run", {
+				model,
+				inputs,
+				options: runOptions
+			});
+		},
+		async models(params) {
+			return (await proxyFetch("models", { inputs: params })).json();
+		},
+		async toMarkdown(items, options) {
+			return (await proxyFetch("toMarkdown", {
+				inputs: items,
+				options
+			})).json();
+		}
+	};
+}
+let _backend;
+function backend() {
+	return _backend ??= resolveBackend();
+}
+const ai = new Proxy({}, { get(_, prop) {
+	if (prop === "stream") return async (model, inputs, options) => {
+		const body = await backend().run(model, {
+			...inputs,
+			stream: true
+		}, options);
+		return new Response(body, { headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache"
+		} });
+	};
+	if (prop === "run") return backend().run;
+	if (prop === "image") return backend().image;
+	if (prop === "models") return backend().models;
+	if (prop === "toMarkdown") return backend().toMarkdown;
+} });
+//#endregion
+export { ai };

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

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

package/dist/runtime/auth-client-react.mjs

@@ -0,0 +1,6 @@
+import { createAuthClient as createAuthClient$1 } from "better-auth/react";
+//#region src/runtime/auth-client-react.ts
+const createAuthClient = createAuthClient$1;
+const auth = createAuthClient$1({ basePath: "/api/auth" });
+//#endregion
+export { auth, createAuthClient };

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

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

package/dist/runtime/auth-client-solid.mjs

@@ -0,0 +1,6 @@
+import { createAuthClient as createAuthClient$1 } from "better-auth/solid";
+//#region src/runtime/auth-client-solid.ts
+const createAuthClient = createAuthClient$1;
+const auth = createAuthClient$1({ basePath: "/api/auth" });
+//#endregion
+export { auth, createAuthClient };

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

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

package/dist/runtime/auth-client-svelte.mjs

@@ -0,0 +1,6 @@
+import { createAuthClient as createAuthClient$1 } from "better-auth/svelte";
+//#region src/runtime/auth-client-svelte.ts
+const createAuthClient = createAuthClient$1;
+const auth = createAuthClient$1({ basePath: "/api/auth" });
+//#endregion
+export { auth, createAuthClient };

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

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

package/dist/runtime/auth-client-vue.mjs

@@ -0,0 +1,6 @@
+import { createAuthClient as createAuthClient$1 } from "better-auth/vue";
+//#region src/runtime/auth-client-vue.ts
+const createAuthClient = createAuthClient$1;
+const auth = createAuthClient$1({ basePath: "/api/auth" });
+//#endregion
+export { auth, createAuthClient };

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

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

package/dist/runtime/auth-client.mjs

@@ -0,0 +1,6 @@
+import { createAuthClient as createAuthClient$1 } from "better-auth/client";
+//#region src/runtime/auth-client.ts
+const createAuthClient = createAuthClient$1;
+const auth = createAuthClient$1({ basePath: "/api/auth" });
+//#endregion
+export { auth, createAuthClient };

package/dist/runtime/auth.d.mts

@@ -0,0 +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-BdsJ0Aff.mjs";
+export { AuthSession, AuthState, AuthUser, VoidAuthConfig, VoidAuthConfigContext, authContext, defineAuth, getSession, getUser, requireAuth };

package/dist/runtime/auth.mjs

@@ -0,0 +1,22 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { HTTPException } from "hono/http-exception";
+//#region src/runtime/auth.ts
+const AUTH_CONTEXT_SYMBOL = Symbol.for("void.authContext.v1");
+const globalWithAuthContext = globalThis;
+const authContext = globalWithAuthContext[AUTH_CONTEXT_SYMBOL] ?? (globalWithAuthContext[AUTH_CONTEXT_SYMBOL] = new AsyncLocalStorage());
+function defineAuth(config) {
+	return config;
+}
+function getUser() {
+	return authContext.getStore()?.user ?? null;
+}
+function getSession() {
+	return authContext.getStore()?.state ?? null;
+}
+function requireAuth(c) {
+	const user = c.get("user");
+	if (!user) throw new HTTPException(401, { message: "Unauthorized" });
+	return user;
+}
+//#endregion
+export { authContext, defineAuth, getSession, getUser, requireAuth };

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

@@ -0,0 +1,11 @@
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-C9_GHSkR.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"];
+//#endregion
+export { type VoidAuthDialect, type VoidAuthEnv, type VoidAuthRuntimeOptions, createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };

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

@@ -0,0 +1,51 @@
+import { t as applyPgAuthMigrations } from "../auth-migrations-BAtAck2g.mjs";
+import { t as createVoidAuthRuntime } from "../better-auth-shared-CdYmQGry.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 pool = new pg.Pool({
+		connectionString,
+		max: 1
+	});
+	return {
+		database: pool,
+		async dispose() {
+			await pool.end();
+		}
+	};
+}
+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}'.`);
+	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) });
+	await client.connect();
+	try {
+		await applyPgAuthMigrations({
+			async all(sql, params) {
+				return (await client.query(sql, params)).rows;
+			},
+			async run(sql, params) {
+				await client.query(sql, params);
+			}
+		}, migrationSchema);
+	} finally {
+		await client.end();
+	}
+}
+const runtime = createVoidAuthRuntime("postgresql", resolveDatabase, runPostgresAuthMigrations);
+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.d.mts

@@ -0,0 +1,11 @@
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv, r as VoidAuthRuntimeApi, t as VoidAuthDialect } from "../better-auth-shared-C9_GHSkR.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"];
+//#endregion
+export { type VoidAuthDialect, type VoidAuthEnv, type VoidAuthRuntimeOptions, createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };