void 0.1.6 → 0.7.0

package/AGENT_PROMPT.md

@@ -0,0 +1,15 @@
+## Void
+
+This project uses [Void](https://void.cloud) — a fullstack Vite plugin + deployment platform for Cloudflare. `voidPlugin()` in `vite.config.ts` gives you file-based API routing on Hono (`routes/`), Inertia-inspired server-rendered pages with co-located loaders/actions (`pages/` + `@void/vue` or `@void/react`), auto-provisioned D1/KV/R2 bindings, first-class Drizzle ORM integration (schema in `db/schema.ts` -> `void/db` Drizzle instance -> typed routes -> typed fetch client), built-in auth, queues, cron jobs, edge caching (ISR), and one-command deploys via `npx void deploy`. For first-time setup, prefer `npx void init`; in an empty directory, install `void` first and let the interactive flow scaffold the starter, add the matching framework adapter, configure project files, handle auth, and link or create the deploy project before the first deploy. In an existing app, `void init` configures Void in place by adding missing Vite scripts and creating or patching `vite.config.*` with `voidPlugin()`. Use `void` and `@void/*` package names in source code and package manifests.
+
+Database: define Drizzle tables in `db/schema.ts`, import `db` from `void/db` and tables from `@schema`. Use `void db push` for prototyping, `void db generate` for production migrations. `drizzle-orm` and `drizzle-kit` ship with void (no extra install). Migrations live in `db/migrations/`.
+
+Env: declare every env key in `env.ts` at the project root via `defineEnv({ KEY: string(), ... })` from `void/env`. Read values via `import { env } from "void/env"`. Schema validation runs at dev start (warns) and on `void deploy` (hard error on missing prod secrets). Use `VITE_*` prefix for keys that should be exposed to client code.
+
+CI/editor prep: run `void prepare` to generate `.void/routes.d.ts`, `.void/db.d.ts`, `.void/queues.d.ts`, `.void/env.d.ts`, and `.void/tsconfig.json` without booting Vite. Run it after `npm install` in CI or a fresh clone before typechecking; `vite dev` and `vite build` regenerate these during normal workflows.
+
+Rewrites and redirects: declare static rules in `void.json` under `routing.redirects` / `routing.rewrites` / `routing.fallbacks`, or in a `public/_redirects` file. For dynamic rewrites, call `c.rewrite(path)` in a `defineMiddleware`.
+
+Logs: surface app-level errors that should show up under `void project logs --level error` via `import { logger } from "void/log"` and `logger.error(msg, fields?)` (also `.warn` / `.info`). Anything caught and only persisted to your own DB is invisible to Cloudflare Tail; route it through `logger.*` or `console.*` so the platform can see it.
+
+Full docs are in `node_modules/void/docs/`. If you have the `void` skill available, use it for a complete API reference covering project structure, routing, pages mode, database, auth, typed fetch, KV, storage, queues, cron jobs, CLI, configuration, and deployment.

package/README.md

@@ -1,150 +1,89 @@
-Void [![Build Status](https://travis-ci.org/edj-boston/void.svg?branch=master)](https://travis-ci.org/edj-boston/void)
-====
+# void
 
-[Void](https://github.com/edj-boston/void) is a NodeJS [module](https://www.npmjs.org/package/teleshenvoidmodule) that intelligently invalidates your CloudFront Cache. It respects the following limitations:
+Vite plugin and CLI for building and deploying apps on Void.
 
-* Hard limit of 1000 paths per invalidation
-* Only 3 invalidations can run at the same time (and other processes may be creating them too)
-* There is no callback for the native AWS SDK, so the API must be polled
+## What It Covers
 
+- file-based API routes from `routes/`
+- Pages mode from `pages/`
+- typed Drizzle access via `void/db`
+- `crons/` and `queues/`
+- URL redirects, rewrites, and fallbacks (`void.json` / `public/_redirects`, plus `c.rewrite()` from middleware)
+- binding inference for D1, KV, R2, AI, auth, and queues
+- remote bindings for local development
+- deploy packaging for Void-hosted apps, static sites, and supported meta-frameworks
 
-Installation
-------------
+## Quick Start
 
-	$ npm install void
+Install the Void CLI:
 
-
-Void relies on the [AWS-SDK](https://www.npmjs.org/package/aws-sdk), which requires that you set two environment variables:
-
-	AWS_ACCESS_KEY_ID
-	AWS_SECRET_ACCESS_KEY
-
-You can [export](http://www.cyberciti.biz/faq/linux-unix-shell-export-command/) them in the shell for local testing or permanent use. You can also load them into your environment using a tool like [supervisor](https://www.npmjs.org/package/supervisor) or [foreman](http://ddollar.github.io/foreman/) to load an .env file.
-
-Follow your hosting provider's instructions for setting environment variables in production:
-
-* [Heroku](https://devcenter.heroku.com/articles/nodejs-support#environment)
-* [AWS Elastic Beanstalk](http://docs.aws.amazon.com/gettingstarted/latest/deploy/envvar.html)
-
-Void requires a third environment variable that contains the CloudFront distribution id:
-
-	DISTRIBUTION_ID
-
-__WARNING:__ Do _not_ place your AWS credentials or CloudFront Distribution ID in source control!
-
-
-Usage
------
-
-Require void at the top of your script.
-
-```js
-var Void = require('void');
-```
-
-Call the constructor with the `new` keyword.
-
-```js
-var v = new Void();
+```bash
+npm install -D void
 ```
 
-_Note:_ Use a capital "V" for the constructor and a single, lowercase "v" to avoid collision with the reserved word "void".
+If you run `void init` in an empty directory, the scaffold flow adds the matching Pages adapter and Vite dependencies for you.
 
+Then run `npx void init`. In an empty directory, the full interactive flow can scaffold a starter, configure local project files, log you in, and link or create your Void project so the next step is just `npx void deploy`. In an existing app, it configures Void in place by adding missing Vite scripts and creating or patching `vite.config.*` with `voidPlugin()`.
 
-Arguments
----------
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { voidPlugin } from 'void';
 
-* __name:__ will default to a 5 character string for logging
-* __distribution:__ will default to `process.env.DISTRIBUTION_ID`
-* __paths:__ Array of path strings to be cleared
-* __dirs:__ Array of directories to be scanned and added to `paths`
-* __poison:__ Array of path strings to be removed from `paths`
-* __maxPaths:__ Max number of paths per invalidation (defaults to 1000)
-* __maxJobs:__ Max number of simultaneous invalidations (defaults to 3)
-
-
-Properties
-----------
-
-* __queue:__ Queue of invalidations
-* __cloudfront:__ The AWS-SDK object
-
-
-Example
--------
-
-We can change the default `maxPaths` method to see some complex behavior:
-
-```js
-var v = new Void({
-	paths : [
-		'/index.html',
-		'/index2.html',
-		'/foo/bar.html',
-		'/foo2/bar2.html'
-	],
-	maxPaths : 1
+export default defineConfig({
+  plugins: [voidPlugin()],
 });
 ```
 
-This will result in the the following console output:
+## Core Surfaces
 
-```
-[Void:IWZ33] Created 4 item(s) in the queue
-[Void:IWZ33][Job:H27NL] Invalidation "IVBLZ2PCXZL5Q" created. Checking in 10 minute(s)...
-[Void:IWZ33][Job:JD9ZU] Invalidation "I35PDGSFYBCA1X" created. Checking in 10 minute(s)...
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H27NL] In progress, re-checking in 2 minute(s)...
-[Void:IWZ33][Job:JD9ZU] In progress, re-checking in 2 minute(s)...
-[Void:IWZ33][Job:H1C3R] Too many invalidations, retrying in 2 minute(s)
-[Void:IWZ33][Job:H27NL] In progress, re-checking in 2 minute(s)...
-[Void:IWZ33][Job:JD9ZU] In progress, re-checking in 2 minute(s)...
-[Void:IWZ33][Job:H1C3R] Invalidation "I13B9HSQI6RO7J" created. Checking in 10 minute(s)...
-[Void:IWZ33][Job:JD9ZU] Invalidation "I35PDGSFYBCA1X" completed!
-[Void:IWZ33][Job:H27NL] Invalidation "IVBLZ2PCXZL5Q" completed!
-[Void:IWZ33][Job:7BTD7] Invalidation "I3HRQCLJU7OSZ7" created. Checking in 10 minute(s)...
-[Void:IWZ33][Job:H1C3R] Invalidation "I13B9HSQI6RO7J" completed!
-[Void:IWZ33][Job:7BTD7] In progress, re-checking in 2 minute(s)...
-[Void:IWZ33][Job:7BTD7] Invalidation "I3HRQCLJU7OSZ7" completed!
-[Void:IWZ23] All jobs complete!
-```
+- `voidPlugin()` — Vite integration, routing, pages mode, codegen, migrations, packaging
+- `void prepare` — generate `.void` artifacts for CI, editors, and fresh clones
+- `void auth login` — platform auth
+- `void deploy` — build and deploy
+- `void db *` — local DB and migration commands
+- `void project *` — link, status, logs, rollback, delete
 
+Runtime helpers include:
 
-Tests
------
+- `defineHandler`
+- `defineMiddleware`
+- `defineScheduled`
+- `defineQueue`
+- `void/db`
+- `void/kv`
+- `void/storage`
+- `void/ai`
+- `void/isr`
+- `void/client`
+- `void/auth`
 
-Install the global dependancies with sudo permissions.
+## Supported App Shapes
 
-```
-$ sudo npm install -g mocha
-$ sudo npm install -g should
-```
+- native Void apps (`routes/`, `pages/`, `middleware/`, `crons/`, `queues/`)
+- supported meta-framework deploy targets:
+  - TanStack Start
+  - React Router
+  - SvelteKit
+  - Nuxt
+  - Astro
+- static and SPA deploys
+- non-Cloudflare server targets (`node`, `bun`, `deno`)
 
-Run mocha directly to see the test results.
-
-```
-$ cd void
-$ mocha
-```
+There is Vinext-specific source in the repo, but it is intentionally on hold and not part of the current public support matrix.
 
-__WARNING:__ Tests will fail unless you have the `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `DISTRIBUTION_ID` variables configured in your environment!
+## Database Model
 
+`void/db` is Drizzle-first.
 
-Notes
------
+- D1 is the default managed database target
+- framework apps can opt into PostgreSQL mode
+- route types, DB types, and queue types are generated into `.void/*.d.ts`
 
-1. You may incur charges if you invalidate your CloudFront cache frequently. PLease see their [documentation](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Invalidation.html#PayingForInvalidation) and pricing.
-2. Again… do NOT put your AWS credentials of CloudFront distribution id in source control
+## Documentation
 
+Full docs live at [void.cloud/docs](https://void.cloud/docs).
 
-To do
------
+## License
 
-1. More tests
-2. Surface granual `Job` properties in `Void` constructor for more flexibility
-3. `Void` event callbacks
-4. Document `Job` object
+MIT

package/dist/auth-BdsJ0Aff.d.mts

@@ -0,0 +1,43 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { BetterAuthOptions, Session, User } from "better-auth";
+import { Context, Env } from "hono";
+
+//#region src/runtime/auth.d.ts
+type AuthUser = User;
+type AuthSession = Session;
+interface AuthState {
+  session: AuthSession;
+  user: AuthUser;
+}
+interface VoidAuthConfigContext {
+  defaults: BetterAuthOptions;
+  env: Record<string, unknown>;
+  dialect: "sqlite" | "postgresql";
+  request: Request;
+}
+type VoidAuthConfig = BetterAuthOptions | ((ctx: VoidAuthConfigContext) => BetterAuthOptions);
+/**
+* Shared AsyncLocalStorage that holds the authenticated Better Auth state for the
+* current request.
+*
+* Stored on `globalThis` under a `Symbol.for` key so duplicate module loads
+* (e.g. once by void's bundled runtime and once by Vite's SSR module runner
+* when user code imports from `void/auth`) share a single ALS instance. Without
+* this, the middleware writes to one instance and `getUser()` reads another,
+* always returning null.
+*/
+type AuthContextStore = {
+  user: AuthUser | null;
+  state: AuthState | null;
+};
+declare const authContext: AsyncLocalStorage<AuthContextStore>;
+declare function defineAuth<T extends VoidAuthConfig>(config: T): T;
+declare function getUser(): AuthUser | null;
+declare function getSession(): AuthState | null;
+declare function requireAuth<E extends Env & {
+  Variables: {
+    user: AuthUser | null;
+  };
+}>(c: Context<E>): AuthUser;
+//#endregion
+export { VoidAuthConfigContext as a, getSession as c, VoidAuthConfig as i, getUser as l, AuthState as n, authContext as o, AuthUser as r, defineAuth as s, AuthSession as t, requireAuth as u };

package/dist/auth-cmd-Dx8oPKZC.mjs

@@ -0,0 +1,43 @@
+import { c as R } from "./dist-Dayj3gCK.mjs";
+import { n as PlatformClient, s as getToken, u as removeToken } from "./client-snXOjrp1.mjs";
+import { n as runLoginCommand } from "./login-CkcXUiIu.mjs";
+import { execSync } from "node:child_process";
+//#region src/cli/auth-cmd.ts
+async function runAuthCommand(root, args) {
+	switch (args.subcommand) {
+		case "login": return runLoginCommand(root);
+		case "logout":
+			if (removeToken(root)) R.success("Logged out.");
+			else R.info("Not logged in.");
+			return;
+		case "whoami": {
+			const token = getToken(root);
+			if (!token) {
+				R.error("Not logged in. Run `void auth login` first.");
+				process.exit(1);
+			}
+			const user = await new PlatformClient(token, { root }).whoami();
+			R.info(`${user.login} (${user.plan})`);
+			return;
+		}
+		case "token": {
+			if (!getToken(root)) await runLoginCommand(root);
+			const token = getToken(root);
+			if (!token) {
+				R.error("Login failed. Run `void auth login` to try again.");
+				process.exit(1);
+			}
+			const platform = process.platform;
+			const cmd = platform === "darwin" ? "pbcopy" : platform === "win32" ? "clip" : "xclip -selection clipboard";
+			try {
+				execSync(cmd, { input: token });
+				R.success("Token copied to clipboard.");
+			} catch {
+				R.warn("Could not copy to clipboard. Re-run `void login` to generate a new token.");
+			}
+			return;
+		}
+	}
+}
+//#endregion
+export { runAuthCommand };

package/dist/auth-migrations-BAtAck2g.mjs

@@ -0,0 +1,117 @@
+//#region src/runtime/auth-migrations.ts
+function quoteIdentifier(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+function quotePragmaArg(name) {
+	return `'${name.replaceAll("'", "''")}'`;
+}
+function createIndexName(tableName, fieldName, unique) {
+	return `${tableName}_${fieldName}_${unique ? "uidx" : "idx"}`;
+}
+function resolveColumnType(dialect, idStrategy, fieldName, field) {
+	const useIdType = fieldName === "id" || field.references?.field === "id";
+	if (dialect === "postgresql") {
+		if (useIdType) {
+			if (fieldName === "id" && idStrategy === "serial") return "integer GENERATED BY DEFAULT AS IDENTITY";
+			if (idStrategy === "serial") return "integer";
+			if (idStrategy === "uuid") return "uuid";
+			return "text";
+		}
+		if (field.type === "boolean") return "boolean";
+		if (field.type === "date") return "timestamptz";
+		if (field.type === "number") return field.bigint ? "bigint" : "integer";
+		if (field.type === "json" || field.type === "string[]" || field.type === "number[]") return "jsonb";
+		return "text";
+	}
+	if (useIdType) return idStrategy === "serial" ? "INTEGER" : "TEXT";
+	if (field.type === "boolean" || field.type === "date" || field.type === "number") return "INTEGER";
+	if (field.type === "json" || field.type === "string[]" || field.type === "number[]") return "TEXT";
+	return "TEXT";
+}
+function buildColumnDefinition(dialect, schema, fieldName, field, options = {}) {
+	const parts = [`${quoteIdentifier(fieldName)} ${resolveColumnType(dialect, schema.idStrategy, fieldName, field)}`];
+	if (options.primaryKey) parts.push("PRIMARY KEY");
+	if (field.required || options.primaryKey) parts.push("NOT NULL");
+	if (field.references) parts.push(`REFERENCES ${quoteIdentifier(field.references.table)}(${quoteIdentifier(field.references.field)}) ON DELETE ${String(field.references.onDelete ?? "cascade").toUpperCase()}`);
+	return parts.join(" ");
+}
+function buildCreateTableSql(schema, table) {
+	const dialect = schema.dialect;
+	const columns = [buildColumnDefinition(dialect, schema, "id", {
+		type: schema.idStrategy === "serial" ? "number" : "string",
+		required: true,
+		unique: false,
+		index: false,
+		bigint: false
+	}, { primaryKey: true }), ...Object.entries(table.fields).map(([fieldName, field]) => buildColumnDefinition(dialect, schema, fieldName, field))];
+	return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(table.name)} (${columns.join(", ")})`;
+}
+function buildAddColumnSql(schema, tableName, fieldName, field) {
+	const ifNotExists = schema.dialect === "postgresql" ? " IF NOT EXISTS" : "";
+	return `ALTER TABLE ${quoteIdentifier(tableName)} ADD COLUMN${ifNotExists} ${buildColumnDefinition(schema.dialect, schema, fieldName, field)}`;
+}
+function buildCreateIndexSql(tableName, fieldName, unique) {
+	return `CREATE ${unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quoteIdentifier(createIndexName(tableName, fieldName, unique))} ON ${quoteIdentifier(tableName)} (${quoteIdentifier(fieldName)})`;
+}
+async function ensureSqliteIndexes(runner, table) {
+	const indexRows = await runner.all(`PRAGMA index_list(${quotePragmaArg(table.name)})`);
+	const existingIndexes = new Set(indexRows.map((row) => String(row.name)));
+	for (const [fieldName, field] of Object.entries(table.fields)) {
+		if (!field.index && !field.unique) continue;
+		const indexName = createIndexName(table.name, fieldName, field.unique);
+		if (existingIndexes.has(indexName)) continue;
+		await runner.run(buildCreateIndexSql(table.name, fieldName, field.unique));
+	}
+}
+async function ensurePgIndexes(runner, schemaName, table) {
+	const indexRows = await runner.all("SELECT indexname FROM pg_indexes WHERE schemaname = $1 AND tablename = $2", [schemaName, table.name]);
+	const existingIndexes = new Set(indexRows.map((row) => String(row.indexname)));
+	for (const [fieldName, field] of Object.entries(table.fields)) {
+		if (!field.index && !field.unique) continue;
+		const indexName = createIndexName(table.name, fieldName, field.unique);
+		if (existingIndexes.has(indexName)) continue;
+		await runner.run(buildCreateIndexSql(table.name, fieldName, field.unique));
+	}
+}
+async function applySqliteAuthMigrations(runner, schema) {
+	const tableRows = await runner.all("SELECT name FROM sqlite_master WHERE type = 'table'");
+	const existingTables = new Set(tableRows.map((row) => String(row.name)));
+	for (const table of schema.tables) {
+		if (!existingTables.has(table.name)) {
+			await runner.run(buildCreateTableSql(schema, table));
+			await ensureSqliteIndexes(runner, table);
+			existingTables.add(table.name);
+			continue;
+		}
+		const columnRows = await runner.all(`PRAGMA table_info(${quotePragmaArg(table.name)})`);
+		const existingColumns = new Set(columnRows.map((row) => String(row.name)));
+		for (const [fieldName, field] of Object.entries(table.fields)) {
+			if (existingColumns.has(fieldName)) continue;
+			await runner.run(buildAddColumnSql(schema, table.name, fieldName, field));
+		}
+		await ensureSqliteIndexes(runner, table);
+	}
+}
+async function applyPgAuthMigrations(runner, schema) {
+	const schemaRows = await runner.all("SELECT current_schema() AS schema");
+	const schemaName = String(schemaRows[0]?.schema ?? "public");
+	const tableRows = await runner.all("SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'", [schemaName]);
+	const existingTables = new Set(tableRows.map((row) => String(row.table_name)));
+	for (const table of schema.tables) {
+		if (!existingTables.has(table.name)) {
+			await runner.run(buildCreateTableSql(schema, table));
+			await ensurePgIndexes(runner, schemaName, table);
+			existingTables.add(table.name);
+			continue;
+		}
+		const columnRows = await runner.all("SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2", [schemaName, table.name]);
+		const existingColumns = new Set(columnRows.map((row) => String(row.column_name)));
+		for (const [fieldName, field] of Object.entries(table.fields)) {
+			if (existingColumns.has(fieldName)) continue;
+			await runner.run(buildAddColumnSql(schema, table.name, fieldName, field));
+		}
+		await ensurePgIndexes(runner, schemaName, table);
+	}
+}
+//#endregion
+export { applySqliteAuthMigrations as n, applyPgAuthMigrations as t };

package/dist/better-auth-shared-C9_GHSkR.d.mts

@@ -0,0 +1,71 @@
+import { i as VoidAuthConfig, n as AuthState } from "./auth-BdsJ0Aff.mjs";
+import { DBFieldAttribute } from "better-auth/db";
+import { BetterAuthOptions, betterAuth } from "better-auth";
+import { Context } from "hono";
+
+//#region src/auth/drizzle.d.ts
+type AuthIdStrategy = "serial" | "text" | "uuid";
+interface VoidAuthMigrationField {
+  type: DBFieldAttribute["type"];
+  required: boolean;
+  unique: boolean;
+  index: boolean;
+  bigint: boolean;
+  references?: {
+    table: string;
+    field: string;
+    onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+  };
+}
+interface VoidAuthMigrationTable {
+  name: string;
+  order: number;
+  fields: Record<string, VoidAuthMigrationField>;
+}
+interface VoidAuthMigrationSchema {
+  dialect: "sqlite" | "postgresql";
+  idStrategy: AuthIdStrategy;
+  tables: ReadonlyArray<VoidAuthMigrationTable>;
+}
+//#endregion
+//#region src/auth/providers.d.ts
+declare const VOID_SOCIAL_AUTH_PROVIDERS: readonly ["apple", "atlassian", "cognito", "discord", "dropbox", "facebook", "figma", "github", "gitlab", "google", "huggingface", "kakao", "kick", "line", "linear", "linkedin", "microsoft", "naver", "notion", "paybin", "paypal", "polar", "railway", "reddit", "roblox", "salesforce", "slack", "spotify", "tiktok", "twitch", "twitter", "vercel", "vk", "zoom"];
+declare const VOID_EMAIL_AUTH_PROVIDER = "email";
+declare const VOID_AUTH_PROVIDERS: readonly [typeof VOID_EMAIL_AUTH_PROVIDER, ...typeof VOID_SOCIAL_AUTH_PROVIDERS];
+type VoidAuthProvider = (typeof VOID_AUTH_PROVIDERS)[number];
+//#endregion
+//#region src/runtime/better-auth-shared.d.ts
+type VoidAuthDialect = "sqlite" | "postgresql";
+interface VoidAuthRuntimeOptions {
+  dialect: VoidAuthDialect;
+  providers: ReadonlyArray<VoidAuthProvider> | null;
+  userConfig?: VoidAuthConfig;
+}
+interface VoidAuthEnv extends Record<string, unknown> {
+  DB?: D1Database;
+  DATABASE_URL?: string;
+  HYPERDRIVE?: {
+    connectionString?: string;
+  };
+  BETTER_AUTH_SECRET?: string;
+  GITHUB_OAUTH_ID?: string;
+  GITHUB_OAUTH_SECRET?: string;
+  GOOGLE_OAUTH_ID?: string;
+  GOOGLE_OAUTH_SECRET?: string;
+}
+interface VoidAuthRuntimeApi {
+  resolveVoidAuthOptions(request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions, databaseOverride?: NonNullable<BetterAuthOptions["database"]>, disposeOverride?: () => Promise<void>): Promise<{
+    options: BetterAuthOptions;
+    dispose(): Promise<void>;
+  }>;
+  createVoidAuth(request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions, databaseOverride?: NonNullable<BetterAuthOptions["database"]>, disposeOverride?: () => Promise<void>): Promise<{
+    auth: ReturnType<typeof betterAuth>;
+    dispose(): Promise<void>;
+  }>;
+  resolveVoidAuthState(request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions, databaseOverride?: NonNullable<BetterAuthOptions["database"]>, disposeOverride?: () => Promise<void>): Promise<AuthState | null>;
+  runVoidAuthMiddleware(c: Context, next: () => Promise<void>, runtime: VoidAuthRuntimeOptions, databaseOverride?: NonNullable<BetterAuthOptions["database"]>, disposeOverride?: () => Promise<void>): Promise<void>;
+  handleVoidAuthRequest(c: Context, runtime: VoidAuthRuntimeOptions, databaseOverride?: NonNullable<BetterAuthOptions["database"]>, disposeOverride?: () => Promise<void>): Promise<Response>;
+  runVoidAuthMigrations(request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions, migrationSchema: VoidAuthMigrationSchema): Promise<void>;
+}
+//#endregion
+export { VoidAuthRuntimeOptions as i, VoidAuthEnv as n, VoidAuthRuntimeApi as r, VoidAuthDialect as t };

package/dist/better-auth-shared-CdYmQGry.mjs

@@ -0,0 +1,163 @@
+import { a as isVoidSocialAuthProvider, r as getVoidAuthProviderEnvNames } from "./providers-B3aMxWzP.mjs";
+import { authContext } from "./runtime/auth.mjs";
+import { betterAuth } from "better-auth";
+//#region src/runtime/better-auth-shared.ts
+function isLocalHost(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local");
+}
+function resolveSecret(request, env) {
+	const explicit = typeof env.BETTER_AUTH_SECRET === "string" && env.BETTER_AUTH_SECRET.length > 0 ? env.BETTER_AUTH_SECRET : void 0;
+	if (explicit) return explicit;
+	if (isLocalHost(new URL(request.url).hostname)) return "void-dev-better-auth-secret-1234567890";
+	throw new Error("auth: Missing Better Auth secret. Set BETTER_AUTH_SECRET.");
+}
+function readEnvString(env, ...keys) {
+	for (const key of keys) {
+		const value = env[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function resolveEmailAndPassword(configuredProviders) {
+	if (!configuredProviders || configuredProviders.includes("email")) return { enabled: true };
+}
+function resolveSocialProviderCredentials(env, provider) {
+	const envNames = getVoidAuthProviderEnvNames(provider);
+	const clientIdKeys = [envNames.clientId];
+	const clientSecretKeys = [envNames.clientSecret];
+	if (envNames.legacyClientId) clientIdKeys.push(envNames.legacyClientId);
+	if (envNames.legacyClientSecret) clientSecretKeys.push(envNames.legacyClientSecret);
+	const clientId = readEnvString(env, ...clientIdKeys);
+	const clientSecret = readEnvString(env, ...clientSecretKeys);
+	if (!clientId || !clientSecret) throw new Error(`auth: Missing credentials for provider '${provider}'. Set ${envNames.clientId} and ${envNames.clientSecret}, or remove '${provider}' from auth.providers.`);
+	return {
+		clientId,
+		clientSecret
+	};
+}
+function resolveSocialProviders(env, configuredProviders) {
+	if (!configuredProviders) return;
+	const providers = {};
+	for (const provider of configuredProviders) {
+		if (!isVoidSocialAuthProvider(provider)) continue;
+		providers[provider] = resolveSocialProviderCredentials(env, provider);
+	}
+	return Object.keys(providers).length > 0 ? providers : void 0;
+}
+function appendAuthHeaders(target, source) {
+	if (!source) return;
+	source.forEach((value, key) => {
+		if (key.toLowerCase() === "set-cookie") {
+			target.append(key, value);
+			return;
+		}
+		target.set(key, value);
+	});
+}
+function resolveUserConfig(userConfig, defaults, request, env, dialect) {
+	if (!userConfig) return defaults;
+	if (typeof userConfig === "function") return userConfig({
+		defaults,
+		request,
+		env,
+		dialect
+	});
+	return {
+		...defaults,
+		...userConfig
+	};
+}
+function assertRuntimeDialect(runtime, dialect) {
+	if (runtime.dialect !== dialect) throw new Error(`auth: Runtime mismatch. Expected ${dialect}, received '${runtime.dialect}'.`);
+}
+function createVoidAuthRuntime(dialect, resolveDatabase, runVoidAuthMigrations) {
+	async function resolveVoidAuthOptions(request, env, runtime, databaseOverride, disposeOverride) {
+		assertRuntimeDialect(runtime, dialect);
+		const { database, dispose } = databaseOverride ? {
+			database: databaseOverride,
+			dispose: disposeOverride ?? (async () => {})
+		} : await resolveDatabase(env);
+		const origin = new URL(request.url).origin;
+		const emailAndPassword = resolveEmailAndPassword(runtime.providers);
+		const socialProviders = resolveSocialProviders(env, runtime.providers);
+		const defaults = {
+			baseURL: origin,
+			basePath: "/api/auth",
+			secret: resolveSecret(request, env),
+			database,
+			...emailAndPassword ? { emailAndPassword } : {},
+			...socialProviders ? { socialProviders } : {},
+			trustedOrigins: [origin]
+		};
+		return {
+			options: resolveUserConfig(runtime.userConfig, defaults, request, env, dialect),
+			dispose
+		};
+	}
+	async function createVoidAuth(request, env, runtime, databaseOverride, disposeOverride) {
+		const { options, dispose } = await resolveVoidAuthOptions(request, env, runtime, databaseOverride, disposeOverride);
+		return {
+			auth: betterAuth(options),
+			dispose
+		};
+	}
+	async function resolveVoidAuthState(request, env, runtime, databaseOverride, disposeOverride) {
+		const { auth, dispose } = await createVoidAuth(request, env, runtime, databaseOverride, disposeOverride);
+		try {
+			return (await auth.api.getSession({
+				headers: request.headers,
+				asResponse: false,
+				returnHeaders: true
+			})).response ?? null;
+		} finally {
+			await dispose();
+		}
+	}
+	async function runVoidAuthMiddleware(c, next, runtime, databaseOverride, disposeOverride) {
+		if (c.req.path.startsWith("/__")) {
+			c.set("user", null);
+			c.set("session", null);
+			return next();
+		}
+		const { auth, dispose } = await createVoidAuth(c.req.raw, c.env, runtime, databaseOverride, disposeOverride);
+		c.set("__voidAuth", auth);
+		try {
+			const result = await auth.api.getSession({
+				headers: c.req.raw.headers,
+				asResponse: false,
+				returnHeaders: true
+			});
+			const state = result.response ?? null;
+			c.set("user", state?.user ?? null);
+			c.set("session", state?.session ?? null);
+			await authContext.run({
+				user: state?.user ?? null,
+				state
+			}, async () => {
+				await next();
+			});
+			appendAuthHeaders(c.res.headers, result.headers);
+		} finally {
+			await dispose();
+		}
+	}
+	async function handleVoidAuthRequest(c, runtime, databaseOverride, disposeOverride) {
+		const existingAuth = c.get("__voidAuth");
+		if (existingAuth) return existingAuth.handler(c.req.raw);
+		const { auth, dispose } = await createVoidAuth(c.req.raw, c.env, runtime, databaseOverride, disposeOverride);
+		try {
+			return await auth.handler(c.req.raw);
+		} finally {
+			await dispose();
+		}
+	}
+	return {
+		resolveVoidAuthOptions,
+		createVoidAuth,
+		resolveVoidAuthState,
+		runVoidAuthMiddleware,
+		handleVoidAuthRequest,
+		runVoidAuthMigrations
+	};
+}
+//#endregion
+export { createVoidAuthRuntime as t };