void 0.10.5 → 0.10.6

package/dist/drizzle-DqstQTGq.mjs

@@ -1,232 +0,0 @@
-import { a as isVoidSocialAuthProvider } from "./providers-BwPbdHdi.mjs";
-import { getAuthTables, getSchema } from "better-auth/db";
-//#region src/auth/drizzle.ts
-const DEFAULT_TABLE_ORDER = Number.MAX_SAFE_INTEGER;
-function resolveEmailAndPassword(configuredProviders) {
-	if (!configuredProviders || configuredProviders.includes("email")) return { enabled: true };
-}
-function resolvePlaceholderSocialProviders(configuredProviders) {
-	if (!configuredProviders) return;
-	const providers = {};
-	for (const provider of configuredProviders) {
-		if (!isVoidSocialAuthProvider(provider)) continue;
-		providers[provider] = {
-			clientId: `void-${provider}-client-id`,
-			clientSecret: `void-${provider}-client-secret`
-		};
-	}
-	return Object.keys(providers).length > 0 ? providers : void 0;
-}
-function resolveSchemaUserConfig(userConfig, defaults, dialect, env) {
-	if (!userConfig) return defaults;
-	if (typeof userConfig === "function") return userConfig({
-		defaults,
-		request: new Request("http://localhost/api/auth"),
-		env,
-		dialect
-	});
-	return {
-		...defaults,
-		...userConfig
-	};
-}
-function resolveSchemaOptions(runtime, env) {
-	const origin = "http://localhost";
-	const emailAndPassword = resolveEmailAndPassword(runtime.providers);
-	const socialProviders = resolvePlaceholderSocialProviders(runtime.providers);
-	const defaults = {
-		baseURL: origin,
-		basePath: "/api/auth",
-		secret: "void-build-better-auth-secret",
-		database: {},
-		trustedOrigins: [origin],
-		...emailAndPassword ? { emailAndPassword } : {},
-		...socialProviders ? { socialProviders } : {}
-	};
-	return resolveSchemaUserConfig(runtime.userConfig, defaults, runtime.dialect, env);
-}
-function resolveIdStrategy(options) {
-	const generateId = options.advanced?.database?.generateId;
-	if (generateId === "serial") return "serial";
-	if (generateId === "uuid") return "uuid";
-	return "text";
-}
-function sanitizeIdentifier(name) {
-	const value = name.replace(/[^A-Za-z0-9_$]/g, "_");
-	return /^[A-Za-z_$]/.test(value) ? value : `_${value}`;
-}
-function isJsonField(field) {
-	return field.type === "json" || field.type === "string[]" || field.type === "number[]";
-}
-function renderEnumValues(values) {
-	return `[${values.map((value) => JSON.stringify(value)).join(", ")}] as const`;
-}
-function resolveFieldName(defaultFieldName, field) {
-	return field.fieldName ?? defaultFieldName;
-}
-function resolveReferenceFieldName(schema, model, field) {
-	if (field === "id") return "id";
-	const referencedField = schema[model]?.fields[field];
-	return referencedField ? resolveFieldName(field, referencedField) : field;
-}
-function createColumnBuilder(dialect, idStrategy, fieldName, field) {
-	const useIdType = fieldName === "id" || field.references?.field === "id";
-	if (dialect === "postgresql") {
-		if (useIdType) {
-			if (idStrategy === "serial") return `integer(${JSON.stringify(fieldName)})`;
-			if (idStrategy === "uuid") return `uuid(${JSON.stringify(fieldName)})`;
-			return `text(${JSON.stringify(fieldName)})`;
-		}
-		if (Array.isArray(field.type)) return `text(${JSON.stringify(fieldName)}, { enum: ${renderEnumValues(field.type)} })`;
-		if (isJsonField(field)) return `jsonb(${JSON.stringify(fieldName)})`;
-		switch (field.type) {
-			case "boolean": return `boolean(${JSON.stringify(fieldName)})`;
-			case "date": return `timestamp(${JSON.stringify(fieldName)}, { mode: "date", withTimezone: true })`;
-			case "number": return field.bigint ? `bigint(${JSON.stringify(fieldName)}, { mode: "number" })` : `integer(${JSON.stringify(fieldName)})`;
-			case "string": return `text(${JSON.stringify(fieldName)})`;
-			default: return `text(${JSON.stringify(fieldName)})`;
-		}
-	}
-	if (useIdType) {
-		if (idStrategy === "serial") return `integer(${JSON.stringify(fieldName)})`;
-		return `text(${JSON.stringify(fieldName)})`;
-	}
-	if (Array.isArray(field.type)) return `text(${JSON.stringify(fieldName)}, { enum: ${renderEnumValues(field.type)} })`;
-	if (isJsonField(field)) return `text(${JSON.stringify(fieldName)}, { mode: "json" })`;
-	switch (field.type) {
-		case "boolean": return `integer(${JSON.stringify(fieldName)}, { mode: "boolean" })`;
-		case "date": return `integer(${JSON.stringify(fieldName)}, { mode: "timestamp_ms" })`;
-		case "number": return `integer(${JSON.stringify(fieldName)})`;
-		case "string": return `text(${JSON.stringify(fieldName)})`;
-		default: return `text(${JSON.stringify(fieldName)})`;
-	}
-}
-function createColumnDefinition(dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field) {
-	const actualFieldName = resolveFieldName(defaultFieldName, field);
-	const parts = [createColumnBuilder(dialect, idStrategy, actualFieldName, field)];
-	if (actualFieldName === "id") parts.push(".primaryKey()");
-	if (field.required !== false || actualFieldName === "id") parts.push(".notNull()");
-	if (field.references) {
-		const referenceModel = Object.entries(schema).find(([_, value]) => value.modelName === field.references?.model)?.[0] ?? field.references.model;
-		const referenceVariable = defaultToVariable.get(referenceModel);
-		if (referenceVariable) {
-			const referenceFieldName = resolveReferenceFieldName(schema, referenceModel, field.references.field);
-			parts.push(`.references(() => ${referenceVariable}[${JSON.stringify(referenceFieldName)}], { onDelete: ${JSON.stringify(field.references.onDelete ?? "cascade")} })`);
-		}
-	}
-	if (field.unique && actualFieldName !== "id") parts.push(".unique()");
-	return parts.join("");
-}
-function collectCoreImports(dialect, schema, idStrategy) {
-	const imports = new Set([dialect === "postgresql" ? "pgTable" : "sqliteTable", "text"]);
-	if (idStrategy === "serial") imports.add("integer");
-	if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
-	for (const [, table] of Object.entries(schema)) for (const [defaultFieldName, field] of Object.entries(table.fields)) {
-		if (resolveFieldName(defaultFieldName, field) === "id" || field.references?.field === "id") {
-			if (idStrategy === "serial") imports.add("integer");
-			if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
-			continue;
-		}
-		if (field.index) imports.add("index");
-		if (Array.isArray(field.type) || field.type === "string") {
-			imports.add("text");
-			continue;
-		}
-		if (isJsonField(field)) {
-			imports.add(dialect === "postgresql" ? "jsonb" : "text");
-			continue;
-		}
-		if (field.type === "boolean") {
-			imports.add(dialect === "postgresql" ? "boolean" : "integer");
-			continue;
-		}
-		if (field.type === "date") {
-			imports.add(dialect === "postgresql" ? "timestamp" : "integer");
-			continue;
-		}
-		if (field.type === "number") {
-			imports.add("integer");
-			if (field.bigint && dialect === "postgresql") imports.add("bigint");
-		}
-	}
-	return [...imports].sort();
-}
-function generateVoidAuthDrizzleSchema(runtime, env = {}) {
-	const options = resolveSchemaOptions(runtime, env);
-	const schema = getAuthTables(options);
-	const migrationSchema = resolveVoidAuthMigrationSchema(runtime, env);
-	const idStrategy = resolveIdStrategy(options);
-	const defaultToVariable = /* @__PURE__ */ new Map();
-	const entries = Object.entries(schema).sort(([, left], [, right]) => (left.order ?? DEFAULT_TABLE_ORDER) - (right.order ?? DEFAULT_TABLE_ORDER));
-	for (const [defaultModelName] of entries) defaultToVariable.set(defaultModelName, `${sanitizeIdentifier(defaultModelName)}Table`);
-	const tableFactory = runtime.dialect === "postgresql" ? "pgTable" : "sqliteTable";
-	const importPath = runtime.dialect === "postgresql" ? "void/schema-pg" : "void/schema-d1";
-	const lines = [
-		"// Auto-generated by void — do not edit",
-		`import { ${collectCoreImports(runtime.dialect, schema, idStrategy).join(", ")} } from ${JSON.stringify(importPath)};`,
-		""
-	];
-	for (const [defaultModelName, table] of entries) {
-		const variableName = defaultToVariable.get(defaultModelName);
-		const fieldEntries = Object.entries(table.fields);
-		const renderedFields = [`  "id": ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, "id", {
-			type: idStrategy === "serial" ? "number" : "string",
-			required: true
-		})},`, ...fieldEntries.map(([defaultFieldName, field]) => {
-			const actualFieldName = resolveFieldName(defaultFieldName, field);
-			return `  ${JSON.stringify(actualFieldName)}: ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field)},`;
-		})];
-		const indexedFields = fieldEntries.filter(([, field]) => field.index && !field.unique);
-		if (indexedFields.length > 0) lines.push(`export const ${variableName} = ${tableFactory}(${JSON.stringify(table.modelName)}, {`, ...renderedFields, `}, (table) => [`, ...indexedFields.map(([defaultFieldName, field]) => {
-			const actualFieldName = resolveFieldName(defaultFieldName, field);
-			return `  index(${JSON.stringify(`${table.modelName}_${actualFieldName}_idx`)}).on(table[${JSON.stringify(actualFieldName)}]),`;
-		}), `]);`);
-		else lines.push(`export const ${variableName} = ${tableFactory}(${JSON.stringify(table.modelName)}, {`, ...renderedFields, `});`);
-		lines.push("");
-	}
-	lines.push("export const schema = {");
-	for (const [defaultModelName] of entries) lines.push(`  ${JSON.stringify(defaultModelName)}: ${defaultToVariable.get(defaultModelName)},`);
-	lines.push("} as const;");
-	lines.push(`export const migrationSchema = ${JSON.stringify(migrationSchema, null, 2)} as const;`);
-	lines.push("");
-	return lines.join("\n") + "\n";
-}
-function resolveVoidAuthMigrationSchema(runtime, env = {}) {
-	const options = resolveSchemaOptions(runtime, env);
-	const schema = getSchema(options);
-	return {
-		dialect: runtime.dialect,
-		idStrategy: resolveIdStrategy(options),
-		tables: Object.entries(schema).sort(([, left], [, right]) => (left.order ?? DEFAULT_TABLE_ORDER) - (right.order ?? DEFAULT_TABLE_ORDER)).map(([name, table]) => ({
-			name,
-			order: table.order ?? DEFAULT_TABLE_ORDER,
-			fields: Object.fromEntries(Object.entries(table.fields).map(([fieldName, field]) => [fieldName, {
-				type: field.type,
-				required: field.required !== false,
-				unique: field.unique === true,
-				index: field.index === true,
-				bigint: field.bigint === true,
-				...field.references ? { references: {
-					table: field.references.model,
-					field: field.references.field,
-					...field.references.onDelete ? { onDelete: field.references.onDelete } : {}
-				} } : {}
-			}]))
-		}))
-	};
-}
-function generateVoidAuthDatabaseModule(options) {
-	const schemaImport = JSON.stringify(options.schemaImportPath);
-	const provider = options.dialect === "postgresql" ? "pg" : "sqlite";
-	return [
-		"// Auto-generated by void — do not edit",
-		`import { drizzleAdapter } from ${JSON.stringify(options.drizzleAdapterPath)};`,
-		`import { db as __voidDb } from "void/db";`,
-		`import { schema as __voidAuthSchema } from ${schemaImport};`,
-		"",
-		`export const __voidAuthDatabase = drizzleAdapter(__voidDb, { provider: ${JSON.stringify(provider)}, schema: __voidAuthSchema });`,
-		""
-	].join("\n");
-}
-//#endregion
-export { generateVoidAuthDrizzleSchema as n, resolveVoidAuthMigrationSchema as r, generateVoidAuthDatabaseModule as t };

package/dist/link-ZFmboqY3.mjs

@@ -1,47 +0,0 @@
-import { n as cliTitle, s as import_picocolors } from "./output-DeiS4oEX.mjs";
-import { d as getSiteDomain, f as getToken, n as PlatformClient } from "./client-BlbnA92X.mjs";
-import { _ as me, c as R, g as ge, y as ye } from "./dist-abzUneor.mjs";
-import { a as writeProjectConfig, r as readProjectConfig } from "./project-CH9pdo16.mjs";
-import { n as promptAndCreateProject, r as promptProjectSelection } from "./create-project-LjvkYziS.mjs";
-import { r as resolveProjectBySlug } from "./resolve-project-D4O1_fZz.mjs";
-//#region src/cli/link.ts
-async function runLink(root, slug) {
-	console.log();
-	ge(cliTitle("project link"));
-	const existing = readProjectConfig(root);
-	if (existing) {
-		R.warn(`Already linked to ${import_picocolors.default.blue(existing.slug)}.${getSiteDomain(root)}`);
-		ye("To re-link, delete .void/project.json and run again.");
-		return;
-	}
-	const token = getToken(root);
-	if (!token) {
-		me("No auth token found. Run `void auth login` first.");
-		process.exit(1);
-	}
-	const client = new PlatformClient(token, { root });
-	const projects = await client.listProjects();
-	if (slug) {
-		const config = resolveProjectBySlug(projects, slug);
-		if (!config) {
-			me(`project: No project found with slug '${slug}'.`);
-			process.exit(1);
-		}
-		writeProjectConfig(root, config);
-		ye(`Linked to ${import_picocolors.default.blue(config.slug)}.${getSiteDomain(root)}`);
-		return;
-	}
-	const result = await promptProjectSelection(projects, "Select a project:", root, { confirmExisting: true });
-	if (result.action === "create") {
-		const config = await promptAndCreateProject(root, client);
-		ye(`Created and linked to ${import_picocolors.default.blue(config.slug)}.${getSiteDomain(root)}`);
-		return;
-	}
-	writeProjectConfig(root, {
-		projectId: result.project.id,
-		slug: result.project.slug
-	});
-	ye(`Linked to ${import_picocolors.default.blue(result.project.slug)}.${getSiteDomain(root)}`);
-}
-//#endregion
-export { runLink };

package/dist/output-DeiS4oEX.mjs

@@ -1,139 +0,0 @@
-import { r as __toESM, t as __commonJSMin } from "./chunk-DJd-R1mw.mjs";
-import { c as R, f as at, h as ft } from "./dist-abzUneor.mjs";
-//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
-var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-	let formatter = (open, close, replace = open) => (input) => {
-		let string = "" + input, index = string.indexOf(close, open.length);
-		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-	};
-	let replaceClose = (string, close, replace, index) => {
-		let result = "", cursor = 0;
-		do {
-			result += string.substring(cursor, index) + replace;
-			cursor = index + close.length;
-			index = string.indexOf(close, cursor);
-		} while (~index);
-		return result + string.substring(cursor);
-	};
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1B[0m", "\x1B[0m"),
-			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-			italic: f("\x1B[3m", "\x1B[23m"),
-			underline: f("\x1B[4m", "\x1B[24m"),
-			inverse: f("\x1B[7m", "\x1B[27m"),
-			hidden: f("\x1B[8m", "\x1B[28m"),
-			strikethrough: f("\x1B[9m", "\x1B[29m"),
-			black: f("\x1B[30m", "\x1B[39m"),
-			red: f("\x1B[31m", "\x1B[39m"),
-			green: f("\x1B[32m", "\x1B[39m"),
-			yellow: f("\x1B[33m", "\x1B[39m"),
-			blue: f("\x1B[34m", "\x1B[39m"),
-			magenta: f("\x1B[35m", "\x1B[39m"),
-			cyan: f("\x1B[36m", "\x1B[39m"),
-			white: f("\x1B[37m", "\x1B[39m"),
-			gray: f("\x1B[90m", "\x1B[39m"),
-			bgBlack: f("\x1B[40m", "\x1B[49m"),
-			bgRed: f("\x1B[41m", "\x1B[49m"),
-			bgGreen: f("\x1B[42m", "\x1B[49m"),
-			bgYellow: f("\x1B[43m", "\x1B[49m"),
-			bgBlue: f("\x1B[44m", "\x1B[49m"),
-			bgMagenta: f("\x1B[45m", "\x1B[49m"),
-			bgCyan: f("\x1B[46m", "\x1B[49m"),
-			bgWhite: f("\x1B[47m", "\x1B[49m"),
-			blackBright: f("\x1B[90m", "\x1B[39m"),
-			redBright: f("\x1B[91m", "\x1B[39m"),
-			greenBright: f("\x1B[92m", "\x1B[39m"),
-			yellowBright: f("\x1B[93m", "\x1B[39m"),
-			blueBright: f("\x1B[94m", "\x1B[39m"),
-			magentaBright: f("\x1B[95m", "\x1B[39m"),
-			cyanBright: f("\x1B[96m", "\x1B[39m"),
-			whiteBright: f("\x1B[97m", "\x1B[39m"),
-			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-			bgRedBright: f("\x1B[101m", "\x1B[49m"),
-			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-		};
-	};
-	module.exports = createColors();
-	module.exports.createColors = createColors;
-}));
-//#endregion
-//#region src/cli/output.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-/**
-* CI-safe spinner wrapper. In CI environments (GitHub Actions, etc.),
-* `@clack/prompts` spinner emits DEC Private Mode cursor hide/show codes
-* (`\x1b[?25l` / `\x1b[?25h`) that render as text artifacts. This wrapper
-* replaces the spinner with plain log output in CI.
-*/
-function createSpinner() {
-	if (!at()) return ft();
-	let currentMessage = "";
-	return {
-		start(msg = "") {
-			currentMessage = msg;
-			if (msg) R.step(msg);
-		},
-		stop(msg = "") {
-			if (msg) R.info(msg);
-		},
-		message(msg = "") {
-			if (msg && msg !== currentMessage) {
-				currentMessage = msg;
-				R.step(msg);
-			}
-		},
-		cancel(msg = "") {
-			if (msg) R.warn(msg);
-		},
-		error(msg = "") {
-			if (msg) R.error(msg);
-		},
-		clear() {},
-		get isCancelled() {
-			return false;
-		}
-	};
-}
-function cliTitle(command) {
-	return import_picocolors.default.blue(`void ${command}`);
-}
-function sectionTitle(title) {
-	return import_picocolors.default.reset(import_picocolors.default.blue(title));
-}
-function categoryTitle(title) {
-	return import_picocolors.default.reset(import_picocolors.default.bold(import_picocolors.default.cyan(title)));
-}
-function dim(text) {
-	return import_picocolors.default.dim(text);
-}
-function tablePrefix() {
-	return `${import_picocolors.default.gray("│")}  `;
-}
-function helpLine(command, description) {
-	return `${import_picocolors.default.reset(command.padEnd(34))} ${import_picocolors.default.dim(description)}`;
-}
-/**
-* Ensure a timestamp string will be parsed as UTC by `new Date()`.
-* DB timestamps lack timezone info — appends 'Z' only when no
-* existing indicator (Z, z, or numeric offset) is present.
-*/
-function ensureUtc(s) {
-	const last = s.at(-1);
-	if (last === "Z" || last === "z") return s;
-	if (s.includes("+", 10)) return s;
-	if (s.lastIndexOf("-") > 9) return s;
-	return s + "Z";
-}
-//#endregion
-export { ensureUtc as a, sectionTitle as c, dim as i, tablePrefix as l, cliTitle as n, helpLine as o, createSpinner as r, import_picocolors as s, categoryTitle as t, require_picocolors as u };

package/dist/plan-aD3wRDqF.mjs

@@ -1,271 +0,0 @@
-import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
-import { t as canonicalJson } from "./canonical-json-CEyQaVDa.mjs";
-import { createHash } from "node:crypto";
-//#region src/migrations/tokenize.ts
-function* tokenizeSql(sql) {
-	const sqlLength = sql.length;
-	let index = 0;
-	let runStart = 0;
-	const flushRun = (upTo) => {
-		if (upTo > runStart) return {
-			kind: "sql",
-			start: runStart,
-			end: upTo
-		};
-	};
-	while (index < sqlLength) {
-		const character = sql[index];
-		const next = index + 1 < sqlLength ? sql[index + 1] : "";
-		if (character === "-" && next === "-") {
-			const run = flushRun(index);
-			if (run) yield run;
-			let scanIndex = index + 2;
-			while (scanIndex < sqlLength && sql[scanIndex] !== "\n") scanIndex++;
-			yield {
-				kind: "line-comment",
-				start: index,
-				end: scanIndex
-			};
-			index = scanIndex;
-			runStart = index;
-			continue;
-		}
-		if (character === "/" && next === "*") {
-			const run = flushRun(index);
-			if (run) yield run;
-			let scanIndex = index + 2;
-			while (scanIndex < sqlLength - 1 && !(sql[scanIndex] === "*" && sql[scanIndex + 1] === "/")) scanIndex++;
-			const end = Math.min(scanIndex + 2, sqlLength);
-			yield {
-				kind: "block-comment",
-				start: index,
-				end
-			};
-			index = end;
-			runStart = index;
-			continue;
-		}
-		if (character === "'") {
-			const run = flushRun(index);
-			if (run) yield run;
-			let scanIndex = index + 1;
-			while (scanIndex < sqlLength) {
-				if (sql[scanIndex] === "'" && sql[scanIndex + 1] === "'") {
-					scanIndex += 2;
-					continue;
-				}
-				if (sql[scanIndex] === "'") {
-					scanIndex++;
-					break;
-				}
-				scanIndex++;
-			}
-			yield {
-				kind: "string",
-				start: index,
-				end: scanIndex
-			};
-			index = scanIndex;
-			runStart = index;
-			continue;
-		}
-		if (character === "\"" || character === "`" || character === "[") {
-			const run = flushRun(index);
-			if (run) yield run;
-			const close = character === "[" ? "]" : character;
-			let scanIndex = index + 1;
-			while (scanIndex < sqlLength) {
-				if (close !== "]" && sql[scanIndex] === close && sql[scanIndex + 1] === close) {
-					scanIndex += 2;
-					continue;
-				}
-				if (sql[scanIndex] === close) {
-					scanIndex++;
-					break;
-				}
-				scanIndex++;
-			}
-			yield {
-				kind: "ident-quote",
-				open: character,
-				start: index,
-				end: scanIndex
-			};
-			index = scanIndex;
-			runStart = index;
-			continue;
-		}
-		index++;
-	}
-	const tail = flushRun(sqlLength);
-	if (tail) yield tail;
-}
-//#endregion
-//#region src/migrations/plan.ts
-var plan_exports = /* @__PURE__ */ __exportAll({
-	DESTRUCTIVE_PRAGMA: () => DESTRUCTIVE_PRAGMA,
-	MIGRATION_CLASSIFIER_VERSION: () => 1,
-	UNSPLIT_MULTI_STATEMENT_PRAGMA: () => UNSPLIT_MULTI_STATEMENT_PRAGMA,
-	buildMigrationPlanBundle: () => buildMigrationPlanBundle,
-	canonicalSql: () => canonicalSql,
-	classifyMigration: () => classifyMigration,
-	computeMigrationListHash: () => computeMigrationListHash,
-	hasStandalonePragma: () => hasStandalonePragma,
-	isSingleStatement: () => isSingleStatement,
-	sha256Hex: () => sha256Hex
-});
-const UNSPLIT_MULTI_STATEMENT_PRAGMA = "-- void:allow-unsplit-multi-statement";
-const DESTRUCTIVE_PRAGMA = "-- void:allow-destructive";
-function canonicalSql(sql) {
-	return (sql.charCodeAt(0) === 65279 ? sql.slice(1) : sql).replace(/\r\n?/g, "\n");
-}
-function sha256Hex(value) {
-	return `sha256:${createHash("sha256").update(value).digest("hex")}`;
-}
-function getPlanHashInput(plan) {
-	const base = {
-		classifierVersion: plan.classifierVersion,
-		dialect: plan.dialect,
-		kind: plan.kind,
-		name: plan.name,
-		sqlHash: plan.sqlHash,
-		stability: plan.stability
-	};
-	if (plan.kind === "breakpoint-framed") base.statements = plan.statements;
-	return base;
-}
-function hashPlan(plan) {
-	return sha256Hex(canonicalJson(getPlanHashInput(plan)));
-}
-function computeMigrationListHash(plans) {
-	return sha256Hex(canonicalJson(plans.map((plan) => [
-		plan.name,
-		plan.sqlHash,
-		plan.planHash
-	])));
-}
-function isStandalonePragmaLine(line, pragma) {
-	return line.trim() === pragma;
-}
-function hasStandalonePragma(sql, pragma) {
-	return canonicalSql(sql).split("\n").some((line) => isStandalonePragmaLine(line, pragma));
-}
-function isBreakpointComment(text) {
-	return text.trim() === "--> statement-breakpoint";
-}
-function splitBreakpointFramedSql(sql) {
-	const normalized = canonicalSql(sql);
-	const statements = [];
-	let cursor = 0;
-	for (const segment of tokenizeSql(normalized)) {
-		if (segment.kind !== "line-comment") continue;
-		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) {
-			const statement = normalized.slice(cursor, segment.start).trim();
-			if (statement) statements.push(statement);
-			cursor = segment.end;
-		}
-	}
-	const statement = normalized.slice(cursor).trim();
-	if (statement) statements.push(statement);
-	return statements;
-}
-function getExecutableSql(sql) {
-	let out = "";
-	for (const segment of tokenizeSql(sql)) if (segment.kind === "sql") out += sql.slice(segment.start, segment.end);
-	else out += " ".repeat(segment.end - segment.start);
-	return out;
-}
-function hasStatementBreakpointOutsideLiterals(sql) {
-	const normalized = canonicalSql(sql);
-	for (const segment of tokenizeSql(normalized)) {
-		if (segment.kind !== "line-comment") continue;
-		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) return true;
-	}
-	return false;
-}
-function isSingleStatement(sql) {
-	const normalized = canonicalSql(sql);
-	let statements = 0;
-	let inStatement = false;
-	for (const segment of tokenizeSql(normalized)) {
-		if (segment.kind === "line-comment" || segment.kind === "block-comment") continue;
-		if (segment.kind === "string" || segment.kind === "ident-quote") {
-			inStatement = true;
-			continue;
-		}
-		for (let index = segment.start; index < segment.end; index++) {
-			const character = normalized[index];
-			if (character === ";") {
-				if (inStatement) {
-					statements++;
-					inStatement = false;
-				}
-				continue;
-			}
-			if (character !== " " && character !== "	" && character !== "\n" && character !== "\r") inStatement = true;
-		}
-	}
-	if (inStatement) statements++;
-	return statements === 1;
-}
-function includesTransactionControl(sql) {
-	return getExecutableSql(sql).match(/(?:^|;)\s*(BEGIN(?:\s+(?:DEFERRED|IMMEDIATE|EXCLUSIVE|TRANSACTION))?|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)\b/i)?.[1]?.toUpperCase() ?? null;
-}
-function classifyMigration(migration) {
-	const sql = canonicalSql(migration.sql);
-	const sqlHash = sha256Hex(sql);
-	const transactionControl = includesTransactionControl(sql);
-	if (transactionControl) throw new Error(`Migration ${migration.name} contains ${transactionControl}; Void owns the stable D1 transaction boundary.`);
-	let base;
-	const warnings = [];
-	if (hasStatementBreakpointOutsideLiterals(sql)) {
-		const statements = splitBreakpointFramedSql(sql);
-		if (statements.length === 0) throw new Error(`Migration ${migration.name} has statement breakpoints but no SQL statements.`);
-		base = {
-			classifierVersion: 1,
-			dialect: "sqlite",
-			kind: "breakpoint-framed",
-			name: migration.name,
-			sqlHash,
-			stability: "stable",
-			statements
-		};
-	} else if (isSingleStatement(sql)) base = {
-		classifierVersion: 1,
-		dialect: "sqlite",
-		kind: "single-statement",
-		name: migration.name,
-		sqlHash,
-		stability: "stable"
-	};
-	else {
-		const allowLegacy = hasStandalonePragma(sql, UNSPLIT_MULTI_STATEMENT_PRAGMA);
-		warnings.push(`Migration ${migration.name} contains multiple statements without Drizzle statement breakpoints; it will run through the legacy D1 path.`);
-		base = {
-			allowLegacy,
-			classifierVersion: 1,
-			dialect: "sqlite",
-			kind: "legacy-unsplit-multi-statement",
-			name: migration.name,
-			sqlHash,
-			stability: "legacy"
-		};
-	}
-	return {
-		...base,
-		planHash: hashPlan(base),
-		...warnings.length > 0 ? { warnings } : {}
-	};
-}
-function buildMigrationPlanBundle(migrations) {
-	const plans = migrations.map((migration) => classifyMigration(migration));
-	return {
-		classifierVersion: 1,
-		destructiveValidation: "passed",
-		migrationListHash: computeMigrationListHash(plans),
-		plans,
-		protocolVersion: 2
-	};
-}
-//#endregion
-export { tokenizeSql as a, plan_exports as i, buildMigrationPlanBundle as n, classifyMigration as r, DESTRUCTIVE_PRAGMA as t };