void 0.27.0 → 0.28.0

package/dist/runtime/live.d.mts

@@ -1,3 +1,3 @@
 /// <reference types="@cloudflare/workers-types" />
-import { _ as __getLiveBindingName, a as LiveControlErrorCode, b as defineLiveStream, c as LiveControlOptions, d as LiveHookContext, f as LiveLimits, g as LiveSubscribeHookContext, h as LiveStreamOptions, i as LiveControlError, l as LiveControlRequest, m as LiveStream, n as LiveConnectHookContext, o as LiveControlOperation, p as LivePublishOptions, r as LiveConnectOptions, s as LiveControlOperationResult, t as LiveClientEvent, u as LiveControlResponse, v as __setLiveBindingName, y as __setLiveDev } from "../live-Du8jXwOW.mjs";
+import { _ as __getLiveBindingName, a as LiveControlErrorCode, b as defineLiveStream, c as LiveControlOptions, d as LiveHookContext, f as LiveLimits, g as LiveSubscribeHookContext, h as LiveStreamOptions, i as LiveControlError, l as LiveControlRequest, m as LiveStream, n as LiveConnectHookContext, o as LiveControlOperation, p as LivePublishOptions, r as LiveConnectOptions, s as LiveControlOperationResult, t as LiveClientEvent, u as LiveControlResponse, v as __setLiveBindingName, y as __setLiveDev } from "../live-DJONVlQK.mjs";
 export { LiveClientEvent, LiveConnectHookContext, LiveConnectOptions, LiveControlError, LiveControlErrorCode, LiveControlOperation, LiveControlOperationResult, LiveControlOptions, LiveControlRequest, LiveControlResponse, LiveHookContext, LiveLimits, LivePublishOptions, LiveStream, LiveStreamOptions, LiveSubscribeHookContext, __getLiveBindingName, __setLiveBindingName, __setLiveDev, defineLiveStream };

package/dist/runtime/live.mjs

@@ -1,2 +1,2 @@
-import { i as defineLiveStream, n as __setLiveBindingName, r as __setLiveDev, t as __getLiveBindingName } from "../live-CgQuTpqD.mjs";
+import { i as defineLiveStream, n as __setLiveBindingName, r as __setLiveDev, t as __getLiveBindingName } from "../live-BxLX-JqJ.mjs";
 export { __getLiveBindingName, __setLiveBindingName, __setLiveDev, defineLiveStream };

package/dist/runtime/migration-handler-mysql.d.mts

@@ -1,4 +1,4 @@
-import { t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
+import { t as MigrationEntry } from "../migration-handler-CwlEQUoo.mjs";
 //#region src/runtime/migration-handler-mysql.d.ts
-export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
+export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
 //#endregion

package/dist/runtime/migration-handler-mysql.mjs

@@ -1,5 +1,6 @@
+import { n as splitMigrationSql } from "../migration-handler-Cg0Y4EPu.mjs";
 //#region src/runtime/migration-handler-mysql.ts
-function createMigrationHandler(env, migrations, _dialect, runAuthMigrations) {
+function createMigrationHandler(env, migrations, runAuthMigrations) {
 	return async (request) => {
 		const token = request.headers.get("x-void-internal");
 		if (!token || token !== env.__VOID_PROXY_TOKEN) return Response.json({
@@ -48,7 +49,7 @@ async function runMySqlMigrations(env, migrations) {
 			}
 			const start = Date.now();
 			try {
-				await connection.query(migration.sql);
+				for (const statement of splitMigrationSql(migration.sql)) await connection.query(statement);
 				await connection.query("INSERT INTO `_void_migrations` (`name`, `applied_at`) VALUES (?, ?)", [migration.name, (/* @__PURE__ */ new Date()).toISOString()]);
 				results.push({
 					name: migration.name,

package/dist/runtime/migration-handler-pg.d.mts

@@ -1,4 +1,4 @@
-import { t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
+import { t as MigrationEntry } from "../migration-handler-CwlEQUoo.mjs";
 //#region src/runtime/migration-handler-pg.d.ts
-export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
+export declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
 //#endregion

package/dist/runtime/migration-handler-pg.mjs

@@ -1,6 +1,6 @@
 import { t as disablePgPassFallback } from "../pg-J2HbZIkX.mjs";
 //#region src/runtime/migration-handler-pg.ts
-function createMigrationHandler(env, migrations, _dialect, runAuthMigrations) {
+function createMigrationHandler(env, migrations, runAuthMigrations) {
 	return async (request) => {
 		const token = request.headers.get("x-void-internal");
 		if (!token || token !== env.__VOID_PROXY_TOKEN) return Response.json({

package/dist/runtime/migration-handler.d.mts

@@ -1,2 +1,2 @@
-import { i as createMigrationHandler, n as MigrationResponse, r as MigrationResult, t as MigrationEntry } from "../migration-handler-DM4clYj5.mjs";
-export { MigrationEntry, MigrationResponse, MigrationResult, createMigrationHandler };
+import { a as splitMigrationSql, i as createMigrationHandler, n as MigrationResponse, r as MigrationResult, t as MigrationEntry } from "../migration-handler-CwlEQUoo.mjs";
+export { MigrationEntry, MigrationResponse, MigrationResult, createMigrationHandler, splitMigrationSql };

package/dist/runtime/migration-handler.mjs

@@ -1,470 +1,2 @@
-import { canonicalJson, canonicalSql, getMigrationPlanHashInput, isSingleStatement, splitSqlStatements } from "@void/deploy-core";
-//#region src/runtime/migration-handler.ts
-const SUPPORTED_CLASSIFIER_VERSION = 1;
-function createMigrationHandler(env, migrations, _dialect, runAuthMigrations, planBundle) {
-	return async (request) => {
-		const token = request.headers.get("x-void-internal");
-		if (!token || token !== env.__VOID_PROXY_TOKEN) return Response.json({
-			ok: false,
-			error: "unauthorized",
-			migrations: []
-		}, { status: 401 });
-		const url = new URL(request.url);
-		try {
-			const db = env.DB;
-			if (!db) return Response.json({
-				ok: false,
-				error: "no D1 binding found",
-				migrations: []
-			}, { status: 500 });
-			if (request.method === "GET" && url.pathname === "/__void/migrate/capabilities") {
-				const verified = await verifyPlanBundle(migrations ?? [], planBundle);
-				return Response.json({
-					classifierVersion: verified.classifierVersion,
-					destructiveValidation: verified.destructiveValidation,
-					dialect: "sqlite",
-					endpoints: {
-						app: "/__void/migrate/app",
-						auth: runAuthMigrations ? "/__void/migrate/auth" : void 0,
-						reconcile: "/__void/migrate/app/attempt/:attemptId"
-					},
-					migrationListHash: verified.migrationListHash,
-					protocolVersion: 2
-				});
-			}
-			if (request.method === "POST" && url.pathname === "/__void/migrate/app") {
-				const body = await request.json().catch(() => ({}));
-				if (!body.attemptId) return Response.json({
-					ok: false,
-					protocolVersion: 2,
-					error: "attemptId required",
-					migrations: []
-				}, { status: 400 });
-				const result = await runD1AppMigrations(db, migrations ?? [], planBundle, {
-					attemptId: body.attemptId,
-					deploymentId: body.deploymentId
-				});
-				const status = result.ok ? 200 : result.error?.startsWith("migration already in progress") ? 409 : 500;
-				return Response.json(result, { status });
-			}
-			if (request.method === "GET" && url.pathname.startsWith("/__void/migrate/app/attempt/")) {
-				const result = await reconcileAttempt(db, decodeURIComponent(url.pathname.split("/").pop() ?? ""));
-				return Response.json(result, { status: result.ok ? 200 : 409 });
-			}
-			if (request.method === "POST" && url.pathname === "/__void/migrate/auth") {
-				if (runAuthMigrations) await runAuthMigrations();
-				return Response.json({
-					ok: true,
-					protocolVersion: 2
-				});
-			}
-			const result = await runD1LegacyMigrations(db, migrations ?? []);
-			if (result.ok && runAuthMigrations) try {
-				await runAuthMigrations();
-			} catch (err) {
-				return Response.json({
-					...result,
-					ok: false,
-					error: err instanceof Error ? err.message : String(err)
-				}, { status: 500 });
-			}
-			return Response.json(result);
-		} catch (err) {
-			return Response.json({
-				ok: false,
-				error: err instanceof Error ? err.message : String(err),
-				migrations: []
-			}, { status: 500 });
-		}
-	};
-}
-async function createTrackingTable(db) {
-	await db.prepare(`CREATE TABLE IF NOT EXISTS _void_migrations (
-      name TEXT PRIMARY KEY,
-      applied_at TEXT NOT NULL
-    )`).run();
-}
-async function createAttemptTables(db) {
-	await db.batch([
-		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_attempts (
-        attempt_id TEXT PRIMARY KEY,
-        deployment_id TEXT,
-        migration_list_hash TEXT NOT NULL,
-        planned_names_json TEXT NOT NULL,
-        plan_hashes_json TEXT NOT NULL,
-        status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed', 'unknown')),
-        started_at TEXT NOT NULL,
-        completed_at TEXT,
-        error TEXT
-      )`),
-		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_lock (
-        name TEXT PRIMARY KEY,
-        attempt_id TEXT NOT NULL,
-        acquired_at TEXT NOT NULL
-      )`),
-		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_fences (
-        attempt_id TEXT PRIMARY KEY,
-        owned INTEGER NOT NULL CHECK (owned = 1)
-      )`)
-	]);
-}
-async function upgradeTrackingTable(db, fencedAttemptId) {
-	const { results } = await db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_migrations'").all();
-	if (!results || results.length === 0) return;
-	await db.batch([
-		...ownershipFence(db, fencedAttemptId),
-		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migrations (
-        name TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL
-      )`),
-		db.prepare(`INSERT OR IGNORE INTO _void_migrations (name, applied_at) SELECT name, applied_at FROM _migrations`),
-		db.prepare(`DROP TABLE _migrations`)
-	]);
-}
-async function readAppliedSet(db) {
-	const { results } = await db.prepare("SELECT name FROM _void_migrations").all();
-	return new Set((results ?? []).map((row) => row.name));
-}
-async function runD1AppMigrations(db, migrations, planBundle, attempt) {
-	const verified = await verifyPlanBundle(migrations, planBundle);
-	await createAttemptTables(db);
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const plannedNames = migrations.map((migration) => migration.name);
-	const planHashes = verified.plans.map((plan) => plan.planHash);
-	const fenced = verified.plans.every((plan) => plan.kind !== "legacy-unsplit-multi-statement");
-	const lock = await acquireAttemptLock(db, attempt.attemptId, now, [db.prepare(`INSERT INTO _void_migration_attempts
-          (attempt_id, deployment_id, migration_list_hash, planned_names_json, plan_hashes_json, status, started_at)
-         VALUES (?, ?, ?, ?, ?, 'running', ?)`).bind(attempt.attemptId, attempt.deploymentId ?? null, verified.migrationListHash, JSON.stringify(plannedNames), JSON.stringify(planHashes), now), ...fenced ? [db.prepare("INSERT INTO _void_migration_fences (attempt_id, owned) VALUES (?, 1)").bind(attempt.attemptId)] : []]);
-	if (lock !== "acquired") return lock;
-	const migrationResults = [];
-	const confirmedApplied = [];
-	const confirmedSkipped = [];
-	let warnings = verified.plans.flatMap((plan) => plan.warnings ?? []);
-	let stability = "stable";
-	try {
-		await createTrackingTable(db);
-		await upgradeTrackingTable(db, fenced ? attempt.attemptId : void 0);
-		const applied = await readAppliedSet(db);
-		warnings = verified.plans.flatMap((plan, index) => applied.has(migrations[index].name) ? [] : plan.warnings ?? []);
-		for (let index = 0; index < migrations.length; index++) {
-			const migration = migrations[index];
-			const plan = verified.plans[index];
-			if (plan.stability === "legacy") stability = "legacy";
-			if (applied.has(migration.name)) {
-				confirmedSkipped.push(migration.name);
-				migrationResults.push({
-					applied: false,
-					durationMs: 0,
-					name: migration.name,
-					stability: plan.stability,
-					status: "skipped"
-				});
-				continue;
-			}
-			const start = Date.now();
-			try {
-				await executeMigrationPlan(db, migration, plan, fenced ? attempt.attemptId : void 0);
-				applied.add(migration.name);
-				confirmedApplied.push(migration.name);
-				migrationResults.push({
-					applied: true,
-					durationMs: Date.now() - start,
-					name: migration.name,
-					stability: plan.stability,
-					status: "applied"
-				});
-			} catch (err) {
-				const error = err instanceof Error ? err.message : String(err);
-				migrationResults.push({
-					applied: false,
-					durationMs: Date.now() - start,
-					error,
-					name: migration.name,
-					stability: plan.stability,
-					status: "failed"
-				});
-				await markAttempt(db, attempt.attemptId, "failed", error);
-				await releaseAttemptLock(db, attempt.attemptId);
-				return {
-					ok: false,
-					protocolVersion: 2,
-					attemptId: attempt.attemptId,
-					confirmedApplied,
-					confirmedSkipped,
-					error: `migration ${migration.name} failed`,
-					migrations: migrationResults,
-					stability,
-					warnings
-				};
-			}
-		}
-		await markAttempt(db, attempt.attemptId, "completed");
-		await releaseAttemptLock(db, attempt.attemptId);
-		return {
-			ok: true,
-			protocolVersion: 2,
-			attemptId: attempt.attemptId,
-			confirmedApplied,
-			confirmedSkipped,
-			migrations: migrationResults,
-			stability,
-			warnings
-		};
-	} catch (err) {
-		const error = err instanceof Error ? err.message : String(err);
-		await markAttempt(db, attempt.attemptId, "failed", error).catch(() => {});
-		await releaseAttemptLock(db, attempt.attemptId).catch(() => {});
-		return {
-			ok: false,
-			protocolVersion: 2,
-			attemptId: attempt.attemptId,
-			confirmedApplied,
-			confirmedSkipped,
-			error,
-			migrations: migrationResults,
-			stability,
-			warnings
-		};
-	}
-}
-async function acquireAttemptLock(db, attemptId, acquiredAt, initialize) {
-	for (let tries = 0; tries < 2; tries++) try {
-		await db.batch([db.prepare("INSERT INTO _void_migration_lock (name, attempt_id, acquired_at) VALUES (?, ?, ?)").bind("app", attemptId, acquiredAt), ...initialize]);
-		return "acquired";
-	} catch {
-		const existing = await db.prepare("SELECT attempt_id FROM _void_migration_lock WHERE name = ?").bind("app").first();
-		if (!existing && await readAttempt(db, attemptId)) return reconcileAttempt(db, attemptId, false);
-		if (existing?.attempt_id) {
-			const row = await readAttempt(db, existing.attempt_id);
-			if (row?.status === "completed" || row?.status === "failed") {
-				await releaseAttemptLock(db, existing.attempt_id).catch(() => {});
-				continue;
-			}
-		}
-		return {
-			ok: false,
-			protocolVersion: 2,
-			attemptId,
-			migrations: [],
-			error: `migration already in progress for attempt ${existing?.attempt_id ?? "unknown"}`
-		};
-	}
-	return {
-		ok: false,
-		protocolVersion: 2,
-		attemptId,
-		migrations: [],
-		error: "migration lock could not be acquired"
-	};
-}
-async function executeMigrationPlan(db, migration, plan, fencedAttemptId) {
-	const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
-	if (plan.kind === "single-statement") {
-		await db.batch([
-			...ownershipFence(db, fencedAttemptId),
-			db.prepare(migration.sql),
-			db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)
-		]);
-		return;
-	}
-	if (plan.kind === "breakpoint-framed") {
-		await db.batch([
-			...ownershipFence(db, fencedAttemptId),
-			...plan.statements.map((statement) => db.prepare(statement)),
-			db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)
-		]);
-		return;
-	}
-	await runUnsplitMigration(db, migration, appliedAt, fencedAttemptId);
-}
-/**
-* D1 `exec()` treats each line as its own statement, so multi-line statements
-* fail there. Run each top-level statement through one batch instead, and keep
-* `exec()` only for SQL the splitter cannot divide safely (trigger bodies).
-*/
-async function runUnsplitMigration(db, migration, appliedAt, fencedAttemptId) {
-	const record = db.prepare("INSERT OR IGNORE INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt);
-	const statements = splitSqlStatements(migration.sql);
-	if (statements) {
-		await db.batch([
-			...ownershipFence(db, fencedAttemptId),
-			...statements.map((statement) => db.prepare(statement)),
-			record
-		]);
-		return;
-	}
-	await db.exec(migration.sql);
-	await record.run();
-}
-/** Fail the whole D1 batch if recovery has revoked this executor's ownership. */
-function ownershipFence(db, attemptId) {
-	if (!attemptId) return [];
-	return [db.prepare(`INSERT INTO _void_migration_fences (attempt_id, owned)
-     VALUES (?, EXISTS(SELECT 1 FROM _void_migration_lock WHERE name = 'app' AND attempt_id = ?))
-     ON CONFLICT(attempt_id) DO UPDATE SET owned = excluded.owned`).bind(attemptId, attemptId)];
-}
-function attemptUpdate(db, attemptId, status, error) {
-	return db.prepare(`UPDATE _void_migration_attempts
-       SET status = ?, completed_at = ?, error = ?
-       WHERE attempt_id = ? AND status ${status === "completed" ? "IN ('running', 'unknown')" : "= 'running'"}`).bind(status, (/* @__PURE__ */ new Date()).toISOString(), error ?? null, attemptId);
-}
-async function markAttempt(db, attemptId, status, error) {
-	await attemptUpdate(db, attemptId, status, error).run();
-}
-async function releaseAttemptLock(db, attemptId) {
-	await db.prepare("DELETE FROM _void_migration_lock WHERE name = ? AND attempt_id = ?").bind("app", attemptId).run();
-}
-async function readAttempt(db, attemptId) {
-	return db.prepare("SELECT * FROM _void_migration_attempts WHERE attempt_id = ?").bind(attemptId).first();
-}
-async function reconcileAttempt(db, attemptId, recover = true) {
-	await createAttemptTables(db);
-	await createTrackingTable(db);
-	const row = await readAttempt(db, attemptId);
-	if (!row) return {
-		ok: false,
-		protocolVersion: 2,
-		attemptId,
-		migrations: [],
-		error: "migration attempt not found"
-	};
-	const fenced = await db.prepare("SELECT attempt_id FROM _void_migration_fences WHERE attempt_id = ?").bind(attemptId).first();
-	if (recover && fenced) await db.batch([attemptUpdate(db, attemptId, "unknown", "migration outcome unknown"), db.prepare("DELETE FROM _void_migration_lock WHERE name = ? AND attempt_id = ?").bind("app", attemptId)]);
-	const plannedNames = JSON.parse(row.planned_names_json);
-	const applied = await readAppliedSet(db);
-	const confirmed = plannedNames.filter((name) => applied.has(name));
-	const complete = confirmed.length === plannedNames.length;
-	if (complete && row.status !== "completed") await markAttempt(db, attemptId, "completed").catch(() => {});
-	const inProgress = !fenced && !complete && (row.status === "running" || row.status === "unknown");
-	if (complete || row.status === "completed" || row.status === "failed") await releaseAttemptLock(db, attemptId);
-	return {
-		ok: complete,
-		protocolVersion: 2,
-		attemptId,
-		confirmedApplied: [],
-		confirmedSkipped: confirmed,
-		migrations: plannedNames.map((name) => ({
-			applied: false,
-			durationMs: 0,
-			name,
-			status: applied.has(name) ? "skipped" : "failed"
-		})),
-		error: complete ? void 0 : inProgress ? `migration already in progress for attempt ${attemptId}; wait for this migration to finish before retrying recovery` : row.error ?? "migration outcome unknown",
-		stability: "stable"
-	};
-}
-async function verifyPlanBundle(migrations, planBundle) {
-	if (!planBundle || planBundle.protocolVersion !== 2) throw new Error("migration protocol v2 execution plans are missing");
-	if (planBundle.classifierVersion !== SUPPORTED_CLASSIFIER_VERSION || planBundle.destructiveValidation !== "passed") throw new Error("unsupported migration execution plan metadata");
-	if (planBundle.plans.length !== migrations.length) throw new Error("migration execution plan count does not match bundled migrations");
-	for (let index = 0; index < migrations.length; index++) {
-		const migration = migrations[index];
-		const plan = planBundle.plans[index];
-		if (plan.name !== migration.name || plan.dialect !== "sqlite" || plan.classifierVersion !== SUPPORTED_CLASSIFIER_VERSION) throw new Error(`invalid migration execution plan for ${migration.name}`);
-		const sqlHash = await sha256Hex(canonicalSql(migration.sql));
-		if (plan.sqlHash !== sqlHash) throw new Error(`migration SQL hash mismatch for ${migration.name}`);
-		const planHash = await hashPlan(plan);
-		if (plan.planHash !== planHash) throw new Error(`migration plan hash mismatch for ${migration.name}`);
-	}
-	const migrationListHash = await sha256Hex(canonicalJson(planBundle.plans.map((plan) => [
-		plan.name,
-		plan.sqlHash,
-		plan.planHash
-	])));
-	if (planBundle.migrationListHash !== migrationListHash) throw new Error("migration list hash mismatch");
-	return planBundle;
-}
-async function sha256Hex(value) {
-	const bytes = new TextEncoder().encode(value);
-	const hash = await crypto.subtle.digest("SHA-256", bytes);
-	return `sha256:${[...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
-}
-async function hashPlan(plan) {
-	return sha256Hex(canonicalJson(getMigrationPlanHashInput(plan)));
-}
-async function runD1LegacyMigrations(db, migrations) {
-	await createTrackingTable(db);
-	await upgradeTrackingTable(db);
-	const applied = await readAppliedSet(db);
-	const migrationResults = [];
-	for (const migration of migrations) {
-		if (applied.has(migration.name)) {
-			migrationResults.push({
-				name: migration.name,
-				applied: false,
-				durationMs: 0
-			});
-			continue;
-		}
-		const start = Date.now();
-		try {
-			const statements = splitMigrationSql(migration.sql);
-			if (statements.length === 1) {
-				if (isSingleStatement(statements[0])) {
-					await db.prepare(statements[0]).run();
-					await recordLegacyMigration(db, migration.name);
-				} else await runUnsplitMigration(db, migration, (/* @__PURE__ */ new Date()).toISOString());
-			} else {
-				for (const statement of statements) await db.prepare(statement).run();
-				await recordLegacyMigration(db, migration.name);
-			}
-			migrationResults.push({
-				name: migration.name,
-				applied: true,
-				durationMs: Date.now() - start
-			});
-		} catch (err) {
-			migrationResults.push({
-				name: migration.name,
-				applied: false,
-				durationMs: Date.now() - start,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			return {
-				ok: false,
-				migrations: migrationResults,
-				error: `migration ${migration.name} failed`
-			};
-		}
-	}
-	return {
-		ok: true,
-		migrations: migrationResults
-	};
-}
-async function recordLegacyMigration(db, name) {
-	await db.prepare("INSERT OR IGNORE INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(name, (/* @__PURE__ */ new Date()).toISOString()).run();
-}
-function splitMigrationSql(sql) {
-	const lines = sql.split(/\r?\n/);
-	if (!lines.some((line) => isStatementBreakpointLine(line) || hasInlineStatementBreakpoint(line))) return [sql];
-	const statements = [];
-	const current = [];
-	for (const line of lines) {
-		if (isStatementBreakpointLine(line)) {
-			const statement = current.join("\n").trim();
-			if (statement) statements.push(statement);
-			current.length = 0;
-			continue;
-		}
-		if (hasInlineStatementBreakpoint(line)) {
-			current.push(line.replace(/-->\s*statement-breakpoint\s*$/, ""));
-			const statement = current.join("\n").trim();
-			if (statement) statements.push(statement);
-			current.length = 0;
-			continue;
-		}
-		current.push(line);
-	}
-	const statement = current.join("\n").trim();
-	if (statement) statements.push(statement);
-	return statements.length > 0 ? statements : [sql];
-}
-function isStatementBreakpointLine(line) {
-	return line.trim() === "--> statement-breakpoint";
-}
-function hasInlineStatementBreakpoint(line) {
-	return /;\s*-->\s*statement-breakpoint\s*$/.test(line.trim());
-}
-//#endregion
-export { createMigrationHandler };
+import { n as splitMigrationSql, t as createMigrationHandler } from "../migration-handler-Cg0Y4EPu.mjs";
+export { createMigrationHandler, splitMigrationSql };

package/dist/runtime/queues.mjs

@@ -1,4 +1,4 @@
-import { a as requireRuntimeBinding } from "../env-DMA3cXZt.mjs";
+import { a as requireRuntimeBinding } from "../env-BhdWMrNy.mjs";
 //#region src/runtime/queues.ts
 /** Typed queue producers — resolves `QUEUE_*` bindings from the active runtime environment. */
 const queues = new Proxy({}, { get(_, name) {