qubu 0.6.0 → 0.6.2

package/dist/snapshot/mysql.mjs

@@ -1,12 +1,12 @@
-import { d as isValidSchemaObjectName, r as isColumnReference } from "../column-r1Y4ivwt.mjs";
-import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-YGyNPQ_z.mjs";
-import { c as isUnsafeSchemaSql, u as renderSchemaExpression } from "../registry-BRcUuazJ.mjs";
+import { r as isColumnReference, v as isValidSchemaObjectName } from "../column-DDRvD7SF.mjs";
+import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-CAmi18Uk.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "../expressions-_6JF_J77.mjs";
 import { t as createSchemaDialect } from "../dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue } from "../canonical-DMvR9yBe.mjs";
-import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-BN07IK0v.mjs";
+import { a as toSnapshotJsonValue } from "../canonical-B5_ouh-c.mjs";
+import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-CyobNEx-.mjs";
 import { mysqlDialect } from "../mysql.mjs";
 //#region src/snapshot/mysql.ts
-/** MySQL's v1 snapshot extension identity. */
+/** MySQL's snapshot dialect-extension identity. */
 const mysqlSnapshotDialect = Object.freeze({
 	name: "mysql",
 	version: 1
@@ -29,15 +29,15 @@ const mysqlStorageTypes = Object.freeze({
 /** MySQL's query dialect plus its schema metadata behavior. */
 const mysqlSchemaDialect = createSchemaDialect(mysqlDialect(), {
 	version: 1,
-	validate: validateMysqlSchema,
+	validate: validateSchema,
 	encodeStorage(storage, context) {
-		return encodeMysqlStorage(storage, context.dialect);
+		return encodeStorage(storage, context.dialect);
 	},
 	encodeExpression(expression, context) {
-		return encodeMysqlExpression(expression, context.mode, context.dialect);
+		return encodeExpression(expression, context.mode, context.dialect);
 	},
 	encodeDialectExtension(extension, context) {
-		return encodeMysqlExtension(extension, context.dialect);
+		return encodeExtension(extension, context.dialect);
 	}
 });
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
@@ -56,7 +56,7 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 		adapter: mysqlSnapshotAdapter
 	});
 }
-function encodeMysqlStorage(storage, dialect) {
+function encodeStorage(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");
@@ -74,7 +74,7 @@ function encodeMysqlStorage(storage, dialect) {
 		type
 	};
 }
-function encodeMysqlExpression(expression, mode, dialect) {
+function encodeExpression(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,
@@ -88,7 +88,7 @@ function encodeMysqlExpression(expression, mode, dialect) {
 		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
 	};
 }
-function encodeMysqlExtension(extension, dialect) {
+function encodeExtension(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 {
@@ -102,20 +102,20 @@ function sortSnapshotJson(value) {
 	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) {
+function validateSchema(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);
+	if (schema.namespace !== void 0) validateName(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);
+		validateName(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);
+	for (const [id, entry] of tableEntries) validateTable(id, entry, context, diagnostics);
 	return Object.freeze(diagnostics);
 }
-function validateMysqlTable(tableId, entry, context, diagnostics) {
+function validateTable(tableId, entry, context, diagnostics) {
 	const table = entry.table;
 	const tablePath = ["tables", tableId];
 	const definitions = table.definitions;
@@ -126,7 +126,7 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 			"columns",
 			columnId
 		];
-		validateMysqlName(table.sqlNames[columnId] ?? columnId, [...columnPath, "physicalName"], "MySQL column", diagnostics);
+		validateName(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",
@@ -144,7 +144,7 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 				"autoIncrement"
 			]
 		});
-		if (autoIncrement === true) validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics);
+		if (autoIncrement === true) validateAutoIncrement(columnId, definition, metadata, columnPath, diagnostics);
 	}
 	const constraintNames = /* @__PURE__ */ new Map();
 	const constraints = Object.entries(metadata.constraints);
@@ -155,12 +155,12 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 			constraintId
 		];
 		const physicalName = constraint.physicalName ?? constraintId;
-		validateMysqlName(physicalName, [...constraintPath, "physicalName"], "MySQL constraint", diagnostics);
+		validateName(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",
+			message: "MySQL 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({
@@ -170,7 +170,7 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 		});
 		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",
+			message: "MySQL ordinary UNIQUE constraints use distinct NULL semantics",
 			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({
@@ -192,7 +192,7 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 			indexId
 		];
 		const physicalName = index.physicalName ?? indexId;
-		validateMysqlName(physicalName, [...indexPath, "physicalName"], "MySQL index", diagnostics);
+		validateName(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({
@@ -265,7 +265,7 @@ function validateMysqlTable(tableId, entry, context, diagnostics) {
 		}
 	}
 }
-function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics) {
+function validateAutoIncrement(columnId, definition, metadata, columnPath, diagnostics) {
 	if (definition.nullable) diagnostics.push({
 		code: "unsupported-dialect-option",
 		message: "MySQL AUTO_INCREMENT columns must be non-nullable",
@@ -276,13 +276,13 @@ function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath,
 		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({
+	const declaration = declarationFor(definition.storage);
+	if (declaration === void 0 || !isIntegerDeclaration(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({
+	if (!hasAutoIncrementKey(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: [
@@ -293,15 +293,15 @@ function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath,
 		]
 	});
 }
-function mysqlDeclaration(storage) {
+function declarationFor(storage) {
 	if (storage === void 0) return;
 	return storage.kind === "native" ? storage.type : mysqlStorageTypes[storage.type];
 }
-function isMysqlIntegerDeclaration(declaration) {
+function isIntegerDeclaration(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) {
+function hasAutoIncrementKey(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];
@@ -310,7 +310,7 @@ function hasMysqlAutoIncrementKey(columnId, metadata) {
 	}
 	return false;
 }
-function validateMysqlName(name, path, kind, diagnostics) {
+function validateName(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`,

package/dist/snapshot/postgres.d.mts

@@ -1,12 +1,12 @@
-import { Tr as SchemaDialect, Ur as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-C0VkiwpR.mjs";
-import { t as SchemaSnapshotOptions } from "../serialize-CEIIlWhC.mjs";
+import { Yi as Schema, ji as SchemaDialect, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-Dqr4o2I1.mjs";
+import { t as SchemaSnapshotOptions } from "../serialize-Du2UPZMt.mjs";
 //#region src/snapshot/postgres.d.ts
-/** PostgreSQL's v1 snapshot extension identity. */
+/** PostgreSQL's snapshot dialect-extension identity. */
 declare const postgresSnapshotDialect: SnapshotDialect;
 /** PostgreSQL's query dialect plus its schema metadata behavior. */
-declare const postgresSchemaDialect: SchemaDialect<"ilike" | "json" | "on-conflict" | "row-locking">;
+declare const postgresSchemaDialect: SchemaDialect<"ilike" | "json" | "on-conflict" | "row-locking" | "update-from">;
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
-declare const postgresSnapshotAdapter: SchemaSnapshotAdapter<"ilike" | "json" | "on-conflict" | "row-locking">;
+declare const postgresSnapshotAdapter: SchemaSnapshotAdapter<"ilike" | "json" | "on-conflict" | "row-locking" | "update-from">;
 /** Create a canonical PostgreSQL schema snapshot. */
 declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: PostgresSnapshotOptions): SchemaSnapshot;
 /** Return PostgreSQL capability diagnostics without throwing. */

package/dist/snapshot/postgres.mjs

@@ -1,12 +1,12 @@
-import { d as isValidSchemaObjectName } from "../column-r1Y4ivwt.mjs";
-import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-YGyNPQ_z.mjs";
-import { c as isUnsafeSchemaSql, u as renderSchemaExpression } from "../registry-BRcUuazJ.mjs";
+import { v as isValidSchemaObjectName } from "../column-DDRvD7SF.mjs";
+import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-CAmi18Uk.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "../expressions-_6JF_J77.mjs";
 import { t as createSchemaDialect } from "../dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue } from "../canonical-DMvR9yBe.mjs";
-import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-BN07IK0v.mjs";
-import { postgresDialect } from "../postgres.mjs";
+import { a as toSnapshotJsonValue } from "../canonical-B5_ouh-c.mjs";
+import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-CyobNEx-.mjs";
+import { n as postgresDialect } from "../postgres-hFhd0I9n.mjs";
 //#region src/snapshot/postgres.ts
-/** PostgreSQL's v1 snapshot extension identity. */
+/** PostgreSQL's snapshot dialect-extension identity. */
 const postgresSnapshotDialect = Object.freeze({
 	name: "postgresql",
 	version: 1
@@ -29,15 +29,15 @@ const postgresStorageTypes = Object.freeze({
 /** PostgreSQL's query dialect plus its schema metadata behavior. */
 const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
 	version: 1,
-	validate: validatePostgresSchema,
+	validate: validateSchema,
 	encodeStorage(storage, context) {
-		return encodePostgresStorage(storage, context.dialect);
+		return encodeStorage(storage, context.dialect);
 	},
 	encodeExpression(expression, context) {
-		return encodePostgresExpression(expression, context.mode, context.dialect);
+		return encodeExpression(expression, context.mode, context.dialect);
 	},
 	encodeDialectExtension(extension, context) {
-		return encodePostgresExtension(extension, context.dialect);
+		return encodeExtension(extension, context.dialect);
 	}
 });
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
@@ -56,7 +56,7 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 		adapter: postgresSnapshotAdapter
 	});
 }
-function encodePostgresStorage(storage, dialect) {
+function encodeStorage(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");
@@ -74,7 +74,7 @@ function encodePostgresStorage(storage, dialect) {
 		type
 	};
 }
-function encodePostgresExpression(expression, mode, dialect) {
+function encodeExpression(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,
@@ -88,7 +88,7 @@ function encodePostgresExpression(expression, mode, dialect) {
 		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
 	};
 }
-function encodePostgresExtension(extension, dialect) {
+function encodeExtension(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 {
@@ -102,25 +102,25 @@ function sortSnapshotJson(value) {
 	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 validatePostgresSchema(schema, context) {
+function validateSchema(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) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
+	if (schema.namespace !== void 0) validateName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
 	for (const [id, entry] of tableEntries) {
 		const tablePath = ["tables", id];
-		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
+		validateName(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);
+	for (const [id, entry] of tableEntries) validateTable(id, entry, context, relationNames, diagnostics);
 	return Object.freeze(diagnostics);
 }
-function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
+function validateTable(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(left, right))) {
-		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
+		validateName(table.sqlNames[columnId] ?? columnId, [
 			...tablePath,
 			"columns",
 			columnId,
@@ -139,7 +139,7 @@ function validatePostgresTable(tableId, entry, context, relationNames, diagnosti
 		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",
+			message: "PostgreSQL snapshots support stored generated columns only; virtual generated columns are not supported",
 			path: [
 				...tablePath,
 				"columns",
@@ -159,7 +159,7 @@ function validatePostgresTable(tableId, entry, context, relationNames, diagnosti
 			constraintId
 		];
 		const physicalName = constraint.physicalName ?? constraintId;
-		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
+		validateName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
 		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
 		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
 		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
@@ -174,7 +174,7 @@ function validatePostgresTable(tableId, entry, context, relationNames, diagnosti
 		});
 		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",
+			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the adapter does not assume PostgreSQL 15 or newer",
 			path: [...constraintPath, "nulls"]
 		});
 	}
@@ -186,12 +186,12 @@ function validatePostgresTable(tableId, entry, context, relationNames, diagnosti
 			indexId
 		];
 		const physicalName = index.physicalName ?? indexId;
-		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
+		validateName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
 		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
 		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
 	}
 }
-function validatePostgresName(name, path, kind, diagnostics) {
+function validateName(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`,

package/dist/snapshot/sqlite.d.mts

@@ -1,7 +1,7 @@
-import { Tr as SchemaDialect, Ur as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-C0VkiwpR.mjs";
-import { t as SchemaSnapshotOptions } from "../serialize-CEIIlWhC.mjs";
+import { Yi as Schema, ji as SchemaDialect, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-Dqr4o2I1.mjs";
+import { t as SchemaSnapshotOptions } from "../serialize-Du2UPZMt.mjs";
 //#region src/snapshot/sqlite.d.ts
-/** SQLite's v1 snapshot extension identity. */
+/** SQLite's snapshot dialect-extension identity. */
 declare const sqliteSnapshotDialect: SnapshotDialect;
 /** SQLite's five declared-type affinity categories. */
 type SqliteStorageAffinity = "blob" | "integer" | "numeric" | "real" | "text";
@@ -10,7 +10,7 @@ type SqliteStorageAffinity = "blob" | "integer" | "numeric" | "real" | "text";
  * ordered substring rules at table creation time; the returned affinity is useful metadata, not a
  * replacement for the exact type.
  */
-declare function sqliteStorageAffinity(declaration: string): SqliteStorageAffinity;
+declare function storageAffinity(declaration: string): SqliteStorageAffinity;
 /** SQLite's query dialect plus its schema metadata behavior. */
 declare const sqliteSchemaDialect: SchemaDialect<"json" | "on-conflict">;
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
@@ -22,4 +22,4 @@ declare function tryCreateSchemaSnapshot<TSchema extends Schema<any>>(schema: TS
 /** Options accepted by the SQLite snapshot convenience functions. */
 type SqliteSnapshotOptions = Omit<SchemaSnapshotOptions, "adapter" | "dialect">;
 //#endregion
-export { SqliteSnapshotOptions, SqliteStorageAffinity, createSchemaSnapshot, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, tryCreateSchemaSnapshot };
+export { SqliteSnapshotOptions, SqliteStorageAffinity, createSchemaSnapshot, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, storageAffinity, tryCreateSchemaSnapshot };

package/dist/snapshot/sqlite.mjs

@@ -1,12 +1,12 @@
-import { d as isValidSchemaObjectName, r as isColumnReference } from "../column-r1Y4ivwt.mjs";
-import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-YGyNPQ_z.mjs";
-import { c as isUnsafeSchemaSql, u as renderSchemaExpression } from "../registry-BRcUuazJ.mjs";
+import { r as isColumnReference, v as isValidSchemaObjectName } from "../column-DDRvD7SF.mjs";
+import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-CAmi18Uk.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "../expressions-_6JF_J77.mjs";
 import { t as createSchemaDialect } from "../dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue } from "../canonical-DMvR9yBe.mjs";
+import { a as toSnapshotJsonValue } from "../canonical-B5_ouh-c.mjs";
+import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-CyobNEx-.mjs";
 import { sqliteDialect } from "../sqlite.mjs";
-import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-BN07IK0v.mjs";
 //#region src/snapshot/sqlite.ts
-/** SQLite's v1 snapshot extension identity. */
+/** SQLite's snapshot dialect-extension identity. */
 const sqliteSnapshotDialect = Object.freeze({
 	name: "sqlite",
 	version: 1
@@ -31,7 +31,7 @@ const sqliteStorageTypes = Object.freeze({
 * ordered substring rules at table creation time; the returned affinity is useful metadata, not a
 * replacement for the exact type.
 */
-function sqliteStorageAffinity(declaration) {
+function storageAffinity(declaration) {
 	const upper = declaration.toUpperCase();
 	if (upper.includes("INT")) return "integer";
 	if (upper.includes("CHAR") || upper.includes("CLOB") || upper.includes("TEXT")) return "text";
@@ -42,15 +42,15 @@ function sqliteStorageAffinity(declaration) {
 /** SQLite's query dialect plus its schema metadata behavior. */
 const sqliteSchemaDialect = createSchemaDialect(sqliteDialect(), {
 	version: 1,
-	validate: validateSqliteSchema,
+	validate: validateSchema,
 	encodeStorage(storage, context) {
-		return encodeSqliteStorage(storage, context.dialect);
+		return encodeStorage(storage, context.dialect);
 	},
 	encodeExpression(expression, context) {
-		return encodeSqliteExpression(expression, context.mode, context.dialect);
+		return encodeExpression(expression, context.mode, context.dialect);
 	},
 	encodeDialectExtension(extension, context) {
-		return encodeSqliteExtension(extension, context.dialect);
+		return encodeExtension(extension, context.dialect);
 	}
 });
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
@@ -69,7 +69,7 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 		adapter: sqliteSnapshotAdapter
 	});
 }
-function encodeSqliteStorage(storage, dialect) {
+function encodeStorage(storage, dialect) {
 	if (storage.kind === "native") {
 		if (storage.dialect !== dialect.name) throw new SqliteSnapshotDialectError(`SQLite storage cannot encode a native declaration owned by "${storage.dialect}"`);
 		if (storage.type.trim().length === 0) throw new TypeError("SQLite native storage declarations cannot be empty");
@@ -77,7 +77,7 @@ function encodeSqliteStorage(storage, dialect) {
 			kind: "native",
 			dialect: dialect.name,
 			type: storage.type,
-			affinity: sqliteStorageAffinity(storage.type)
+			affinity: storageAffinity(storage.type)
 		};
 	}
 	const type = sqliteStorageTypes[storage.type];
@@ -86,10 +86,10 @@ function encodeSqliteStorage(storage, dialect) {
 		kind: "native",
 		dialect: dialect.name,
 		type,
-		affinity: sqliteStorageAffinity(type)
+		affinity: storageAffinity(type)
 	};
 }
-function encodeSqliteExpression(expression, mode, dialect) {
+function encodeExpression(expression, mode, dialect) {
 	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new SqliteSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the SQLite schema dialect is "${dialect.name}"`);
 	const rendered = renderSchemaExpression(expression, {
 		mode,
@@ -103,7 +103,7 @@ function encodeSqliteExpression(expression, mode, dialect) {
 		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
 	};
 }
-function encodeSqliteExtension(extension, dialect) {
+function encodeExtension(extension, dialect) {
 	if (extension.dialect !== dialect.name) throw new TypeError(`SQLite schema extensions require dialect "${dialect.name}"`);
 	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
 	return {
@@ -117,26 +117,26 @@ function sortSnapshotJson(value) {
 	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 validateSqliteSchema(schema, context) {
+function validateSchema(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) validateSqliteName(schema.namespace, ["namespace"], "SQLite namespace", diagnostics);
+	if (schema.namespace !== void 0) validateName(schema.namespace, ["namespace"], "SQLite namespace", diagnostics);
 	for (const [id, entry] of tableEntries) {
 		const tablePath = ["tables", id];
-		validateSqliteName(entry.physicalName, [...tablePath, "physicalName"], "SQLite table", diagnostics);
+		validateName(entry.physicalName, [...tablePath, "physicalName"], "SQLite table", diagnostics);
 		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
 	}
-	for (const [id, entry] of tableEntries) validateSqliteTable(id, entry, context, relationNames, diagnostics);
+	for (const [id, entry] of tableEntries) validateTable(id, entry, context, relationNames, diagnostics);
 	return Object.freeze(diagnostics);
 }
-function validateSqliteTable(tableId, entry, context, relationNames, diagnostics) {
+function validateTable(tableId, entry, context, relationNames, 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))) {
-		validateSqliteName(table.sqlNames[columnId] ?? columnId, [
+		validateName(table.sqlNames[columnId] ?? columnId, [
 			...tablePath,
 			"columns",
 			columnId,
@@ -172,8 +172,8 @@ function validateSqliteTable(tableId, entry, context, relationNames, diagnostics
 				]
 			});
 			const primary = primaryKeyForColumn(metadata.constraints, columnId);
-			const declaration = sqliteDeclaration(storage);
-			if ((declaration === void 0 ? void 0 : sqliteStorageAffinity(declaration)) !== "integer") diagnostics.push({
+			const declaration = declarationFor(storage);
+			if ((declaration === void 0 ? void 0 : storageAffinity(declaration)) !== "integer") diagnostics.push({
 				code: "unsupported-dialect-option",
 				message: "SQLite identity columns must use INTEGER affinity so they can be rowid aliases",
 				path: [...identityPath, "generation"]
@@ -213,7 +213,7 @@ function validateSqliteTable(tableId, entry, context, relationNames, diagnostics
 			constraintId
 		];
 		const physicalName = constraint.physicalName ?? constraintId;
-		validateSqliteName(physicalName, [...constraintPath, "physicalName"], "SQLite constraint", diagnostics);
+		validateName(physicalName, [...constraintPath, "physicalName"], "SQLite constraint", diagnostics);
 		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
 		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
 		if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint" || constraint.kind === "check") && (constraint.deferrable === true || constraint.initially !== void 0)) diagnostics.push({
@@ -228,7 +228,7 @@ function validateSqliteTable(tableId, entry, context, relationNames, diagnostics
 		});
 		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
 			code: "unsupported-dialect-option",
-			message: "SQLite UNIQUE constraints always use distinct NULL semantics in v1",
+			message: "SQLite UNIQUE constraints always use distinct NULL semantics",
 			path: [...constraintPath, "nulls"]
 		});
 		if (constraint.dialect?.dialect === "sqlite" && "onConflict" in constraint.dialect && constraint.dialect.onConflict !== void 0 && ![
@@ -255,7 +255,7 @@ function validateSqliteTable(tableId, entry, context, relationNames, diagnostics
 			indexId
 		];
 		const physicalName = index.physicalName ?? indexId;
-		validateSqliteName(physicalName, [...indexPath, "physicalName"], "SQLite index", diagnostics);
+		validateName(physicalName, [...indexPath, "physicalName"], "SQLite index", diagnostics);
 		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
 		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
 		if (index.dialect?.dialect === "sqlite" && "auto" in index.dialect && index.dialect.auto !== void 0 && typeof index.dialect.auto !== "boolean") diagnostics.push({
@@ -269,7 +269,7 @@ function validateSqliteTable(tableId, entry, context, relationNames, diagnostics
 		});
 	}
 }
-function sqliteDeclaration(storage) {
+function declarationFor(storage) {
 	if (storage === void 0) return;
 	if (storage.kind === "native") return storage.type;
 	return sqliteStorageTypes[storage.type];
@@ -280,7 +280,7 @@ function primaryKeyForColumn(constraints, columnId) {
 		if (constraint.columns.some((column) => isColumnReference(column) && column.fieldName === columnId)) return constraint.columns;
 	}
 }
-function validateSqliteName(name, path, kind, diagnostics) {
+function validateName(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`,
@@ -318,4 +318,4 @@ function compareIds(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 //#endregion
-export { createSchemaSnapshot, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, tryCreateSchemaSnapshot };
+export { createSchemaSnapshot, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, storageAffinity, tryCreateSchemaSnapshot };