qubu 0.4.3 → 0.5.0

package/dist/snapshot.mjs

@@ -1,6 +1,586 @@
+import { F as isValidSchemaObjectName, r as isColumnReference } from "./column-DmazTL67.mjs";
+import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue, c as canonicalizeSchemaSnapshot, d as schemaSnapshotDialectVersion, f as schemaSnapshotFormat, i as schemaSnapshotDigest, l as decodeSchemaSnapshot, m as schemaSnapshotVersion, n as canonicalJson, o as SnapshotValidationError, p as schemaSnapshotNamingPolicyVersion, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, t as SnapshotCanonicalError, u as neutralSnapshotDialect } from "./canonical-BXUguqfo.mjs";
-import { a as sqliteStorageAffinity, c as createSchemaSnapshot, d as encodeSnapshot, f as serializeSchema, i as sqliteSnapshotDialect, l as digestSchemaSnapshot, n as sqliteSchemaDialect, o as tryCreateSqliteSchemaSnapshot, p as tryCreateSchemaSnapshot, r as sqliteSnapshotAdapter, s as SnapshotSerializationError, t as createSqliteSchemaSnapshot, u as encodeSchemaSnapshot } from "./sqlite-mPVdrKrk.mjs";
-import { _ as completeSchemaSnapshotVersion, a as canonicalizeCompleteSchemaSnapshot, b as schemaSnapshotVersion2, c as decodeCompleteSchemaSnapshot, d as digestCompleteSchemaSnapshot, f as encodeCompleteSchemaSnapshot, g as completeSchemaSnapshotFormat, h as schemaSnapshotV2Digest, i as assertSchemaSnapshotV2, l as decodeCompleteSnapshot, m as encodeSchemaSnapshotV2, n as assertCompleteSchemaSnapshot, o as canonicalizeSchemaSnapshotV2, p as encodeCompleteSnapshot, r as assertCompleteSnapshot, s as completeSchemaSnapshotDigest, t as CompleteSnapshotValidationError, u as decodeSchemaSnapshotV2, v as schemaSnapshotCompleteVersion, y as schemaSnapshotV2Version } from "./complete-WYyVozgK.mjs";
-import { a as tryCreateMysqlSchemaSnapshot, c as postgresSnapshotAdapter, i as mysqlSnapshotDialect, l as postgresSnapshotDialect, n as mysqlSchemaDialect, o as createPostgresSchemaSnapshot, r as mysqlSnapshotAdapter, s as postgresSchemaDialect, t as createMysqlSchemaSnapshot, u as tryCreatePostgresSchemaSnapshot } from "./mysql-DxFleLw4.mjs";
-export { CompleteSnapshotValidationError, SnapshotCanonicalError, SnapshotSerializationError, SnapshotValidationError, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotDigest, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createMysqlSchemaSnapshot, createPostgresSchemaSnapshot, createSchemaDialect, createSchemaSnapshot, createSqliteSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, digestCompleteSchemaSnapshot, digestSchemaSnapshot, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, neutralSnapshotDialect, postgresSchemaDialect, postgresSnapshotAdapter, postgresSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotDigest, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Digest, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, toSnapshotJsonValue, tryCreateMysqlSchemaSnapshot, tryCreatePostgresSchemaSnapshot, tryCreateSchemaSnapshot, tryCreateSqliteSchemaSnapshot };
+import { a as toSnapshotJsonValue, c as canonicalizeSchemaSnapshot, d as schemaSnapshotDialectVersion, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, l as decodeSchemaSnapshot, m as schemaSnapshotVersion, n as canonicalJson, o as SnapshotValidationError, p as schemaSnapshotNamingPolicyVersion, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, t as SnapshotCanonicalError, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
+import { a as sqliteStorageAffinity, c as createSchemaSnapshot, d as fingerprintSchemaSnapshot, f as serializeSchema, i as sqliteSnapshotDialect, l as encodeSchemaSnapshot, n as sqliteSchemaDialect, o as tryCreateSqliteSchemaSnapshot, p as tryCreateSchemaSnapshot, r as sqliteSnapshotAdapter, s as SnapshotSerializationError, t as createSqliteSchemaSnapshot, u as encodeSnapshot } from "./sqlite-CsIUtZ2Q.mjs";
+import { _ as completeSchemaSnapshotVersion, a as canonicalizeCompleteSchemaSnapshot, b as schemaSnapshotVersion2, c as decodeCompleteSchemaSnapshot, d as encodeCompleteSchemaSnapshot, f as encodeCompleteSnapshot, g as completeSchemaSnapshotFormat, h as schemaSnapshotV2Fingerprint, i as assertSchemaSnapshotV2, l as decodeCompleteSnapshot, m as fingerprintCompleteSchemaSnapshot, n as assertCompleteSchemaSnapshot, o as canonicalizeSchemaSnapshotV2, p as encodeSchemaSnapshotV2, r as assertCompleteSnapshot, s as completeSchemaSnapshotFingerprint, t as CompleteSnapshotValidationError, u as decodeSchemaSnapshotV2, v as schemaSnapshotCompleteVersion, y as schemaSnapshotV2Version } from "./complete-DP7pliuY.mjs";
+import { postgresDialect } from "./postgres.mjs";
+import { mysqlDialect } from "./mysql.mjs";
+//#region src/snapshot/postgres.ts
+/** PostgreSQL's v1 snapshot extension identity. */
+const postgresSnapshotDialect = Object.freeze({
+	name: "postgresql",
+	version: 1
+});
+var PostgresSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const postgresStorageTypes = Object.freeze({
+	integer: "INTEGER",
+	numeric: "NUMERIC",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "TIMESTAMP",
+	uuid: "UUID",
+	json: "JSONB",
+	bigint: "BIGINT",
+	binary: "BYTEA"
+});
+/** PostgreSQL's query dialect plus its schema metadata behavior. */
+const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
+	version: 1,
+	validate: validatePostgresSchema,
+	encodeStorage(storage, context) {
+		return encodePostgresStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodePostgresExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodePostgresExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
+/** Create a canonical PostgreSQL schema snapshot. */
+function createPostgresSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+/** Return PostgreSQL capability diagnostics without throwing. */
+function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+function encodePostgresStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = postgresStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodePostgresExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodePostgresExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson$1(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson$1(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson$1);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson$1(child)]));
+}
+function validatePostgresSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds$1(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
+		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds$1(left, right))) {
+		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
+			...tablePath,
+			"columns",
+			columnId,
+			"physicalName"
+		], "PostgreSQL column", diagnostics);
+		if (definition.onUpdate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"onUpdate"
+			]
+		});
+		const generated = definition.generatedColumn;
+		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"generatedColumn",
+				"mode"
+			]
+		});
+	}
+	const metadata = table;
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds$1(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
+		addScopedName$1(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
+			path: [...constraintPath, "deferrable"]
+		});
+		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
+			path: [...constraintPath, "nulls"]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds$1(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
+		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+	}
+}
+function validatePostgresName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+	if (new TextEncoder().encode(name).length > 63) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
+		path
+	});
+}
+function addRelationName(names, name, path, kind, diagnostics) {
+	addScopedName$1(names, name, path, kind, diagnostics);
+}
+function addScopedName$1(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics$1(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function compareIds$1(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+//#region src/snapshot/mysql.ts
+/** MySQL's v1 snapshot extension identity. */
+const mysqlSnapshotDialect = Object.freeze({
+	name: "mysql",
+	version: 1
+});
+var MysqlSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const mysqlStorageTypes = Object.freeze({
+	integer: "INT",
+	numeric: "DECIMAL",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "DATETIME",
+	uuid: "CHAR(36)",
+	json: "JSON",
+	bigint: "BIGINT",
+	binary: "VARBINARY"
+});
+/** MySQL's query dialect plus its schema metadata behavior. */
+const mysqlSchemaDialect = createSchemaDialect(mysqlDialect(), {
+	version: 1,
+	validate: validateMysqlSchema,
+	encodeStorage(storage, context) {
+		return encodeMysqlStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodeMysqlExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodeMysqlExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const mysqlSnapshotAdapter = Object.freeze({ dialect: mysqlSchemaDialect });
+/** Create a canonical MySQL schema snapshot. */
+function createMysqlSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: mysqlSnapshotAdapter
+	});
+}
+/** Return MySQL capability diagnostics without throwing. */
+function tryCreateMysqlSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: mysqlSnapshotAdapter
+	});
+}
+function encodeMysqlStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("MySQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = mysqlStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for MySQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodeMysqlExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new MysqlSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the MySQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("MySQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodeMysqlExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
+}
+function validateMysqlSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validateMysqlName(schema.namespace, ["namespace"], "MySQL database/schema", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validateMysqlName(entry.physicalName, [...tablePath, "physicalName"], "MySQL table", diagnostics);
+		addScopedName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validateMysqlTable(id, entry, context, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validateMysqlTable(tableId, entry, context, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	const metadata = table;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
+		const columnPath = [
+			...tablePath,
+			"columns",
+			columnId
+		];
+		validateMysqlName(table.sqlNames[columnId] ?? columnId, [...columnPath, "physicalName"], "MySQL column", diagnostics);
+		if (definition.onUpdate !== void 0 && definition.generatedColumn) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL generated columns cannot also declare ON UPDATE",
+			path: [...columnPath, "onUpdate"]
+		});
+		const extension = definition.identity?.dialect;
+		const autoIncrement = extension?.dialect === mysqlSnapshotDialect.name ? extension.autoIncrement : void 0;
+		if (extension?.dialect === mysqlSnapshotDialect.name && autoIncrement !== void 0 && typeof autoIncrement !== "boolean") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL identity autoIncrement must be boolean",
+			path: [
+				...columnPath,
+				"identity",
+				"dialect",
+				"autoIncrement"
+			]
+		});
+		if (autoIncrement === true) validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics);
+	}
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validateMysqlName(physicalName, [...constraintPath, "physicalName"], "MySQL constraint", diagnostics);
+		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "foreign-key" && (constraint.match === "full" || constraint.match === "partial")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL v1 snapshots support MATCH SIMPLE foreign keys only",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "foreign-key" && (constraint.onUpdate === "set-default" || constraint.onDelete === "set-default")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL does not support SET DEFAULT foreign-key actions",
+			path: [...constraintPath, constraint.onUpdate === "set-default" ? "onUpdate" : "onDelete"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ordinary UNIQUE constraints use distinct NULL semantics in v1",
+			path: [...constraintPath, "nulls"]
+		});
+		if (constraint.dialect?.dialect === mysqlSnapshotDialect.name && "enforced" in constraint.dialect && constraint.dialect.enforced !== void 0 && typeof constraint.dialect.enforced !== "boolean") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL constraint enforced must be boolean",
+			path: [
+				...constraintPath,
+				"dialect",
+				"enforced"
+			]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	const tableIndexNames = /* @__PURE__ */ new Map();
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validateMysqlName(physicalName, [...indexPath, "physicalName"], "MySQL index", diagnostics);
+		addScopedName(tableIndexNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+		if (index.predicate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL does not support partial-index predicates",
+			path: [...indexPath, "predicate"]
+		});
+		for (const [termIndex, term] of index.terms.entries()) if (isOrderTerm(term) && term.nulls !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL index terms do not support NULLS FIRST/LAST syntax",
+			path: [
+				...indexPath,
+				"terms",
+				termIndex,
+				"nulls"
+			]
+		});
+		const extension = index.dialect;
+		if (extension?.dialect === mysqlSnapshotDialect.name) {
+			const mysqlExtension = extension;
+			if (mysqlExtension.algorithm !== void 0 && ![
+				"default",
+				"inplace",
+				"copy"
+			].includes(String(mysqlExtension.algorithm))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index algorithm is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"algorithm"
+				]
+			});
+			if (mysqlExtension.lock !== void 0 && ![
+				"default",
+				"none",
+				"shared",
+				"exclusive"
+			].includes(String(mysqlExtension.lock))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index lock mode is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"lock"
+				]
+			});
+			if (mysqlExtension.using !== void 0 && ![
+				"btree",
+				"hash",
+				"rtree"
+			].includes(String(mysqlExtension.using))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index access method is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"using"
+				]
+			});
+			if (mysqlExtension.parser !== void 0 && (typeof mysqlExtension.parser !== "string" || mysqlExtension.parser.trim().length === 0)) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index parser must be a non-empty string",
+				path: [
+					...indexPath,
+					"dialect",
+					"parser"
+				]
+			});
+		}
+	}
+}
+function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics) {
+	if (definition.nullable) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns must be non-nullable",
+		path: [...columnPath, "nullable"]
+	});
+	if (definition.generatedColumn !== void 0) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns cannot be generated columns",
+		path: [...columnPath, "generatedColumn"]
+	});
+	const declaration = mysqlDeclaration(definition.storage);
+	if (declaration === void 0 || !isMysqlIntegerDeclaration(declaration)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT requires an integer-family physical storage declaration",
+		path: [...columnPath, "storage"]
+	});
+	if (!hasMysqlAutoIncrementKey(columnId, metadata)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns must be the first column of a primary, unique, or ordinary index key",
+		path: [
+			...columnPath,
+			"identity",
+			"dialect",
+			"autoIncrement"
+		]
+	});
+}
+function mysqlDeclaration(storage) {
+	if (storage === void 0) return;
+	return storage.kind === "native" ? storage.type : mysqlStorageTypes[storage.type];
+}
+function isMysqlIntegerDeclaration(declaration) {
+	const base = declaration.trim().toUpperCase().split(/\s+/u)[0] ?? "";
+	return /^(?:TINYINT|SMALLINT|MEDIUMINT|INT|INTEGER|BIGINT)(?:\(\d+\))?$/u.test(base);
+}
+function hasMysqlAutoIncrementKey(columnId, metadata) {
+	for (const constraint of Object.values(metadata.constraints)) if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") && isColumnReference(constraint.columns[0]) && constraint.columns[0].fieldName === columnId) return true;
+	for (const index of Object.values(metadata.indexes)) {
+		const first = index.terms[0];
+		const expression = isOrderTerm(first) ? first.expression : first;
+		if (isColumnReference(expression) && expression.fieldName === columnId) return true;
+	}
+	return false;
+}
+function validateMysqlName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+	if ([...name].length > 64) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds MySQL's 64-character identifier limit`,
+		path
+	});
+}
+function addScopedName(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `MySQL ${kind} name "${name}" collides with another ${kind}`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function isOrderTerm(value) {
+	return typeof value === "object" && value !== null && "orderKind" in value && value.orderKind === "term" && "expression" in value;
+}
+function compareIds(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+export { CompleteSnapshotValidationError, SnapshotCanonicalError, SnapshotSerializationError, SnapshotValidationError, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotFingerprint, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createMysqlSchemaSnapshot, createPostgresSchemaSnapshot, createSchemaDialect, createSchemaSnapshot, createSqliteSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, fingerprintCompleteSchemaSnapshot, fingerprintSchemaSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, neutralSnapshotDialect, postgresSchemaDialect, postgresSnapshotAdapter, postgresSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotFingerprint, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Fingerprint, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, toSnapshotJsonValue, tryCreateMysqlSchemaSnapshot, tryCreatePostgresSchemaSnapshot, tryCreateSchemaSnapshot, tryCreateSqliteSchemaSnapshot };

package/dist/{sqlite-mPVdrKrk.mjs → sqlite-CsIUtZ2Q.mjs}

@@ -2,7 +2,7 @@ import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
 import { F as isValidSchemaObjectName, P as generatedSchemaObjectName, r as isColumnReference } from "./column-DmazTL67.mjs";
 import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotDigest, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-BXUguqfo.mjs";
+import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
 import { sqliteDialect } from "./sqlite.mjs";
 //#region src/snapshot/serialize.ts
 const neutralSchemaDialect = createSchemaDialect(Object.freeze({
@@ -113,8 +113,8 @@ function encodeSchemaSnapshot(snapshot) {
 const serializeSchema = createSchemaSnapshot;
 /** Alias for the canonical snapshot encoder. */
 const encodeSnapshot = encodeSchemaSnapshot;
-/** Alias for the canonical snapshot digest helper. */
-const digestSchemaSnapshot = schemaSnapshotDigest;
+/** Alias for the canonical snapshot fingerprint helper. */
+const fingerprintSchemaSnapshot = schemaSnapshotFingerprint;
 function serializeTable(id, table, physicalName, tableIds, tablesById, dialect, options, diagnostics) {
 	const definitions = table.definitions;
 	const tableMetadata = table;
@@ -867,4 +867,4 @@ function compareIds(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 //#endregion
-export { sqliteStorageAffinity as a, createSchemaSnapshot as c, encodeSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, digestSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSchemaSnapshot as u };
+export { sqliteStorageAffinity as a, createSchemaSnapshot as c, fingerprintSchemaSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, encodeSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSnapshot as u };

package/docs/config.json

@@ -10,6 +10,7 @@
       "getting-started.md",
       "query-model/",
       "schema/",
+      "migrations/",
       "dialects-and-execution.md",
       "sql-semantic-types.md",
       "guides/",

package/docs/index.md

@@ -46,6 +46,8 @@ define a table, build a `SELECT`, and inspect its SQL and parameters.
   data before DDL emission.
 - [Emit DDL](schema/ddl-emission.md) from an approved migration plan without
   handing Qubu a database connection.
+- [Operate migrations](migrations/index.md) with versioned artifacts, verified
+  adapter profiles, baselines, a portable executor, and explicit recovery.
 
 ## The query pipeline
 
@@ -76,6 +78,7 @@ needs to preserve a fact across composition:
 | ------------------------ | --------------------------------------------------- | ----------------------------------------------------------------------------------- |
 | Query model              | [Source scope](query-model/source-scope.md)         | Source identity, result shapes, fragments, metadata, and query composition          |
 | Schema model             | [Tables and names](schema/tables-and-names.md)      | Tables, snapshots, diffs, migration plans, and DDL emission                         |
+| Migration operations     | [Migration operations](migrations/index.md)         | Artifacts, adapters, CLI policy, baselines, execution, and recovery                 |
 | Database introspection   | [Database introspection](schema/introspection.md)   | Catalog readers, Snapshot v1 mapping, identities, diagnostics, and support limits   |
 | Schema source generation | [Generate a schema](schema/code-generation.md)      | Machine-owned TypeScript, identity handoff, controlled mappings, and v1 exclusions  |
 | Rendering and execution  | [Dialects and execution](dialects-and-execution.md) | Placeholder and identifier policies, capabilities, adapters, and raw-SQL boundaries |
@@ -104,6 +107,7 @@ The inferred row is `{ id: number; name: string }`. The value `7` stays out
 of the SQL text and appears in the `parameters` array in placeholder order.
 
 The [supported features](reference/supported-surface.md) page is the canonical
-package-entrypoint and ownership map. Qubu emits DDL, but the application owns
-migration execution and database lifecycle. [Troubleshooting](troubleshooting.md)
+package-entrypoint and ownership map. Applications may use Qubu's portable
+migration executor while retaining credentials, approval policy, custom SQL,
+and deployment lifecycle ownership. [Troubleshooting](troubleshooting.md)
 starts from common errors and points to the concept page behind each one.