qubu 0.5.1 → 0.6.1

package/dist/column-CFvSbil0.mjs

@@ -0,0 +1,309 @@
+import { S as isSchemaExpression, m as freezeSchemaMetadata, z as resultValue } from "./column-BzN8KFJa.mjs";
+//#region src/schema/column-behavior.ts
+/** A column behavior error with a stable code and optional property path. */
+var ColumnBehaviorError = class extends TypeError {
+	code;
+	path;
+	constructor(code, message, path) {
+		super(message);
+		this.name = "ColumnBehaviorError";
+		this.code = code;
+		this.path = path;
+	}
+};
+/** Build a canonical literal node from a supported JavaScript scalar. */
+function canonicalLiteral(value) {
+	if (value === null) return Object.freeze({ kind: "null" });
+	if (typeof value === "boolean") return Object.freeze({
+		kind: "boolean",
+		value
+	});
+	if (typeof value === "string") return Object.freeze({
+		kind: "string",
+		value
+	});
+	if (typeof value === "bigint") return Object.freeze({
+		kind: "bigint",
+		value: String(value)
+	});
+	if (!Number.isFinite(value)) throw new ColumnBehaviorError("invalid-default", "Default literal numbers must be finite", "default.value");
+	return Object.freeze({
+		kind: "number",
+		value: Object.is(value, -0) ? "0" : String(value)
+	});
+}
+function literalDefault(value) {
+	return Object.freeze({
+		kind: "literal",
+		value: canonicalLiteral(value)
+	});
+}
+/** Normalize a public default input into its canonical snapshot descriptor. */
+function normalizeDefault(value) {
+	if (isSchemaExpression(value)) return Object.freeze({
+		kind: "expression",
+		expression: value
+	});
+	if (isExternalDefaultDescriptor(value)) return externalDefault();
+	return literalDefault(value);
+}
+/** Mark a legacy or externally managed database default explicitly. */
+function externalDefault() {
+	return Object.freeze({ kind: "external" });
+}
+/** Create an immutable generated-column descriptor. */
+function generatedColumn(expression, mode) {
+	assertSchemaExpression(expression, "generatedColumn.expression", "invalid-generated-column");
+	const resolvedMode = typeof mode === "string" ? mode : mode?.mode ?? "stored";
+	if (resolvedMode !== "stored" && resolvedMode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", `Generated-column mode must be "stored" or "virtual", received "${String(resolvedMode)}"`, "generatedColumn.mode");
+	return Object.freeze({
+		kind: "expression",
+		expression,
+		mode: resolvedMode
+	});
+}
+/** Mark a legacy or externally managed generated column explicitly. */
+function externalGeneratedColumn() {
+	return Object.freeze({ kind: "external" });
+}
+/** Describe a database identity column without inventing a generated SQL expression. */
+function identityColumn(generation, options) {
+	const resolvedGeneration = generation ?? "by-default";
+	if (resolvedGeneration !== "always" && resolvedGeneration !== "by-default") throw new ColumnBehaviorError("invalid-identity", `Identity generation must be "always" or "by-default", received "${String(resolvedGeneration)}"`, "identity.generation");
+	return Object.freeze({
+		kind: "identity",
+		generation: resolvedGeneration,
+		...options?.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(options.dialect) }
+	});
+}
+/** Normalize complete and legacy column behavior into immutable metadata. */
+function resolveColumnBehavior(options) {
+	const hasDefaultFlag = options.hasDefault === true;
+	const defaultFn = options.defaultFn;
+	const generatedFlag = options.generated === true;
+	const defaultDescriptor = options.default === void 0 ? void 0 : normalizeDefault(options.default);
+	const generatedDescriptor = options.generatedColumn;
+	const identityDescriptor = options.identity;
+	const onUpdateExpression = options.onUpdate;
+	if (defaultFn !== void 0 && typeof defaultFn !== "function") throw new ColumnBehaviorError("invalid-runtime-default", "Column defaultFn must be a function", "defaultFn");
+	if (defaultFn !== void 0 && (generatedFlag || generatedDescriptor !== void 0 || identityDescriptor !== void 0)) throw new ColumnBehaviorError("runtime-default-generated-conflict", "A runtime default cannot be combined with generated-column or identity metadata", "defaultFn");
+	if (onUpdateExpression !== void 0 && !isSchemaExpression(onUpdateExpression)) throw new ColumnBehaviorError("invalid-on-update", "Column onUpdate metadata must carry the deterministic schema-expression brand", "onUpdate");
+	if (defaultDescriptor !== void 0) {
+		assertDefaultDescriptor(defaultDescriptor);
+		if (options.hasDefault === false) throw new ColumnBehaviorError("default-flag-conflict", "A complete default descriptor cannot be combined with hasDefault: false", "hasDefault");
+		if (generatedDescriptor !== void 0 || identityDescriptor !== void 0) throw new ColumnBehaviorError("default-generated-conflict", "A column cannot declare a complete default together with generated-column or identity metadata", "default");
+		if (generatedFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete default descriptor cannot be combined with generated: true", "default");
+	}
+	if (generatedDescriptor !== void 0) {
+		assertGeneratedColumnDescriptor(generatedDescriptor);
+		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "A complete generated-column descriptor cannot be combined with generated: false", "generated");
+		if (identityDescriptor !== void 0) throw new ColumnBehaviorError("identity-generated-conflict", "A column cannot declare both generated-column and identity metadata", "generatedColumn");
+		if (hasDefaultFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete generated-column descriptor cannot be combined with hasDefault: true", "generatedColumn");
+	}
+	if (identityDescriptor !== void 0) {
+		assertIdentityDescriptor(identityDescriptor);
+		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "Identity metadata cannot be combined with generated: false", "generated");
+		if (hasDefaultFlag) throw new ColumnBehaviorError("identity-generated-conflict", "Identity metadata cannot be combined with hasDefault: true", "identity");
+	}
+	const normalizedDefault = defaultDescriptor === void 0 ? void 0 : freezeDefaultDescriptor(defaultDescriptor);
+	const normalizedGenerated = generatedDescriptor === void 0 ? void 0 : freezeGeneratedColumnDescriptor(generatedDescriptor);
+	const normalizedIdentity = identityDescriptor === void 0 ? void 0 : freezeIdentityDescriptor(identityDescriptor);
+	return Object.freeze({
+		hasDefault: hasDefaultFlag || normalizedDefault !== void 0,
+		hasRuntimeDefault: defaultFn !== void 0,
+		generated: generatedFlag || normalizedGenerated !== void 0 || normalizedIdentity !== void 0,
+		default: normalizedDefault ?? (hasDefaultFlag ? externalDefault() : void 0),
+		defaultFn,
+		generatedColumn: normalizedGenerated ?? (generatedFlag && normalizedIdentity === void 0 ? externalGeneratedColumn() : void 0),
+		identity: normalizedIdentity,
+		onUpdate: onUpdateExpression
+	});
+}
+function freezeDefaultDescriptor(value) {
+	if (value.kind === "external") return externalDefault();
+	if (value.kind === "expression") return Object.freeze({
+		kind: "expression",
+		expression: value.expression
+	});
+	return Object.freeze({
+		kind: "literal",
+		value: Object.freeze({ ...value.value })
+	});
+}
+function isExternalDefaultDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "external";
+}
+function freezeGeneratedColumnDescriptor(value) {
+	if (value.kind === "external") return externalGeneratedColumn();
+	return Object.freeze({
+		kind: "expression",
+		expression: value.expression,
+		mode: value.mode
+	});
+}
+function freezeIdentityDescriptor(value) {
+	return Object.freeze({
+		kind: "identity",
+		generation: value.generation,
+		...value.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(value.dialect) }
+	});
+}
+function assertSchemaExpression(expression, path, code = "invalid-default") {
+	if (!isSchemaExpression(expression)) throw new ColumnBehaviorError(code, "Schema behavior expressions must carry the deterministic schema-expression brand", path);
+}
+function assertDefaultDescriptor(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Column default metadata must be an object", "default");
+	if (value.kind === "external") return;
+	if (value.kind === "expression") {
+		assertSchemaExpression(value.expression, "default.expression");
+		return;
+	}
+	if (value.kind === "literal") {
+		assertCanonicalLiteral(value.value);
+		return;
+	}
+	throw new ColumnBehaviorError("invalid-default", "Unknown column default descriptor kind", "default.kind");
+}
+function assertGeneratedColumnDescriptor(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column metadata must be an object", "generatedColumn");
+	if (value.kind === "external") return;
+	if (value.kind === "expression") {
+		assertSchemaExpression(value.expression, "generatedColumn.expression", "invalid-generated-column");
+		if (value.mode !== "stored" && value.mode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column mode must be \"stored\" or \"virtual\"", "generatedColumn.mode");
+		return;
+	}
+	throw new ColumnBehaviorError("invalid-generated-column", "Unknown generated-column descriptor kind", "generatedColumn.kind");
+}
+function assertIdentityDescriptor(value) {
+	if (!value || typeof value !== "object" || value.kind !== "identity" || value.generation !== "always" && value.generation !== "by-default") throw new ColumnBehaviorError("invalid-identity", "Identity metadata must use generation \"always\" or \"by-default\"", "identity.generation");
+	if (value.dialect !== void 0) {
+		if (typeof value.dialect !== "object" || value.dialect === null || typeof value.dialect.dialect !== "string" || value.dialect.dialect.length === 0) throw new ColumnBehaviorError("invalid-identity", "Identity dialect metadata must contain a non-empty dialect tag", "identity.dialect");
+	}
+}
+function assertCanonicalLiteral(value) {
+	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a canonical literal node", "default.value");
+	switch (value.kind) {
+		case "null": return;
+		case "boolean":
+			if (typeof value.value === "boolean") return;
+			break;
+		case "string":
+			if (typeof value.value === "string") return;
+			break;
+		case "number":
+			if (typeof value.value === "string" && value.value.length > 0) return;
+			break;
+		case "bigint": if (/^-?(0|[1-9][0-9]*)$/.test(value.value)) return;
+	}
+	throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a valid canonical literal node", "default.value");
+}
+//#endregion
+//#region src/schema/column.ts
+/** Create an immutable portable physical storage descriptor. */
+function portableStorage(type) {
+	return Object.freeze({
+		kind: "portable",
+		type
+	});
+}
+function nativeStorage(dialectOrOptions, type) {
+	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
+	const declaration = typeof dialectOrOptions === "string" ? type : "type" in dialectOrOptions ? dialectOrOptions.type : dialectOrOptions.declaration;
+	return Object.freeze({
+		kind: "native",
+		dialect,
+		type: declaration
+	});
+}
+function narrowColumnType() {
+	return this;
+}
+function withPortableCast(definition, type) {
+	return Object.freeze({
+		...definition,
+		castTarget: Object.freeze({
+			kind: "portable-cast",
+			type
+		})
+	});
+}
+function withPortableStorage(definition, type) {
+	return Object.freeze({
+		...definition,
+		storage: portableStorage(type)
+	});
+}
+function column(options) {
+	return Object.freeze({
+		definitionKind: "column",
+		nullable: options?.nullable === true,
+		...resolveColumnBehavior(options ?? {}),
+		sqlName: options?.sqlName,
+		storage: options?.storage ? Object.freeze({ ...options.storage }) : void 0,
+		...options?.decode === void 0 && options?.codec === void 0 ? {} : { resultDecoder: options?.decode ?? options?.codec?.fromDriver },
+		...options?.codec === void 0 ? {} : {
+			parameterEncoder: options.codec.toDriver,
+			columnCodec: Object.freeze({ ...options.codec })
+		},
+		$type: narrowColumnType,
+		castTarget: options?.castType ? Object.freeze({
+			kind: "named-cast",
+			typeName: options.castType
+		}) : void 0
+	});
+}
+/** Resolve the runtime result metadata carried by a column definition. */
+function columnResultValue(definition) {
+	const storage = definition.storage;
+	const type = storage?.kind === "portable" && (storage.type === "boolean" || storage.type === "date" || storage.type === "timestamp" || storage.type === "json") ? storage.type : void 0;
+	return resultValue(type, definition.resultDecoder);
+}
+/** Apply a live column codec while preserving SQL NULL unchanged. */
+function encodeColumnParameter(definition, value) {
+	return value === null || definition.parameterEncoder === void 0 ? value : definition.parameterEncoder(value);
+}
+function nativeColumn(storageOrDialect, typeOrOptions, maybeOptions) {
+	const storage = typeof storageOrDialect === "string" ? nativeStorage(storageOrDialect, typeOrOptions) : storageOrDialect;
+	return column({
+		...typeof storageOrDialect === "string" ? maybeOptions : typeOrOptions,
+		storage
+	});
+}
+function nullable(definition) {
+	return Object.freeze({
+		...definition,
+		nullable: true
+	});
+}
+function integer(options) {
+	return withPortableStorage(withPortableCast(column(options), "integer"), "integer");
+}
+function numeric(options) {
+	return withPortableStorage(withPortableCast(column(options), "decimal"), "numeric");
+}
+function text(options) {
+	return withPortableStorage(withPortableCast(column(options), "text"), "text");
+}
+function boolean(options) {
+	return withPortableStorage(withPortableCast(column(options), "boolean"), "boolean");
+}
+function date(options) {
+	return withPortableStorage(withPortableCast(column(options), "date"), "date");
+}
+function timestamp(options) {
+	return withPortableStorage(withPortableCast(column(options), "timestamp"), "timestamp");
+}
+function uuid(options) {
+	return withPortableStorage(withPortableCast(column(options), "uuid"), "uuid");
+}
+function json(options) {
+	return withPortableStorage(withPortableCast(column(options), "json"), "json");
+}
+function bigint(options) {
+	return withPortableStorage(withPortableCast(column(options), "bigint"), "bigint");
+}
+function binary(options) {
+	return withPortableStorage(withPortableCast(column(options), "binary"), "binary");
+}
+//#endregion
+export { identityColumn as C, generatedColumn as S, uuid as _, columnResultValue as a, externalDefault as b, integer as c, nativeStorage as d, nullable as f, timestamp as g, text as h, column as i, json as l, portableStorage as m, binary as n, date as o, numeric as p, boolean as r, encodeColumnParameter as s, bigint as t, nativeColumn as u, ColumnBehaviorError as v, resolveColumnBehavior as w, externalGeneratedColumn as x, canonicalLiteral as y };

package/dist/{complete-types-CY0KbzNw.d.mts → complete-types-CNMWBWap.d.mts}

@@ -1,4 +1,4 @@
-import { A as SnapshotStorage, D as SnapshotLiteral, O as SnapshotNamingPolicy, T as SnapshotJsonValue, b as SnapshotGeneratedColumn, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, m as SnapshotDialect } from "./types-C0VkiwpR.mjs";
+import { A as SnapshotStorage, D as SnapshotLiteral, O as SnapshotNamingPolicy, T as SnapshotJsonValue, b as SnapshotGeneratedColumn, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, m as SnapshotDialect } from "./types-DUe6eeI0.mjs";
 //#region src/snapshot/complete-types.d.ts
 /** The stable envelope tag shared by Snapshot v1 and the complete model. */
 declare const completeSchemaSnapshotFormat: "qubu-schema";

package/dist/constraints-DM_tarXc.mjs

@@ -0,0 +1,208 @@
+import { m as freezeSchemaMetadata, p as dialectMismatchDiagnostic, r as isColumnReference } from "./column-BzN8KFJa.mjs";
+import { c as unsafeSchemaSql } from "./expressions-BCjc08zw.mjs";
+//#region src/schema/indexes.ts
+/**
+* Validate portable and dialect-owned index facts for one target adapter. Unsupported features are
+* reported as data so a serializer can aggregate diagnostics instead of failing during traversal
+* with an opaque exception.
+*/
+function validateIndexDialect(indexMetadata, dialect, path = ["index"]) {
+	const diagnostics = [];
+	const extension = indexMetadata.dialect;
+	if (extension !== void 0) {
+		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
+		if (mismatch !== void 0) diagnostics.push(mismatch);
+	}
+	if ((dialect === "sqlite" || dialect === "mysql") && indexMetadata.includedColumns !== void 0 && indexMetadata.includedColumns.length > 0) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${dialect} indexes do not support included columns`,
+		path: [...path, "includedColumns"],
+		dialect
+	});
+	const mysqlKeyBlockSize = extension?.dialect === "mysql" ? extension.keyBlockSize : void 0;
+	if (mysqlKeyBlockSize !== void 0 && (!Number.isInteger(mysqlKeyBlockSize) || mysqlKeyBlockSize <= 0)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL index keyBlockSize must be a positive integer",
+		path: [
+			...path,
+			"dialect",
+			"keyBlockSize"
+		],
+		dialect
+	});
+	return Object.freeze(diagnostics);
+}
+/** Declare a portable column or expression index. */
+function index(terms, options) {
+	const resolvedOptions = options ?? {};
+	const candidateKey = resolvedOptions.unique === true && resolvedOptions.where === void 0 && terms.every((term) => {
+		return ("orderKind" in term ? term.expression : term).expressionKind === "column";
+	});
+	return Object.freeze({
+		kind: "index",
+		terms: Object.freeze([...terms]),
+		unique: resolvedOptions.unique === true,
+		predicate: resolvedOptions.where,
+		...resolvedOptions.include !== void 0 ? { includedColumns: Object.freeze([...resolvedOptions.include]) } : {},
+		...resolvedOptions.physicalName !== void 0 ? { physicalName: resolvedOptions.physicalName } : {},
+		...resolvedOptions.dialect !== void 0 ? { dialect: freezeSchemaMetadata(resolvedOptions.dialect) } : {},
+		candidateKey
+	});
+}
+//#endregion
+//#region src/schema/constraints.ts
+/**
+* Validate one constraint against a schema adapter dialect. This is kept separate from construction
+* because the same declaration can be inspected for more than one target dialect before a
+* serializer is selected.
+*/
+function validateConstraintDialect(constraint, dialect, path = ["constraint"]) {
+	const diagnostics = [];
+	const extension = constraint.dialect;
+	if (extension !== void 0) {
+		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
+		if (mismatch !== void 0) diagnostics.push(mismatch);
+		if (extension.dialect === "postgresql" && "notValid" in extension && extension.notValid === true && (constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NOT VALID is not supported for key constraints",
+			path: [
+				...path,
+				"dialect",
+				"notValid"
+			],
+			dialect
+		});
+		if (extension.dialect === "sqlite" && "onConflict" in extension && extension.onConflict !== void 0 && constraint.kind === "foreign-key") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite conflict policies do not apply to foreign keys",
+			path: [
+				...path,
+				"dialect",
+				"onConflict"
+			],
+			dialect
+		});
+	}
+	if (constraint.kind === "foreign-key" && constraint.match === "partial" && dialect === "mysql") diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL does not support MATCH PARTIAL foreign keys",
+		path: [...path, "match"],
+		dialect
+	});
+	if (constraint.kind === "foreign-key" && constraint.deferrable === true && dialect === "mysql") diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL foreign keys cannot be declared DEFERRABLE",
+		path: [...path, "deferrable"],
+		dialect
+	});
+	if (constraint.initially !== void 0 && constraint.deferrable !== true) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "An initial constraint timing requires deferrable: true",
+		path: [...path, "initially"],
+		dialect
+	});
+	return Object.freeze(diagnostics);
+}
+function primaryKey(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	return freezeConstraint("primary-key", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
+}
+function unique(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	return freezeConstraint("unique", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
+}
+function uniqueConstraint(...columnsAndOptions) {
+	const last = columnsAndOptions.at(-1);
+	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
+	const columns = options ? columnsAndOptions.slice(0, -1) : columnsAndOptions;
+	const resolvedOptions = options ?? {};
+	return freezeConstraint("unique-constraint", columns, resolvedOptions, resolvedOptions.nulls ?? "distinct");
+}
+/** Pair a table with the exact columns targeted by a foreign key. */
+function references(table, ...columns) {
+	return Object.freeze({
+		table,
+		columns: Object.freeze([...columns])
+	});
+}
+/** Declare a single-column or composite foreign key. */
+function foreignKey(columns, target, options) {
+	return freezeConstraint("foreign-key", columns, options, target);
+}
+/**
+* Reconstruct a foreign key proved by database catalog metadata.
+*
+* @remarks
+*   Use this helper for generated or introspection-owned declarations when one or both native SQL
+*   domains are unresolved. It accepts unresolved domains, but still rejects known domain
+*   mismatches, unequal tuple arity, and local columns from different sources. The enclosing
+*   `table()` declaration continues to verify target-column ownership and candidate-key metadata.
+*   Resolved targets also receive runtime shape, ownership, and arity checks. The returned value
+*   serializes as an ordinary foreign-key constraint.
+*/
+function catalogForeignKey(columns, target, options) {
+	assertCatalogForeignKeyColumns(columns, "local");
+	return freezeConstraint("foreign-key", columns, options, validateCatalogForeignKeyTargetInput(target, columns.length));
+}
+/** Declare a boolean table invariant. */
+function check(expression, options) {
+	return freezeConstraint("check", void 0, options, expression);
+}
+/**
+* Reconstruct a boolean check from opaque SQL recovered from a database catalog.
+*
+* @remarks
+*   This helper records catalog origin as a narrow type-level proof. It gives the opaque expression
+*   the {@link SqlBoolean} semantic type without changing the ordinary {@link check} contract. Qubu
+*   does not parse or infer dependencies from the SQL. It preserves the text apart from normalizing
+*   line endings and retains the dialect tag in serialized schema metadata.
+*/
+function catalogCheck(input, options) {
+	assertCatalogCheckSql(input);
+	return freezeConstraint("check", void 0, options, unsafeSchemaSql(input.dialect, input.sql));
+}
+function assertCatalogCheckSql(value) {
+	if (typeof value !== "object" || value === null) throw new TypeError("catalogCheck() requires dialect-tagged SQL data");
+	const input = value;
+	if (input.dialect !== "postgresql" && input.dialect !== "sqlite" && input.dialect !== "mysql") throw new TypeError(`catalogCheck() requires a supported catalog dialect, received "${String(input.dialect)}"`);
+	if (typeof input.sql !== "string" || input.sql.trim().length === 0) throw new TypeError("catalogCheck() requires non-empty SQL text");
+}
+function assertCatalogForeignKeyColumns(value, side) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`catalogForeignKey() requires at least one ${side} column`);
+	if (!value.every(isColumnReference)) throw new TypeError(`catalogForeignKey() requires ${side} columns to be column references`);
+}
+function validateCatalogForeignKeyTargetInput(value, localArity) {
+	return typeof value === "function" ? () => validateCatalogForeignKeyTarget(value(), localArity) : validateCatalogForeignKeyTarget(value, localArity);
+}
+function validateCatalogForeignKeyTarget(value, localArity) {
+	if (typeof value !== "object" || value === null) throw new TypeError("catalogForeignKey() requires a foreign-key target");
+	const target = value;
+	assertCatalogForeignKeyColumns(target.columns, "target");
+	if (target.columns.length !== localArity) throw new TypeError(`catalogForeignKey() column arity differs: ${localArity} local and ${target.columns.length} target`);
+	const table = target.table;
+	if (typeof table !== "object" || table === null || typeof table.columns !== "object" || table.columns === null) throw new TypeError("catalogForeignKey() target must reference a table");
+	for (const column of target.columns) if (table.columns[column.fieldName] !== column) throw new TypeError(`catalogForeignKey() target column "${column.fieldName}" does not belong to its table`);
+	return target;
+}
+function freezeConstraint(kind, columns, options, extra) {
+	const value = { kind };
+	const optionValues = options;
+	if (columns !== void 0) value.columns = Object.freeze([...columns]);
+	if (kind === "check") value.expression = extra;
+	else if (kind === "foreign-key") value.target = extra;
+	else if (kind === "unique-constraint") value.nulls = extra;
+	if (optionValues?.physicalName !== void 0) value.physicalName = optionValues.physicalName;
+	if (optionValues?.dialect !== void 0) value.dialect = freezeSchemaMetadata(optionValues.dialect);
+	if (optionValues?.deferrable !== void 0) value.deferrable = optionValues.deferrable;
+	if (optionValues?.initially !== void 0) value.initially = optionValues.initially;
+	if (kind === "foreign-key") {
+		if (optionValues?.onUpdate !== void 0) value.onUpdate = optionValues.onUpdate;
+		if (optionValues?.onDelete !== void 0) value.onDelete = optionValues.onDelete;
+		if (optionValues?.match !== void 0) value.match = optionValues.match;
+	}
+	return Object.freeze(value);
+}
+//#endregion
+export { primaryKey as a, uniqueConstraint as c, validateIndexDialect as d, foreignKey as i, validateConstraintDialect as l, catalogForeignKey as n, references as o, check as r, unique as s, catalogCheck as t, index as u };

package/dist/core.d.mts

@@ -1,4 +1,4 @@
-import { $ as PaginationKind, $l as AggregateMeta, $u as SqlNumericLike, Au as RequiresOuterMetadataOf, B as CastTarget, Bl as withDialectCapability, Bu as isFragment, Ca as SelectClause, Cu as ProvidesOuterSourceMeta, Du as RenderFunction, Eu as RenderContext, Fu as SqlTypeOf, G as DialectJson, Ga as typedCall, Gu as SqlBinary, H as DialectCapability, Hu as sequence, Iu as SubqueryMeta, J as DialectRowLocking, Ju as SqlDecimal, K as DialectOptions, Ku as SqlBoolean, Ll as isExpression, Lu as VisibleDependenciesOf, Mu as RequiresOuterSourceMeta, No as typedCast, Nu as RequiresSourceMeta, Ol as Expression, Ou as RequiresCapabilityMeta, Pu as ResultMeta, Q as NamedCastTarget, Ql as AggregateDependenciesOf, Qu as SqlJson, Rl as makeExpression, Ru as WindowMeta, Sa as ClausePlacement, Su as ProvidesOuterOf, Tl as expressionFragment, Tu as QueryCardinality, U as DialectCastTypes, Uu as AnySqlType, V as Dialect, Vu as parenthesize, W as DialectExplain, Wu as SqlBigInt, X as ExplainRenderOptions, Xu as SqlEqualityCompatible, Y as ExplainFormat, Yu as SqlEqualityComparable, Z as JsonScalarKind, Zu as SqlInteger, _l as RenderedQuery, _u as MetadataOf, ad as SqlTimestamp, at as SchemaLiteralRenderer, au as DependenciesOf, bu as NullableSourcesOf, cd as SqlUuid, ct as resolveCastTarget, cu as FragmentMeta, du as GroupingMeta, ed as SqlOrderCompatible, et as PaginationPart, eu as AnyFragment, fu as HasAggregate, gl as RenderOptions, gu as InheritedMetadataOf, hl as RenderCapabilityValidation, hu as InheritedMetadata, id as SqlTextLike, it as RowLockWaitPolicy, iu as CardinalityOf, ju as RequiresOuterOf, ko as typedValue, ku as RequiresOf, lu as GroupingDependenciesOf, mu as HasWindow, nd as SqlSemanticType, nt as PortableCastType, nu as CapabilityMetadataOf, od as SqlTypeSatisfies, ot as assertDialectCapability, ou as ExpressionMeta, pu as HasSubquery, q as DialectPagination, qu as SqlDate, rd as SqlText, rt as RowLockMode, ru as CardinalityMeta, sd as SqlUnknown, st as createDialect, su as Fragment, td as SqlOrderable, tt as PortableCastTarget, tu as CapabilitiesOf, uu as GroupingKeysOf, vl as render, vu as NullabilityOf, wu as ProvidesSourceMeta, xu as OutputOf, yu as NullableSourceMeta, zl as markExpressionCategory, zu as fragment } from "./types-C0VkiwpR.mjs";
+import { $ as PaginationKind, $u as SqlDecimal, Al as expressionFragment, Au as QueryCardinality, B as CastTarget, Bu as SqlTypeOf, Cl as render, Cu as NullabilityOf, Da as ClausePlacement, Du as ProvidesOuterOf, Eu as OutputOf, Fu as RequiresOuterMetadataOf, G as DialectJson, Gl as withDialectCapability, Gu as isFragment, H as DialectCapability, Hl as isExpression, Hu as VisibleDependenciesOf, Iu as RequiresOuterOf, J as DialectRowLocking, Ju as AnySqlType, K as DialectOptions, Ku as parenthesize, Lu as RequiresOuterSourceMeta, Mu as RenderFunction, Nl as Expression, Nu as RequiresCapabilityMeta, Oa as SelectClause, Ou as ProvidesOuterSourceMeta, Po as typedValue, Pu as RequiresOf, Q as NamedCastTarget, Qu as SqlDate, Ro as typedCast, Ru as RequiresSourceMeta, Sl as RenderedQuery, Su as MetadataOf, Tu as NullableSourcesOf, U as DialectCastTypes, Ul as makeExpression, Uu as WindowMeta, V as Dialect, Vu as SubqueryMeta, W as DialectExplain, Wl as markExpressionCategory, Wu as fragment, X as ExplainRenderOptions, Xa as typedCall, Xu as SqlBinary, Y as ExplainFormat, Yu as SqlBigInt, Z as JsonScalarKind, Zu as SqlBoolean, _u as HasAggregate, ad as SqlOrderCompatible, at as SchemaLiteralRenderer, au as AnyFragment, bl as RenderCapabilityValidation, bu as InheritedMetadata, cd as SqlText, ct as resolveCastTarget, cu as CardinalityMeta, dd as SqlTypeSatisfies, du as ExpressionMeta, ed as SqlEqualityComparable, et as PaginationPart, fd as SqlUnknown, fu as Fragment, gu as GroupingMeta, hu as GroupingKeysOf, id as SqlNumericLike, it as RowLockWaitPolicy, iu as AggregateMeta, ju as RenderContext, ku as ProvidesSourceMeta, ld as SqlTextLike, lu as CardinalityOf, mu as GroupingDependenciesOf, nd as SqlInteger, nt as PortableCastType, od as SqlOrderable, ot as assertDialectCapability, ou as CapabilitiesOf, pd as SqlUuid, pu as FragmentMeta, q as DialectPagination, qu as sequence, rd as SqlJson, rt as RowLockMode, ru as AggregateDependenciesOf, sd as SqlSemanticType, st as createDialect, su as CapabilityMetadataOf, td as SqlEqualityCompatible, tt as PortableCastTarget, ud as SqlTimestamp, uu as DependenciesOf, vu as HasSubquery, wu as NullableSourceMeta, xl as RenderOptions, xu as InheritedMetadataOf, yu as HasWindow, zu as ResultMeta } from "./types-DUe6eeI0.mjs";
 //#region src/core/primitives/compose.d.ts
 declare function commaSeparated<const TParts extends readonly AnyFragment[]>(parts: TParts): Fragment<InheritedMetadata<TParts[number]>>;
 declare function keyword<TPart extends AnyFragment | undefined>(value: string, part?: TPart): Fragment<TPart extends AnyFragment ? InheritedMetadata<TPart> : never>;

package/dist/core.mjs

@@ -1,7 +1,6 @@
 import { a as assertDialectCapability, o as createDialect, s as resolveCastTarget } from "./json-Db7XRD91.mjs";
-import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-CTENnDh9.mjs";
-import { B as isExpression, H as makeExpression, J as isFragment, K as withDialectCapability, W as markExpressionCategory, X as sequence, Y as parenthesize, a as qualifiedIdentifier, i as identifier, n as expressionFragment, q as fragment } from "./column-DmazTL67.mjs";
-import { a as parameter, r as typedValue } from "./value-BEEj_Ayd.mjs";
+import { A as parenthesize, C as makeExpression, D as withDialectCapability, O as fragment, T as markExpressionCategory, a as qualifiedIdentifier, c as typedValue, i as identifier, j as sequence, k as isFragment, n as expressionFragment, u as parameter, x as isExpression } from "./column-BzN8KFJa.mjs";
+import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-BLNRatG_.mjs";
 //#region src/core/primitives/compose.ts
 function commaSeparated(parts) {
 	return sequence(parts, ", ");

package/dist/diagnostics-I9vVtXkc.mjs

@@ -0,0 +1,40 @@
+//#region src/introspection/diagnostics.ts
+/**
+* Create one immutable diagnostic without interpreting catalog text or copying driver error details
+* into the structured fields.
+*/
+function createIntrospectionDiagnostic(diagnostic) {
+	return freezeDiagnostic(diagnostic);
+}
+/** Return whether a diagnostic list prevents strict introspection output. */
+function hasIntrospectionErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+/** Error raised by a throwing introspection operation after collecting findings. */
+var IntrospectionError = class extends Error {
+	name = "IntrospectionError";
+	diagnostics;
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => freezeDiagnostic(diagnostic)));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+function freezeDiagnostic(diagnostic) {
+	return Object.freeze({
+		...diagnostic,
+		path: Object.freeze([...diagnostic.path]),
+		physicalReference: diagnostic.physicalReference ? freezeReference(diagnostic.physicalReference) : void 0,
+		relatedReferences: diagnostic.relatedReferences ? Object.freeze(diagnostic.relatedReferences.map((reference) => freezeReference(reference))) : void 0
+	});
+}
+function freezeReference(reference) {
+	return Object.freeze({
+		...reference,
+		catalog: reference.catalog ? Object.freeze({ ...reference.catalog }) : void 0
+	});
+}
+//#endregion
+export { createIntrospectionDiagnostic as n, hasIntrospectionErrors as r, IntrospectionError as t };

package/dist/diff.d.mts

@@ -1,5 +1,5 @@
-import { T as SnapshotJsonValue, m as SnapshotDialect, n as SchemaSnapshot } from "./types-C0VkiwpR.mjs";
-import { S as CompleteSnapshotObjectKind, t as CompleteSchemaSnapshot } from "./complete-types-CY0KbzNw.mjs";
+import { T as SnapshotJsonValue, m as SnapshotDialect, n as SchemaSnapshot } from "./types-DUe6eeI0.mjs";
+import { S as CompleteSnapshotObjectKind, t as CompleteSchemaSnapshot } from "./complete-types-CNMWBWap.mjs";
 //#region src/diff/types.d.ts
 /** Object families understood by the snapshot diff engine. */
 type SnapshotDiffObjectKind = CompleteSnapshotObjectKind;