void 0.10.5 → 0.10.6

package/dist/validate-DT7nFMlf.mjs

@@ -0,0 +1,504 @@
+import { n as __exportAll } from "./rolldown-runtime-DJK8HYOj.mjs";
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
+import { t as canonicalJson } from "./canonical-json-DuDiiUsQ.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/migrations/collect.ts
+var collect_exports = /* @__PURE__ */ __exportAll({
+	collectMigrations: () => collectMigrations,
+	readJournal: () => readJournal,
+	stripSqlExt: () => stripSqlExt,
+	writeJournal: () => writeJournal
+});
+/**
+* Collect all .sql migration files from the migrations directory,
+* sorted by filename (lexicographic order).
+*/
+function collectMigrations(migrationsDir) {
+	if (!existsSync(migrationsDir)) return [];
+	return readdirSync(migrationsDir).filter((f) => f.endsWith(".sql") && f !== "seed.sql").sort().map((name) => ({
+		name,
+		sql: readFileSync(join(migrationsDir, name), "utf-8")
+	}));
+}
+/**
+* Read `db/migrations/meta/_journal.json` if it exists. Drizzle maintains
+* this file whenever `drizzle-kit generate` runs; every `.sql` migration
+* under `db/migrations/` should correspond to an entry whose `tag` is the
+* filename without the `.sql` suffix.
+*/
+function readJournal(migrationsDir) {
+	const journalPath = join(migrationsDir, "meta", "_journal.json");
+	if (!existsSync(journalPath)) return;
+	try {
+		return JSON.parse(readFileSync(journalPath, "utf-8"));
+	} catch (err) {
+		throw new Error(`db: Failed to parse db/migrations/meta/_journal.json: '${err.message}'.`);
+	}
+}
+/**
+* Write `db/migrations/meta/_journal.json` with pretty-printed JSON and a
+* trailing newline, matching the format Drizzle itself emits. Creates the
+* `meta/` directory if it does not yet exist.
+*/
+function writeJournal(migrationsDir, journal) {
+	const journalPath = join(migrationsDir, "meta", "_journal.json");
+	mkdirSync(dirname(journalPath), { recursive: true });
+	writeFileSync(journalPath, JSON.stringify(journal, null, 2) + "\n");
+}
+/**
+* Drop the `.sql` extension from a migration filename, leaving any other
+* suffix untouched. Used to line filenames up with journal `tag` values.
+*/
+function stripSqlExt(name) {
+	return name.endsWith(".sql") ? name.slice(0, -4) : name;
+}
+//#endregion
+//#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
+//#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+VIEW\b/i,
+	/\bDROP\s+INDEX\b/i,
+	/\bDROP\s+TRIGGER\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bDROP\s+COLUMN\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\s+TO\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\s+COLUMN\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\b[\s\S]*\bTO\b/i,
+	/\bTRUNCATE\b/i,
+	/\bINSERT\s+OR\s+REPLACE\b/i
+];
+function splitExecutableStatements(sql) {
+	return sql.split(";").map((statement) => statement.trim()).filter(Boolean);
+}
+function hasTopLevelKeyword(statement, keyword) {
+	let depth = 0;
+	for (let index = 0; index < statement.length; index++) {
+		const character = statement[index];
+		if (character === "(") {
+			depth++;
+			continue;
+		}
+		if (character === ")") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth !== 0) continue;
+		if (statement.slice(index, index + keyword.length).toUpperCase() === keyword && !/[A-Z0-9_]/i.test(statement[index - 1] ?? "") && !/[A-Z0-9_]/i.test(statement[index + keyword.length] ?? "")) return true;
+	}
+	return false;
+}
+function hasUnboundedWrite(statement) {
+	if (/\bDELETE\s+FROM\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
+	if (/\bUPDATE\b[\s\S]*\bSET\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
+	return false;
+}
+/**
+* Check if a SQL migration contains destructive operations.
+*/
+function isDestructive(sql) {
+	const normalized = sql.replace(/\r\n?/g, "\n");
+	let executable = "";
+	for (const segment of tokenizeSql(normalized)) if (segment.kind === "sql") executable += normalized.slice(segment.start, segment.end);
+	else executable += " ".repeat(segment.end - segment.start);
+	return splitExecutableStatements(executable).some((statement) => {
+		return DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(statement)) || hasUnboundedWrite(statement);
+	});
+}
+function hasDestructivePragma(sql) {
+	return sql.replace(/\r\n?/g, "\n").split("\n").some((line) => line.trim() === DESTRUCTIVE_PRAGMA);
+}
+/**
+* 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 && !hasDestructivePragma(file.sql)) 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 "${DESTRUCTIVE_PRAGMA}" 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 { buildMigrationPlanBundle as a, collectMigrations as c, stripSqlExt as d, writeJournal as f, validate_exports as i, collect_exports as l, listDrizzleArtifacts as n, classifyMigration as o, validateMigrations as r, plan_exports as s, assertJournalCoherence as t, readJournal as u };

package/dist/{yarn-pnp-WLW2IHUY.mjs → yarn-pnp-CW8LB6g_.mjs}

@@ -1,4 +1,4 @@
-import { a as join, n as dirname } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
 import { existsSync, readdirSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/cli/yarn-pnp.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -308,44 +308,44 @@
     }
   },
   "dependencies": {
-    "@cloudflare/sandbox": "^0.10.0",
-    "@cloudflare/vite-plugin": "^1.36.3",
-    "@cloudflare/workers-types": "^4.20260508.1",
+    "@cloudflare/sandbox": "^0.12.3",
+    "@cloudflare/vite-plugin": "^1.43.0",
+    "@cloudflare/workers-types": "^4.20260702.1",
     "@hono/oauth-providers": "^0.8.5",
     "@napi-rs/keyring": "1.3.0",
-    "better-auth": "^1.6.9",
-    "better-sqlite3": "^12.9.0",
+    "better-auth": "^1.6.23",
+    "better-sqlite3": "^12.11.1",
     "blake3-jit": "^1.1.0",
     "drizzle-arktype": "^0.1.3",
     "drizzle-kit": "^0.31.10",
     "drizzle-orm": "^0.45.2",
     "drizzle-valibot": "^0.4.2",
     "drizzle-zod": "^0.8.3",
-    "es-module-lexer": "^2.1.0",
-    "hono": "^4.12.18",
+    "es-module-lexer": "^2.3.0",
+    "hono": "^4.12.27",
     "ignore": "^7.0.5",
     "jsonc-parser": "3.3.1",
-    "pg": "^8.20.0",
-    "wrangler": "^4.90.0"
+    "pg": "8.22.0",
+    "wrangler": "^4.107.0"
   },
   "devDependencies": {
-    "@clack/prompts": "^1.3.0",
-    "@electric-sql/pglite": "0.4.5",
+    "@clack/prompts": "^1.7.0",
+    "@electric-sql/pglite": "0.5.4",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.6.2",
+    "@types/node": "^26.1.0",
     "@types/pg": "^8.20.0",
     "@typescript/native-preview": "7.0.0-dev.20260507.1",
-    "arktype": "^2.2.0",
+    "arktype": "^2.2.2",
     "estree-walker": "^3.0.3",
     "magic-string": "^0.30.21",
     "ofetch": "2.0.0-alpha.3",
     "pathe": "^2.0.3",
     "pglite-server": "0.1.5",
     "picocolors": "^1.1.1",
-    "tinyglobby": "^0.2.16",
-    "valibot": "^1.4.0",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.20",
-    "vite-plus": "^0.1.20",
+    "tinyglobby": "^0.2.17",
+    "valibot": "^1.4.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "^0.2.2",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
@@ -353,7 +353,7 @@
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",
     "zod": "^3.25.0 || ^4.0.0",
-    "@void/md": "0.10.5"
+    "@void/md": "0.10.6"
   },
   "peerDependenciesMeta": {
     "@void/md": {