@phake/lanework 0.1.0

package/dist-local/server/assets/dist-CMO4nMbf.js

@@ -0,0 +1,342 @@
+import { f as createAdapterFactory, p as logger } from "./auth-CtuIV0ur.js";
+//#region ../../node_modules/.bun/@better-auth+memory-adapter@1.6.20+4fd37f7b742805ac/node_modules/@better-auth/memory-adapter/dist/index.mjs
+/**
+* Case-insensitive in-memory comparison helpers.
+* Used when evaluating where clauses in the memory adapter.
+*/
+function insensitiveCompare(a, b) {
+	if (typeof a === "string" && typeof b === "string") return a.toLowerCase() === b.toLowerCase();
+	return a === b;
+}
+function insensitiveIn(recordVal, values) {
+	if (typeof recordVal !== "string") return values.includes(recordVal);
+	return values.some((v) => typeof v === "string" && recordVal.toLowerCase() === v.toLowerCase());
+}
+function insensitiveNotIn(recordVal, values) {
+	return !insensitiveIn(recordVal, values);
+}
+function insensitiveContains(recordVal, value) {
+	if (typeof recordVal !== "string" || typeof value !== "string") return false;
+	return recordVal.toLowerCase().includes(value.toLowerCase());
+}
+function insensitiveStartsWith(recordVal, value) {
+	if (typeof recordVal !== "string" || typeof value !== "string") return false;
+	return recordVal.toLowerCase().startsWith(value.toLowerCase());
+}
+function insensitiveEndsWith(recordVal, value) {
+	if (typeof recordVal !== "string" || typeof value !== "string") return false;
+	return recordVal.toLowerCase().endsWith(value.toLowerCase());
+}
+/**
+* Index a table's rows by their `id` for row-level reconciliation. Every
+* better-auth row carries an `id` (the adapter's join logic already keys on
+* `record.id`), so the id is a stable identity for the three-way merge.
+*/
+function indexById(rows) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const row of rows) byId.set(row.id, row);
+	return byId;
+}
+/**
+* Commit a transaction onto the live database with a three-way merge so a
+* concurrent write that interleaved at an `await` point survives.
+*
+* `base` is the snapshot taken when the transaction started; `clone` is that
+* snapshot after the transaction mutated it; `target` is the live database as
+* it stands now (possibly carrying concurrent writes). Replaying only the
+* `base -> clone` delta onto `target` applies the transaction's own creates,
+* updates, and deletes without disturbing rows or tables the transaction never
+* touched. A row the transaction did not change keeps the live version, so a
+* concurrent edit to a different row is preserved. A row the transaction did
+* change wins last-writer-wins over a concurrent edit to the same row, which is
+* acceptable for an in-memory development adapter; isolation is guaranteed only
+* at row/table granularity.
+*
+* `target` is mutated in place so any reference held elsewhere (for example the
+* `db` object the caller passed to `memoryAdapter`) stays valid.
+*/
+function mergeTransactionInto(target, base, clone) {
+	const models = new Set([...Object.keys(base), ...Object.keys(clone)]);
+	for (const model of models) {
+		if (!(model in clone)) {
+			delete target[model];
+			continue;
+		}
+		const baseById = indexById(base[model] ?? []);
+		const cloneRows = clone[model] ?? [];
+		const cloneById = indexById(cloneRows);
+		const liveRows = target[model] ?? [];
+		const merged = [];
+		const placed = /* @__PURE__ */ new Set();
+		for (const liveRow of liveRows) {
+			const id = liveRow.id;
+			const baseRow = baseById.get(id);
+			const cloneRow = cloneById.get(id);
+			if (baseRow !== void 0 && cloneRow === void 0) continue;
+			if (cloneRow !== void 0 && rowChanged(baseRow, cloneRow)) merged.push(cloneRow);
+			else merged.push(liveRow);
+			placed.add(id);
+		}
+		for (const cloneRow of cloneRows) if (!baseById.has(cloneRow.id) && !placed.has(cloneRow.id)) merged.push(cloneRow);
+		target[model] = merged;
+	}
+}
+/**
+* Whether the transaction mutated a row, comparing its pre-transaction
+* snapshot to its post-transaction state. Rows hold scalar columns and
+* adapter-serializable values, so JSON equality reliably tells a
+* transaction-made edit apart from an untouched row.
+*/
+function rowChanged(baseRow, cloneRow) {
+	if (baseRow === void 0) return true;
+	return JSON.stringify(baseRow) !== JSON.stringify(cloneRow);
+}
+var memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	/**
+	* Build an adapter factory whose operations read and write `activeDb`.
+	* The non-transactional adapter targets the live `db`. A transaction
+	* targets an isolated clone so its uncommitted writes are invisible to
+	* concurrent operations against the live `db`. A failed transaction leaves
+	* the live `db` untouched, and a committed one replays only its own
+	* row/table changes, so a concurrent write that interleaved at an `await`
+	* point survives either outcome. Isolation is at row/table granularity:
+	* the in-memory adapter does not serialize writes, so two operations that
+	* edit the same row resolve last-writer-wins. It is built for development
+	* and tests, not production concurrency control.
+	*/
+	const buildAdapterFactory = (activeDb) => createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			supportsArrays: true,
+			customTransformInput(props) {
+				if (props.options.advanced?.database?.generateId === "serial" && props.field === "id" && props.action === "create") return activeDb[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				const base = structuredClone(activeDb);
+				const clone = structuredClone(activeDb);
+				const result = await cb(buildAdapterFactory(clone)(lazyOptions));
+				mergeTransactionInto(activeDb, base, clone);
+				return result;
+			}
+		},
+		adapter: ({ getFieldName, getDefaultFieldName, options, getModelName }) => {
+			const applySortToRecords = (records, sortBy, model) => {
+				if (!sortBy) return records;
+				return records.sort((a, b) => {
+					const field = getFieldName({
+						model,
+						field: sortBy.field
+					});
+					const aValue = a[field];
+					const bValue = b[field];
+					let comparison = 0;
+					if (aValue == null && bValue == null) comparison = 0;
+					else if (aValue == null) comparison = -1;
+					else if (bValue == null) comparison = 1;
+					else if (typeof aValue === "string" && typeof bValue === "string") comparison = aValue.localeCompare(bValue);
+					else if (aValue instanceof Date && bValue instanceof Date) comparison = aValue.getTime() - bValue.getTime();
+					else if (typeof aValue === "number" && typeof bValue === "number") comparison = aValue - bValue;
+					else if (typeof aValue === "boolean" && typeof bValue === "boolean") comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+					else comparison = String(aValue).localeCompare(String(bValue));
+					return sortBy.direction === "asc" ? comparison : -comparison;
+				});
+			};
+			function convertWhereClause(where, model, join, select) {
+				const baseRecords = (() => {
+					const table = activeDb[model];
+					if (!table) {
+						logger.error(`[MemoryAdapter] Model ${model} not found in the DB`, Object.keys(activeDb));
+						throw new Error(`Model ${model} not found`);
+					}
+					const evalClause = (record, clause) => {
+						const { field, value, operator, mode = "sensitive" } = clause;
+						const isInsensitive = mode === "insensitive" && (typeof value === "string" || Array.isArray(value) && value.every((v) => typeof v === "string"));
+						switch (operator) {
+							case "in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								if (isInsensitive) return insensitiveIn(record[field], value);
+								return value.includes(record[field]);
+							case "not_in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								if (isInsensitive) return insensitiveNotIn(record[field], value);
+								return !value.includes(record[field]);
+							case "contains":
+								if (isInsensitive) return insensitiveContains(record[field], value);
+								return record[field]?.includes(value);
+							case "starts_with":
+								if (isInsensitive) return insensitiveStartsWith(record[field], value);
+								return record[field].startsWith(value);
+							case "ends_with":
+								if (isInsensitive) return insensitiveEndsWith(record[field], value);
+								return record[field].endsWith(value);
+							case "ne": return isInsensitive ? !insensitiveCompare(record[field], value) : record[field] !== value;
+							case "gt": return value != null && Boolean(record[field] > value);
+							case "gte": return value != null && Boolean(record[field] >= value);
+							case "lt": return value != null && Boolean(record[field] < value);
+							case "lte": return value != null && Boolean(record[field] <= value);
+							default:
+								if (isInsensitive) return insensitiveCompare(record[field], value);
+								if (value === null) return record[field] == null;
+								return record[field] === value;
+						}
+					};
+					let records = table.filter((record) => {
+						if (!where.length || where.length === 0) return true;
+						let result = evalClause(record, where[0]);
+						for (const clause of where) {
+							const clauseResult = evalClause(record, clause);
+							if (clause.connector === "OR") result = result || clauseResult;
+							else result = result && clauseResult;
+						}
+						return result;
+					});
+					if (select?.length && select.length > 0) records = records.map((record) => Object.fromEntries(Object.entries(record).filter(([key]) => select.includes(getDefaultFieldName({
+						model,
+						field: key
+					})))));
+					return records;
+				})();
+				if (!join) return baseRecords;
+				const grouped = /* @__PURE__ */ new Map();
+				const seenIds = /* @__PURE__ */ new Map();
+				for (const baseRecord of baseRecords) {
+					const baseId = String(baseRecord.id);
+					if (!grouped.has(baseId)) {
+						const nested = { ...baseRecord };
+						for (const [joinModel, joinAttr] of Object.entries(join)) {
+							const joinModelName = getModelName(joinModel);
+							if (joinAttr.relation === "one-to-one") nested[joinModelName] = null;
+							else {
+								nested[joinModelName] = [];
+								seenIds.set(`${baseId}-${joinModel}`, /* @__PURE__ */ new Set());
+							}
+						}
+						grouped.set(baseId, nested);
+					}
+					const nestedEntry = grouped.get(baseId);
+					for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const joinModelName = getModelName(joinModel);
+						const joinTable = activeDb[joinModelName];
+						if (!joinTable) {
+							logger.error(`[MemoryAdapter] JoinOption model ${joinModelName} not found in the DB`, Object.keys(activeDb));
+							throw new Error(`JoinOption model ${joinModelName} not found`);
+						}
+						const matchingRecords = joinTable.filter((joinRecord) => joinRecord[joinAttr.on.to] === baseRecord[joinAttr.on.from]);
+						if (joinAttr.relation === "one-to-one") nestedEntry[joinModelName] = matchingRecords[0] || null;
+						else {
+							const seenSet = seenIds.get(`${baseId}-${joinModel}`);
+							const limit = joinAttr.limit ?? 100;
+							let count = 0;
+							for (const matchingRecord of matchingRecords) {
+								if (count >= limit) break;
+								if (!seenSet.has(matchingRecord.id)) {
+									nestedEntry[joinModelName].push(matchingRecord);
+									seenSet.add(matchingRecord.id);
+									count++;
+								}
+							}
+						}
+					}
+				}
+				return Array.from(grouped.values());
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.generateId === "serial") data.id = activeDb[getModelName(model)].length + 1;
+					if (!activeDb[model]) activeDb[model] = [];
+					activeDb[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where, select, join }) => {
+					const res = convertWhereClause(where, model, join, select);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return null;
+						return resArray[0];
+					}
+					return res[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, select, offset, join }) => {
+					const res = convertWhereClause(where || [], model, join, select);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return [];
+						applySortToRecords(resArray, sortBy, model);
+						let paginatedRecords = resArray;
+						if (offset !== void 0) paginatedRecords = paginatedRecords.slice(offset);
+						if (limit !== void 0) paginatedRecords = paginatedRecords.slice(0, limit);
+						return paginatedRecords;
+					}
+					let table = applySortToRecords(res, sortBy, model);
+					if (offset !== void 0) table = table.slice(offset);
+					if (limit !== void 0) table = table.slice(0, limit);
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) return convertWhereClause(where, model).length;
+					return activeDb[model].length;
+				},
+				update: async ({ model, where, update }) => {
+					if (where.length === 0) return null;
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					if (where.length === 0) return;
+					const table = activeDb[model];
+					const res = convertWhereClause(where, model);
+					activeDb[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = activeDb[model];
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					activeDb[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				consumeOne: async ({ model, where }) => {
+					const table = activeDb[model];
+					const target = convertWhereClause(where, model)[0];
+					if (!target) return null;
+					activeDb[model] = table.filter((record) => record !== target);
+					return target;
+				},
+				incrementOne: async ({ model, where, increment, set }) => {
+					const target = convertWhereClause(where, model)[0];
+					if (!target) return null;
+					for (const [field, delta] of Object.entries(increment)) target[field] = (typeof target[field] === "number" ? target[field] : 0) + delta;
+					if (set) Object.assign(target, set);
+					return target;
+				},
+				updateMany: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res.length;
+				}
+			};
+		}
+	});
+	const adapterCreator = buildAdapterFactory(db);
+	return (options) => {
+		lazyOptions = options;
+		return adapterCreator(options);
+	};
+};
+//#endregion
+export { memoryAdapter };

package/dist-local/server/assets/empty-plugin-adapters-CrnNP3b2.js

@@ -0,0 +1,5 @@
+//#region ../../node_modules/.bun/@tanstack+start-server-core@1.169.15/node_modules/@tanstack/start-server-core/dist/esm/empty-plugin-adapters.js
+var pluginSerializationAdapters = [];
+var hasPluginAdapters = false;
+//#endregion
+export { hasPluginAdapters, pluginSerializationAdapters };

package/dist-local/server/assets/env-impl-DoaQIVbP.js

@@ -0,0 +1,297 @@
+//#region ../../node_modules/.bun/@better-auth+core@1.6.20+abf1b3a1f293bd86/node_modules/@better-auth/core/dist/utils/error-codes.mjs
+function defineErrorCodes(codes) {
+	return Object.fromEntries(Object.entries(codes).map(([key, value]) => [key, {
+		code: key,
+		message: value,
+		toString: () => key
+	}]));
+}
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.6.20+abf1b3a1f293bd86/node_modules/@better-auth/core/dist/error/codes.mjs
+var BASE_ERROR_CODES = defineErrorCodes({
+	USER_NOT_FOUND: "User not found",
+	FAILED_TO_CREATE_USER: "Failed to create user",
+	FAILED_TO_CREATE_SESSION: "Failed to create session",
+	FAILED_TO_UPDATE_USER: "Failed to update user",
+	FAILED_TO_GET_SESSION: "Failed to get session",
+	INVALID_PASSWORD: "Invalid password",
+	INVALID_EMAIL: "Invalid email",
+	INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+	INVALID_USER: "Invalid user",
+	SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+	PROVIDER_NOT_FOUND: "Provider not found",
+	INVALID_TOKEN: "Invalid token",
+	TOKEN_EXPIRED: "Token expired",
+	ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+	FAILED_TO_GET_USER_INFO: "Failed to get user info",
+	USER_EMAIL_NOT_FOUND: "User email not found",
+	EMAIL_NOT_VERIFIED: "Email not verified",
+	PASSWORD_TOO_SHORT: "Password too short",
+	PASSWORD_TOO_LONG: "Password too long",
+	USER_ALREADY_EXISTS: "User already exists.",
+	USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+	EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+	CHANGE_EMAIL_DISABLED: "Change email is disabled",
+	CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+	SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+	FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+	ACCOUNT_NOT_FOUND: "Account not found",
+	USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.",
+	CROSS_SITE_NAVIGATION_LOGIN_BLOCKED: "Cross-site navigation login blocked. This request appears to be a CSRF attack.",
+	VERIFICATION_EMAIL_NOT_ENABLED: "Verification email isn't enabled",
+	EMAIL_ALREADY_VERIFIED: "Email is already verified",
+	EMAIL_MISMATCH: "Email mismatch",
+	SESSION_NOT_FRESH: "Session is not fresh",
+	LINKED_ACCOUNT_ALREADY_EXISTS: "Linked account already exists",
+	INVALID_ORIGIN: "Invalid origin",
+	INVALID_CALLBACK_URL: "Invalid callbackURL",
+	INVALID_REDIRECT_URL: "Invalid redirectURL",
+	INVALID_ERROR_CALLBACK_URL: "Invalid errorCallbackURL",
+	INVALID_NEW_USER_CALLBACK_URL: "Invalid newUserCallbackURL",
+	MISSING_OR_NULL_ORIGIN: "Missing or null Origin",
+	CALLBACK_URL_REQUIRED: "callbackURL is required",
+	FAILED_TO_CREATE_VERIFICATION: "Unable to create verification",
+	FIELD_NOT_ALLOWED: "Field not allowed to be set",
+	ASYNC_VALIDATION_NOT_SUPPORTED: "Async validation is not supported",
+	VALIDATION_ERROR: "Validation Error",
+	MISSING_FIELD: "Field is required",
+	METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED: "POST method requires deferSessionRefresh to be enabled in session config",
+	BODY_MUST_BE_AN_OBJECT: "Body must be an object",
+	PASSWORD_ALREADY_SET: "User already has a password set"
+});
+//#endregion
+//#region ../../node_modules/.bun/better-call@1.3.6+68a1e3a0c4588df3/node_modules/better-call/dist/error.mjs
+function isErrorStackTraceLimitWritable() {
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === void 0) return Object.isExtensible(Error);
+	return Object.prototype.hasOwnProperty.call(desc, "writable") ? desc.writable : desc.set !== void 0;
+}
+/**
+* Hide internal stack frames from the error stack trace.
+*/
+function hideInternalStackFrames(stack) {
+	const lines = stack.split("\n    at ");
+	if (lines.length <= 1) return stack;
+	lines.splice(1, 1);
+	return lines.join("\n    at ");
+}
+/**
+* Creates a custom error class that hides stack frames.
+*/
+function makeErrorForHideStackFrame(Base, clazz) {
+	class HideStackFramesError extends Base {
+		#hiddenStack;
+		constructor(...args) {
+			if (isErrorStackTraceLimitWritable()) {
+				const limit = Error.stackTraceLimit;
+				Error.stackTraceLimit = 0;
+				super(...args);
+				Error.stackTraceLimit = limit;
+			} else super(...args);
+			const stack = (/* @__PURE__ */ new Error()).stack;
+			if (stack) this.#hiddenStack = hideInternalStackFrames(stack.replace(/^Error/, this.name));
+		}
+		get errorStack() {
+			return this.#hiddenStack;
+		}
+	}
+	Object.defineProperty(HideStackFramesError.prototype, "constructor", {
+		get() {
+			return clazz;
+		},
+		enumerable: false,
+		configurable: true
+	});
+	return HideStackFramesError;
+}
+var statusCodes = {
+	OK: 200,
+	CREATED: 201,
+	ACCEPTED: 202,
+	NO_CONTENT: 204,
+	MULTIPLE_CHOICES: 300,
+	MOVED_PERMANENTLY: 301,
+	FOUND: 302,
+	SEE_OTHER: 303,
+	NOT_MODIFIED: 304,
+	TEMPORARY_REDIRECT: 307,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_ALLOWED: 405,
+	NOT_ACCEPTABLE: 406,
+	PROXY_AUTHENTICATION_REQUIRED: 407,
+	REQUEST_TIMEOUT: 408,
+	CONFLICT: 409,
+	GONE: 410,
+	LENGTH_REQUIRED: 411,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	URI_TOO_LONG: 414,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	RANGE_NOT_SATISFIABLE: 416,
+	EXPECTATION_FAILED: 417,
+	"I'M_A_TEAPOT": 418,
+	MISDIRECTED_REQUEST: 421,
+	UNPROCESSABLE_ENTITY: 422,
+	LOCKED: 423,
+	FAILED_DEPENDENCY: 424,
+	TOO_EARLY: 425,
+	UPGRADE_REQUIRED: 426,
+	PRECONDITION_REQUIRED: 428,
+	TOO_MANY_REQUESTS: 429,
+	REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+	UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504,
+	HTTP_VERSION_NOT_SUPPORTED: 505,
+	VARIANT_ALSO_NEGOTIATES: 506,
+	INSUFFICIENT_STORAGE: 507,
+	LOOP_DETECTED: 508,
+	NOT_EXTENDED: 510,
+	NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+var InternalAPIError = class extends Error {
+	constructor(status = "INTERNAL_SERVER_ERROR", body = void 0, headers = {}, statusCode = typeof status === "number" ? status : statusCodes[status]) {
+		super(body?.message, body?.cause ? { cause: body.cause } : void 0);
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+		this.statusCode = statusCode;
+		this.name = "APIError";
+		this.status = status;
+		this.headers = headers;
+		this.statusCode = statusCode;
+		this.body = body;
+	}
+};
+var ValidationError = class extends InternalAPIError {
+	constructor(message, issues) {
+		super(400, {
+			message,
+			code: "VALIDATION_ERROR"
+		});
+		this.message = message;
+		this.issues = issues;
+		this.issues = issues;
+	}
+};
+var BetterCallError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BetterCallError";
+	}
+};
+var kAPIErrorHeaderSymbol = Symbol.for("better-call:api-error-headers");
+var APIError$1 = makeErrorForHideStackFrame(InternalAPIError, Error);
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.6.20+abf1b3a1f293bd86/node_modules/@better-auth/core/dist/error/index.mjs
+var BetterAuthError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "BetterAuthError";
+		this.message = message;
+		this.stack = "";
+	}
+};
+var APIError = class APIError extends APIError$1 {
+	constructor(...args) {
+		super(...args);
+	}
+	static fromStatus(status, body) {
+		return new APIError(status, body);
+	}
+	static from(status, error) {
+		return new APIError(status, {
+			message: error.message,
+			code: error.code
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.6.20+abf1b3a1f293bd86/node_modules/@better-auth/core/dist/env/env-impl.mjs
+var _envShim = Object.create(null);
+var _getEnv = (useShim) => globalThis.process?.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (useShim ? _envShim : globalThis);
+var env = new Proxy(_envShim, {
+	get(_, prop) {
+		return _getEnv()[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		return prop in _getEnv() || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env = _getEnv(true);
+		env[prop] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		if (!prop) return false;
+		const env = _getEnv(true);
+		delete env[prop];
+		return true;
+	},
+	ownKeys() {
+		const env = _getEnv(true);
+		return Object.keys(env);
+	}
+});
+function toBoolean(val) {
+	return val ? val !== "false" : false;
+}
+var nodeENV = env.NODE_ENV ?? "";
+/** Detect if `NODE_ENV` environment variable is `production` */
+var isProduction = nodeENV === "production";
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+var isDevelopment = () => nodeENV === "dev" || nodeENV === "development";
+/** Detect if `NODE_ENV` environment variable is `test` */
+var isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+/**
+* Get environment variable with fallback
+*/
+function getEnvVar(key, fallback) {
+	if (typeof process !== "undefined" && process.env) return process.env[key] ?? fallback;
+	if (typeof Deno !== "undefined") return Deno.env.get(key) ?? fallback;
+	if (typeof Bun !== "undefined") return Bun.env[key] ?? fallback;
+	return fallback;
+}
+/**
+* Get boolean environment variable
+*/
+function getBooleanEnvVar(key, fallback = true) {
+	const value = getEnvVar(key);
+	if (!value) return fallback;
+	return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+/**
+* Common environment variables used in Better Auth
+*/
+var ENV = Object.freeze({
+	get BETTER_AUTH_SECRET() {
+		return getEnvVar("BETTER_AUTH_SECRET");
+	},
+	get AUTH_SECRET() {
+		return getEnvVar("AUTH_SECRET");
+	},
+	get BETTER_AUTH_TELEMETRY() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY");
+	},
+	get BETTER_AUTH_TELEMETRY_ID() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+	},
+	get NODE_ENV() {
+		return getEnvVar("NODE_ENV", "development");
+	},
+	get PACKAGE_VERSION() {
+		return getEnvVar("PACKAGE_VERSION", "0.0.0");
+	},
+	get BETTER_AUTH_TELEMETRY_ENDPOINT() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ENDPOINT", "");
+	}
+});
+//#endregion
+export { isDevelopment as a, APIError as c, BetterCallError as d, ValidationError as f, getEnvVar as i, BetterAuthError as l, BASE_ERROR_CODES as m, env as n, isProduction as o, kAPIErrorHeaderSymbol as p, getBooleanEnvVar as r, isTest as s, ENV as t, APIError$1 as u };