void 0.1.6 → 0.7.0

package/dist/subcommand-prompt-BKjuNAPb.mjs

@@ -0,0 +1,349 @@
+import { s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { a as F, b as z, d as _t, m as et, o as H, r as E, s as J, t as $ } from "./dist-Dayj3gCK.mjs";
+//#region src/cli/subcommand-prompt.ts
+function promptSubcommand(command, subcommands) {
+	return new Promise((resolve) => {
+		const { stdin, stdout } = process;
+		let phase = "select";
+		let cursor = 0;
+		let input = "";
+		let prevLineCount = 0;
+		let resolved = false;
+		let selectedSub = null;
+		let selectedArg;
+		const selectedFlags = {};
+		let flagStates = [];
+		let multiSelectStates = [];
+		let repeatEntries = [];
+		let repeatInput = "";
+		const wasRaw = stdin.isRaw;
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdout.write("\x1B[?25l");
+		function clear() {
+			if (prevLineCount > 0) stdout.write(`\x1B[${prevLineCount}A\x1B[0J`);
+		}
+		function render() {
+			clear();
+			if (phase === "select") renderSelect();
+			else if (phase === "flags") renderFlags();
+			else if (phase === "multi-select") renderMultiSelect();
+			else renderRepeatInput();
+		}
+		const title = command ? `void ${command}` : "void";
+		function headerLine() {
+			const argPart = selectedArg ? ` ${selectedArg}` : "";
+			return `${import_picocolors.default.cyan(_t)}  ${import_picocolors.default.cyan(title)} ${import_picocolors.default.dim("·")} ${import_picocolors.default.cyan(`${selectedSub.name}${argPart}`)}`;
+		}
+		function renderSelect() {
+			const lines = [];
+			const focused = subcommands[cursor];
+			lines.push(`${import_picocolors.default.cyan(_t)}  ${import_picocolors.default.cyan(title)}`);
+			lines.push(import_picocolors.default.gray($));
+			const maxName = Math.max(...subcommands.map((s) => s.name.length));
+			for (let i = 0; i < subcommands.length; i++) {
+				const sub = subcommands[i];
+				const isFocused = i === cursor;
+				const radio = isFocused ? import_picocolors.default.green(z) : import_picocolors.default.dim(H);
+				const name = sub.name.padEnd(maxName);
+				let suffix = "";
+				if (sub.arg) if (isFocused && input.length > 0) suffix = `  ${import_picocolors.default.cyan(input)}`;
+				else suffix = `  ${import_picocolors.default.dim(sub.arg)}`;
+				else if (sub.hint) suffix = `  ${import_picocolors.default.dim(sub.hint)}`;
+				if (isFocused) lines.push(`${import_picocolors.default.gray($)}  ${radio} ${import_picocolors.default.reset(name)}${suffix}`);
+				else lines.push(`${import_picocolors.default.gray($)}  ${radio} ${import_picocolors.default.dim(name)}${suffix}`);
+			}
+			lines.push(import_picocolors.default.gray($));
+			lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(focused.description)}`);
+			if (focused.arg) if (focused.arg.startsWith("<")) lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(`Type ${focused.arg}, then press Enter`)}`);
+			else lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(`Type ${focused.arg}, then press Enter, or press Enter to skip`)}`);
+			lines.push(import_picocolors.default.gray(E));
+			stdout.write(lines.join("\n") + "\n");
+			prevLineCount = lines.length;
+		}
+		function renderFlags() {
+			const flags = selectedSub.flags;
+			const focused = flags[cursor];
+			const lines = [];
+			lines.push(headerLine());
+			lines.push(import_picocolors.default.gray($));
+			const maxFlag = Math.max(...flags.map((f) => f.name.length));
+			for (let i = 0; i < flags.length; i++) {
+				const flag = flags[i];
+				const state = flagStates[i];
+				const isFocused = i === cursor;
+				const checkbox = state.enabled ? import_picocolors.default.green(et) : isFocused ? J : import_picocolors.default.dim(J);
+				const name = flag.name.padEnd(maxFlag);
+				let valueText = "";
+				if (flag.arg) if (state.enabled && state.value.length > 0) valueText = `  ${isFocused ? import_picocolors.default.cyan(state.value) : import_picocolors.default.dim(state.value)}`;
+				else valueText = `  ${import_picocolors.default.dim(flag.arg)}`;
+				if (isFocused) lines.push(`${import_picocolors.default.gray($)}  ${checkbox} ${import_picocolors.default.reset(name)}${valueText}`);
+				else lines.push(`${import_picocolors.default.gray($)}  ${checkbox} ${import_picocolors.default.dim(name)}${valueText}`);
+			}
+			lines.push(import_picocolors.default.gray($));
+			lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(focused.description)}`);
+			lines.push(import_picocolors.default.gray(E));
+			stdout.write(lines.join("\n") + "\n");
+			prevLineCount = lines.length;
+		}
+		function renderMultiSelect() {
+			const options = selectedSub.followUp.options;
+			const lines = [];
+			lines.push(headerLine());
+			lines.push(import_picocolors.default.gray($));
+			const maxLabel = Math.max(...options.map((o) => o.label.length));
+			for (let i = 0; i < options.length; i++) {
+				const opt = options[i];
+				const selected = multiSelectStates[i];
+				const isFocused = i === cursor;
+				const checkbox = selected ? import_picocolors.default.green(et) : isFocused ? J : import_picocolors.default.dim(J);
+				const label = opt.label.padEnd(maxLabel);
+				if (isFocused) lines.push(`${import_picocolors.default.gray($)}  ${checkbox} ${import_picocolors.default.reset(label)}`);
+				else lines.push(`${import_picocolors.default.gray($)}  ${checkbox} ${import_picocolors.default.dim(label)}`);
+			}
+			lines.push(import_picocolors.default.gray($));
+			lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim("space to toggle, enter to confirm")}`);
+			lines.push(import_picocolors.default.gray(E));
+			stdout.write(lines.join("\n") + "\n");
+			prevLineCount = lines.length;
+		}
+		function renderRepeatInput() {
+			const followUp = selectedSub.followUp;
+			const lines = [];
+			lines.push(headerLine());
+			lines.push(import_picocolors.default.gray($));
+			for (const entry of repeatEntries) lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(entry)}`);
+			if (repeatInput.length > 0) lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.cyan(repeatInput)}`);
+			else lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim(followUp.placeholder)}`);
+			lines.push(import_picocolors.default.gray($));
+			lines.push(`${import_picocolors.default.gray($)}  ${import_picocolors.default.dim("enter to add, empty to finish")}`);
+			lines.push(import_picocolors.default.gray(E));
+			stdout.write(lines.join("\n") + "\n");
+			prevLineCount = lines.length;
+		}
+		function cleanup() {
+			if (resolved) return;
+			resolved = true;
+			stdin.setRawMode(wasRaw);
+			stdin.pause();
+			stdin.removeListener("data", onData);
+			stdout.write("\x1B[?25h");
+		}
+		function submit(result) {
+			cleanup();
+			clear();
+			if (result) {
+				let summary = result.subcommand;
+				if (result.arg) summary += ` ${result.arg}`;
+				if (result.flags) for (const [flag, value] of Object.entries(result.flags)) {
+					summary += ` ${flag}`;
+					if (typeof value === "string") summary += ` ${value}`;
+				}
+				if (result.extraArgs && result.extraArgs.length > 0) summary += ` ${result.extraArgs.join(" ")}`;
+				stdout.write(`${import_picocolors.default.gray(F)}  ${import_picocolors.default.dim(title)} ${import_picocolors.default.dim("·")} ${import_picocolors.default.dim(summary)}\n`);
+			}
+			resolve(result);
+		}
+		function finalize() {
+			const result = {
+				subcommand: selectedSub.name,
+				arg: selectedArg
+			};
+			if (Object.keys(selectedFlags).length > 0) result.flags = { ...selectedFlags };
+			if (repeatEntries.length > 0) result.extraArgs = repeatEntries;
+			submit(result);
+		}
+		function advancePhase() {
+			if (phase === "select" && selectedSub.flags && selectedSub.flags.length > 0) {
+				phase = "flags";
+				cursor = 0;
+				flagStates = selectedSub.flags.map(() => ({
+					enabled: false,
+					value: ""
+				}));
+				render();
+				return;
+			}
+			if ((phase === "select" || phase === "flags") && selectedSub.followUp) {
+				const followUp = selectedSub.followUp;
+				if (followUp.type === "multi-select") {
+					phase = "multi-select";
+					cursor = 0;
+					multiSelectStates = followUp.options.map((o) => !!o.selected);
+					render();
+					return;
+				}
+				if (followUp.type === "repeat-input") {
+					phase = "repeat-input";
+					repeatEntries = [];
+					repeatInput = "";
+					render();
+					return;
+				}
+			}
+			finalize();
+		}
+		function handleSelectKey(key) {
+			const focused = subcommands[cursor];
+			if (key === "\x1B[A" || key === "\x1BOA") {
+				cursor = cursor === 0 ? subcommands.length - 1 : cursor - 1;
+				input = "";
+				render();
+				return;
+			}
+			if (key === "\x1B[B" || key === "\x1BOB") {
+				cursor = (cursor + 1) % subcommands.length;
+				input = "";
+				render();
+				return;
+			}
+			if (key === "\r" || key === "\n") {
+				if (focused.arg && focused.arg.startsWith("<") && input.length === 0) return;
+				selectedSub = focused;
+				selectedArg = focused.arg ? input || void 0 : void 0;
+				clear();
+				advancePhase();
+				return;
+			}
+			if (key === "" || key === "\b") {
+				if (focused.arg && input.length > 0) {
+					input = input.slice(0, -1);
+					render();
+				}
+				return;
+			}
+			if (focused.arg && key.length === 1 && key >= " ") {
+				input += key;
+				render();
+			}
+		}
+		function handleFlagKey(key) {
+			const flags = selectedSub.flags;
+			const focused = flags[cursor];
+			const state = flagStates[cursor];
+			if (key === "\x1B[A" || key === "\x1BOA") {
+				cursor = cursor === 0 ? flags.length - 1 : cursor - 1;
+				render();
+				return;
+			}
+			if (key === "\x1B[B" || key === "\x1BOB") {
+				cursor = (cursor + 1) % flags.length;
+				render();
+				return;
+			}
+			if (key === " ") {
+				state.enabled = !state.enabled;
+				if (!state.enabled) state.value = "";
+				render();
+				return;
+			}
+			if (key === "\r" || key === "\n") {
+				for (let i = 0; i < flags.length; i++) if (flagStates[i].enabled && flags[i].arg && flagStates[i].value.length === 0) return;
+				for (let i = 0; i < flags.length; i++) if (flagStates[i].enabled) selectedFlags[flags[i].name] = flags[i].arg ? flagStates[i].value : true;
+				clear();
+				advancePhase();
+				return;
+			}
+			if (key === "" || key === "\b") {
+				if (focused.arg && state.enabled && state.value.length > 0) {
+					state.value = state.value.slice(0, -1);
+					render();
+				}
+				return;
+			}
+			if (focused.arg && key.length === 1 && key >= " ") {
+				if (!state.enabled) state.enabled = true;
+				state.value += key;
+				render();
+			}
+		}
+		function handleMultiSelectKey(key) {
+			const followUp = selectedSub.followUp;
+			const options = followUp.options;
+			if (key === "\x1B[A" || key === "\x1BOA") {
+				cursor = cursor === 0 ? options.length - 1 : cursor - 1;
+				render();
+				return;
+			}
+			if (key === "\x1B[B" || key === "\x1BOB") {
+				cursor = (cursor + 1) % options.length;
+				render();
+				return;
+			}
+			if (key === " ") {
+				multiSelectStates[cursor] = !multiSelectStates[cursor];
+				render();
+				return;
+			}
+			if (key === "\r" || key === "\n") {
+				const selected = options.filter((_, i) => multiSelectStates[i]);
+				if (selected.length === 0) return;
+				selectedFlags[followUp.flag] = selected.map((o) => o.value).join(",");
+				clear();
+				finalize();
+				return;
+			}
+		}
+		function handleRepeatInputKey(key) {
+			if (key === "\r" || key === "\n") {
+				if (repeatInput.length > 0) {
+					repeatEntries.push(repeatInput);
+					repeatInput = "";
+					render();
+				} else {
+					clear();
+					finalize();
+				}
+				return;
+			}
+			if (key === "" || key === "\b") {
+				if (repeatInput.length > 0) {
+					repeatInput = repeatInput.slice(0, -1);
+					render();
+				}
+				return;
+			}
+			if (key.length === 1 && key >= " ") {
+				repeatInput += key;
+				render();
+			}
+		}
+		function handleKey(key) {
+			if (resolved) return;
+			if (phase === "select") handleSelectKey(key);
+			else if (phase === "flags") handleFlagKey(key);
+			else if (phase === "multi-select") handleMultiSelectKey(key);
+			else handleRepeatInputKey(key);
+		}
+		function onData(data) {
+			if (resolved) return;
+			const key = data.toString();
+			if (key === "") {
+				submit(null);
+				return;
+			}
+			if (key === "\x1B" && data.length === 1) {
+				submit(null);
+				return;
+			}
+			if (key.startsWith("\x1B")) {
+				handleKey(key);
+				return;
+			}
+			for (const char of key) {
+				if (char === "") {
+					submit(null);
+					return;
+				}
+				handleKey(char);
+			}
+		}
+		stdin.on("data", onData);
+		process.on("exit", () => {
+			if (!resolved) stdout.write("\x1B[?25h");
+		});
+		render();
+	});
+}
+//#endregion
+export { promptSubcommand };

package/dist/sveltekit.d.mts

@@ -0,0 +1,20 @@
+//#region src/sveltekit.d.ts
+type Tsconfig = Record<string, unknown>;
+type TsconfigHook = (config: Tsconfig) => Tsconfig | void;
+interface VoidSvelteKitTsconfigOptions {
+  /** Project root. Defaults to process.cwd(). */
+  root?: string;
+  /** SvelteKit output directory. Defaults to ".svelte-kit". */
+  outDir?: string;
+}
+/**
+* Merge Void's generated tsconfig fragment into SvelteKit's generated
+* tsconfig. Use from `kit.typescript.config` in `svelte.config.js`.
+*/
+declare function mergeVoidSvelteKitTsconfig(config: Tsconfig, options?: VoidSvelteKitTsconfigOptions): Tsconfig;
+/**
+* Compose a user SvelteKit tsconfig hook with Void's generated type aliases.
+*/
+declare function withVoidTSConfig(hook?: TsconfigHook, options?: VoidSvelteKitTsconfigOptions): TsconfigHook;
+//#endregion
+export { VoidSvelteKitTsconfigOptions, mergeVoidSvelteKitTsconfig, withVoidTSConfig };

package/dist/sveltekit.mjs

@@ -0,0 +1,61 @@
+import { a as join, i as isAbsolute, o as relative, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/sveltekit.ts
+/**
+* Merge Void's generated tsconfig fragment into SvelteKit's generated
+* tsconfig. Use from `kit.typescript.config` in `svelte.config.js`.
+*/
+function mergeVoidSvelteKitTsconfig(config, options = {}) {
+	const root = options.root ?? process.cwd();
+	const voidDir = join(root, ".void");
+	const voidTsconfigPath = join(voidDir, "tsconfig.json");
+	if (!existsSync(voidTsconfigPath)) return config;
+	const voidConfig = JSON.parse(readFileSync(voidTsconfigPath, "utf-8"));
+	const outputDir = resolve(root, options.outDir ?? ".svelte-kit");
+	const voidFiles = Array.isArray(voidConfig.files) ? voidConfig.files.filter((entry) => typeof entry === "string") : [];
+	if (voidFiles.length > 0) config.files = uniqueStrings([...Array.isArray(config.files) ? config.files.filter((entry) => typeof entry === "string") : [], ...voidFiles.map((entry) => relativeFrom(outputDir, resolveTsconfigEntry(voidDir, entry)))]);
+	const voidPaths = readPathMap(readObject(readObject(voidConfig.compilerOptions)?.paths));
+	if (Object.keys(voidPaths).length > 0) {
+		const paths = ensureObject(ensureObject(config, "compilerOptions"), "paths");
+		for (const [key, values] of Object.entries(voidPaths)) paths[key] = values.map((entry) => relativeFrom(outputDir, resolveTsconfigEntry(voidDir, entry)));
+	}
+	return config;
+}
+/**
+* Compose a user SvelteKit tsconfig hook with Void's generated type aliases.
+*/
+function withVoidTSConfig(hook, options) {
+	return (config) => mergeVoidSvelteKitTsconfig(hook?.(config) ?? config, options);
+}
+function readObject(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function ensureObject(target, key) {
+	const current = readObject(target[key]);
+	if (current) return current;
+	const next = {};
+	target[key] = next;
+	return next;
+}
+function readPathMap(value) {
+	const result = {};
+	if (!value) return result;
+	for (const [key, entries] of Object.entries(value)) {
+		if (!Array.isArray(entries)) continue;
+		const strings = entries.filter((entry) => typeof entry === "string");
+		if (strings.length > 0) result[key] = strings;
+	}
+	return result;
+}
+function resolveTsconfigEntry(baseDir, entry) {
+	return isAbsolute(entry) ? entry : resolve(baseDir, entry);
+}
+function relativeFrom(fromDir, target) {
+	const value = relative(fromDir, target).replace(/\\/g, "/");
+	return value.startsWith(".") ? value : `./${value}`;
+}
+function uniqueStrings(values) {
+	return Array.from(new Set(values));
+}
+//#endregion
+export { mergeVoidSvelteKitTsconfig, withVoidTSConfig };

package/dist/types-mHOEwpW4.d.mts

@@ -0,0 +1,57 @@
+//#region src/pages/types.d.ts
+interface PageDefinition {
+  /** URL pattern, e.g. "/users/:id" */
+  pattern: string;
+  /** Route params, e.g. ["id"] */
+  params: Array<string>;
+  /** Whether this is a catch-all route */
+  catchAll: boolean;
+  /** Component file relative path, e.g. "users/[id].vue" */
+  componentPath: string;
+  /** Server handler file relative path, e.g. "users/[id].server.ts" */
+  serverPath: string | null;
+  /** HTTP methods exported by server handler */
+  methods: Array<string>;
+  /** Component ID used in page object, e.g. "users/[id]" */
+  componentId: string;
+  /** Edge caching revalidate TTL in seconds, from .server.ts export */
+  revalidate?: number;
+  /** Whether `export const prerender = true` is set in server handler */
+  prerender?: boolean;
+  /** Whether `export function getPrerenderPaths` is defined in server handler */
+  hasGetPrerenderPaths?: boolean;
+  /** Whether this is an island page (.island.tsx/.island.vue) */
+  island?: boolean;
+  /** Frontmatter metadata extracted from .md files (title, description) */
+  metadata?: {
+    title?: string;
+    description?: string;
+  };
+  /** Named layout selection: "name", "!name", false, or relative path */
+  layout?: string | false;
+}
+interface LayoutDefinition {
+  /** Directory path relative to pages/, e.g. "" (root) or "users" */
+  directory: string;
+  /** Layout file relative path, e.g. "layout.vue" or "users/layout.vue" */
+  filePath: string;
+  /** Whether this is an island layout (layout.island.tsx/.island.vue) */
+  island?: boolean;
+}
+interface NamedLayoutDefinition {
+  /** Layout name, e.g. "home", "post" */
+  name: string;
+  /** Directory containing _layouts/, e.g. "" (root) or "guide" */
+  directory: string;
+  /** File path relative to pages/, e.g. "_layouts/home.vue" */
+  filePath: string;
+  /** Whether this is an island layout */
+  island?: boolean;
+}
+interface PageScanResult {
+  pages: Array<PageDefinition>;
+  layouts: Array<LayoutDefinition>;
+  namedLayouts: Array<NamedLayoutDefinition>;
+}
+//#endregion
+export { PageScanResult as i, NamedLayoutDefinition as n, PageDefinition as r, LayoutDefinition as t };

package/dist/validate-CaMavMxu.mjs

@@ -0,0 +1,146 @@
+import { n as __exportAll } from "./chunk-DJd-R1mw.mjs";
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { i as stripSqlExt, r as readJournal } from "./collect-CjeZgz5D.mjs";
+import { existsSync, readdirSync } from "node:fs";
+//#region src/migrations/validate.ts
+var validate_exports = /* @__PURE__ */ __exportAll({
+	assertJournalCoherence: () => assertJournalCoherence,
+	isDestructive: () => isDestructive,
+	listDrizzleArtifacts: () => listDrizzleArtifacts,
+	validateMigrations: () => validateMigrations
+});
+/**
+* Destructive SQL patterns that are rejected unless the migration
+* contains the `-- void:allow-destructive` pragma comment.
+*/
+const DESTRUCTIVE_PATTERNS = [
+	/\bDROP\s+TABLE\b/i,
+	/\bDROP\s+COLUMN\b/i,
+	/\bALTER\s+TABLE\s+\S+\s+RENAME\b/i,
+	/\bTRUNCATE\b/i
+];
+const PRAGMA_COMMENT = "-- void:allow-destructive";
+/**
+* Check if a SQL migration contains destructive operations.
+*/
+function isDestructive(sql) {
+	return DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(sql));
+}
+/**
+* Validate migration files. Returns the validated list with destructive flags.
+* Throws if any destructive migration lacks the allow-destructive pragma.
+*/
+function validateMigrations(files) {
+	const results = [];
+	const errors = [];
+	for (const file of files) {
+		const destructive = isDestructive(file.sql);
+		if (destructive && !file.sql.includes(PRAGMA_COMMENT)) errors.push(file.name);
+		results.push({
+			name: file.name,
+			sql: file.sql,
+			destructive
+		});
+	}
+	if (errors.length > 0) throw new Error(`Destructive migrations detected without pragma:\n` + errors.map((f) => `  - ${f}`).join("\n") + `\n\nAdd "${PRAGMA_COMMENT}" to each file to allow the migration locally and on deploy.`);
+	return results;
+}
+/**
+* Enumerate drizzle-kit metadata artifacts in a migrations directory.
+* Returns repo-relative paths like `db/migrations/meta/0000_snapshot.json`
+* and `db/migrations/migrations.js`. Empty when none are present.
+*
+* Shared across `assertJournalCoherence`, `void gen migration`, and
+* `void db rename-migrations` so all three agree on what counts as a
+* "partial drizzle-kit state" (journal gone but other metadata lingering).
+*/
+function listDrizzleArtifacts(migrationsDir) {
+	const metaDir = join(migrationsDir, "meta");
+	const snapshotFiles = existsSync(metaDir) ? readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json")) : [];
+	const bundledPath = join(migrationsDir, "migrations.js");
+	const out = [];
+	for (const f of snapshotFiles) out.push(`db/migrations/meta/${f}`);
+	if (existsSync(bundledPath)) out.push("db/migrations/migrations.js");
+	return out;
+}
+/**
+* Assert that every `.sql` file under `migrationsDir` has a matching entry
+* in `meta/_journal.json`, and vice versa.
+*
+* Drift is a silent footgun: the local/remote runners apply files directly
+* from disk, but `drizzle-kit generate` only sees what's in the journal.
+* An orphan file created by hand (or by a botched scaffold/merge) gets
+* applied to D1 without Drizzle ever acknowledging it, and a failed
+* deploy can leave the database in a state that is impossible to recover
+* from without manual SQL edits (see void-sdk/void#6).
+*
+* A missing journal is NOT a drift error. The drift check is a diff
+* between disk and `meta/_journal.json`; with no journal, there is nothing
+* to diff against. Bare-legacy projects — hand-written `.sql` files with no
+* `db/schema.ts`, no drizzle-kit, no `meta/` directory — worked long
+* before this check existed, and the local/remote runners still track
+* applied migrations by filename via `_void_migrations`. Gating those
+* projects here would break `void deploy`, `void db migrate`, `void db
+* reset`, and `void db status` for a valid path with no migration path
+* forward (they cannot run `void db generate` because it requires
+* `db/schema.ts`). We skip the check silently and let the filename-based
+* runners take over.
+*
+* Throws a user-facing error when any mismatch is detected between the
+* journal and disk. Returns silently otherwise.
+*/
+function assertJournalCoherence(migrationsDir, collected) {
+	const journal = readJournal(migrationsDir);
+	const drizzleArtifacts = listDrizzleArtifacts(migrationsDir);
+	if (journal === void 0) {
+		if (drizzleArtifacts.length > 0) throw new Error([
+			"db/migrations/meta/_journal.json is missing, but other drizzle-kit metadata is still present:",
+			...drizzleArtifacts.map((p) => `  - ${p}`),
+			"",
+			"This is a partial drizzle-kit state. Restore _journal.json from version control, or delete the orphaned metadata files above if you intended to revert to hand-written migrations."
+		].join("\n"));
+		return;
+	}
+	if (journal === null || typeof journal !== "object" || Array.isArray(journal) || typeof journal.version !== "string" || typeof journal.dialect !== "string" || !Array.isArray(journal.entries)) throw new Error("db/migrations/meta/_journal.json is malformed: expected an object with string `version`, string `dialect`, and an `entries` array. Restore the file from version control, or delete it if you intended to revert to hand-written migrations.");
+	for (let i = 0; i < journal.entries.length; i++) {
+		const entry = journal.entries[i];
+		if (entry === null || typeof entry !== "object" || typeof entry.idx !== "number" || typeof entry.version !== "string" || typeof entry.tag !== "string" || typeof entry.breakpoints !== "boolean") throw new Error(`db/migrations/meta/_journal.json is malformed: entry at index ${i} is missing required fields (\`idx\`, \`version\`, \`tag\`, \`breakpoints\`). Restore the file from version control, or delete it if you intended to revert to hand-written migrations.`);
+	}
+	if (journal.entries.length === 0) {
+		if (drizzleArtifacts.length === 0) return;
+		throw new Error([
+			"db/migrations/meta/_journal.json has no entries, but drizzle-kit metadata is still present:",
+			...drizzleArtifacts.map((p) => `  - ${p}`),
+			"",
+			"This is a partial drizzle-kit state. Restore _journal.json from version control (or run `void db generate`), or delete the orphaned metadata files above if you intended to revert to hand-written migrations."
+		].join("\n"));
+	}
+	const tagCounts = /* @__PURE__ */ new Map();
+	for (const entry of journal.entries) tagCounts.set(entry.tag, (tagCounts.get(entry.tag) ?? 0) + 1);
+	const duplicateTags = [...tagCounts.entries()].filter(([, n]) => n > 1).map(([tag]) => tag);
+	if (duplicateTags.length > 0) throw new Error([
+		"db/migrations/meta/_journal.json has duplicate migration entries:",
+		...duplicateTags.map((t) => `  - ${t} (appears ${tagCounts.get(t)} times)`),
+		"",
+		"Each migration must have a unique tag. Restore _journal.json from version control, or hand-edit to remove the duplicates."
+	].join("\n"));
+	const journalTags = new Set(journal.entries.map((e) => e.tag));
+	const collectedTags = new Set(collected.map((m) => stripSqlExt(m.name)));
+	const orphans = collected.map((m) => m.name).filter((name) => !journalTags.has(stripSqlExt(name)));
+	const missing = journal.entries.map((e) => `${e.tag}.sql`).filter((file) => !collectedTags.has(stripSqlExt(file)));
+	if (orphans.length === 0 && missing.length === 0) return;
+	const lines = ["Migration drift detected between db/migrations/ and db/migrations/meta/_journal.json."];
+	if (orphans.length > 0) {
+		lines.push("", "These files exist on disk but are not tracked in _journal.json:");
+		for (const f of orphans) lines.push(`  - db/migrations/${f}`);
+		lines.push("", "Delete the orphan file(s), or move their contents into `db/schema.ts` and re-run `void db generate`.");
+	}
+	if (missing.length > 0) {
+		lines.push("", "These entries are in _journal.json but the matching file is missing:");
+		for (const f of missing) lines.push(`  - db/migrations/${f}`);
+		lines.push("", "Restore the missing file(s) from version control, or regenerate migrations.");
+	}
+	throw new Error(lines.join("\n"));
+}
+//#endregion
+export { validate_exports as i, listDrizzleArtifacts as n, validateMigrations as r, assertJournalCoherence as t };