qubu 0.6.0 → 0.6.2

package/dist/column-DDRvD7SF.mjs

@@ -0,0 +1,721 @@
+//#region src/core/dialect.ts
+const standardCastTypes = {
+	integer: "INTEGER",
+	decimal: "DECIMAL",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "TIMESTAMP",
+	uuid: "UUID",
+	json: "JSON",
+	bigint: "BIGINT",
+	binary: "VARBINARY"
+};
+/** Resolve a logical or explicitly named CAST target for a dialect. */
+function resolveCastTarget(dialect, target) {
+	if (target.kind === "named-cast") return target.typeName;
+	return dialect.castTypes?.[target.type] ?? standardCastTypes[target.type];
+}
+const quoteIdentifier = (identifier) => `"${identifier.replaceAll("\"", "\"\"")}"`;
+function createDialect(options) {
+	return Object.freeze({
+		name: options.name,
+		quoteIdentifier: options.quoteIdentifier ?? quoteIdentifier,
+		placeholder: options.placeholder,
+		pagination: options.pagination,
+		rowLocking: options.rowLocking,
+		json: options.json,
+		castTypes: options.castTypes ? Object.freeze({ ...options.castTypes }) : void 0,
+		renderSchemaLiteral: options.renderSchemaLiteral,
+		explain: options.explain,
+		capabilities: Object.freeze([...options.capabilities ?? [], ...options.json ? ["json"] : []])
+	});
+}
+/**
+* Check a capability at runtime for callers that intentionally bypass the typed render boundary or
+* use a dialect supplied by an older integration.
+*/
+function assertDialectCapability(dialect, capability) {
+	if (dialect.capabilities?.includes(capability)) return;
+	throw new Error(`Dialect "${dialect.name}" does not support the "${capability}" capability`);
+}
+/** Extend a dialect with capabilities owned by an addon without changing its SQL policies. */
+function extendDialect(dialect, additionalCapabilities) {
+	const capabilities = Object.freeze([.../* @__PURE__ */ new Set([...dialect.capabilities ?? [], ...additionalCapabilities])]);
+	return Object.freeze({
+		...dialect,
+		capabilities
+	});
+}
+//#endregion
+//#region src/dialects/json.ts
+function jsonPath(path) {
+	return path.reduce((result, segment) => typeof segment === "number" ? `${result}[${segment}]` : `${result}.${JSON.stringify(segment)}`, "$");
+}
+function appendPath(context, path, requiredType) {
+	context.append("'");
+	context.append(jsonPath(path).replaceAll("'", "''"));
+	if (requiredType) {
+		const type = requiredType === "text" ? "string" : requiredType;
+		context.append(` ? (@.type() == "${type}")`);
+	}
+	context.append("'");
+}
+function renderSqlJsonValue(context, document, path, returning, requiredType) {
+	context.append("JSON_VALUE(");
+	context.render(document);
+	context.append(", ");
+	appendPath(context, path, requiredType);
+	context.append(` RETURNING ${returning} NULL ON EMPTY NULL ON ERROR)`);
+}
+const standardJson = {
+	renderScalar(context, document, path, kind) {
+		renderSqlJsonValue(context, document, path, kind === "text" ? "VARCHAR(512)" : kind === "number" ? "DOUBLE PRECISION" : "BOOLEAN", kind);
+	},
+	renderExists(context, document, path) {
+		context.append("COALESCE(JSON_EXISTS(");
+		context.render(document);
+		context.append(", ");
+		appendPath(context, path);
+		context.append(" FALSE ON ERROR), FALSE)");
+	}
+};
+function renderPostgresTarget(context, document, path) {
+	context.append("jsonb_path_query_first(CAST(");
+	context.render(document);
+	context.append(" AS JSONB), ");
+	appendPath(context, path);
+	context.append(")");
+}
+function postgresType(kind) {
+	return kind === "text" ? "string" : kind;
+}
+const postgresJson = {
+	renderScalar(context, document, path, kind) {
+		context.append("(CASE jsonb_typeof(");
+		renderPostgresTarget(context, document, path);
+		context.append(`) WHEN '${postgresType(kind)}' THEN `);
+		if (kind !== "text") context.append("CAST(");
+		context.append("(");
+		renderPostgresTarget(context, document, path);
+		context.append(" #>> '{}')");
+		if (kind !== "text") context.append(kind === "number" ? " AS DOUBLE PRECISION)" : " AS BOOLEAN)");
+		context.append(" END)");
+	},
+	renderExists(context, document, path) {
+		context.append("COALESCE(jsonb_path_exists(CAST(");
+		context.render(document);
+		context.append(" AS JSONB), ");
+		appendPath(context, path);
+		context.append(", '{}'::JSONB, TRUE), FALSE)");
+	}
+};
+function renderMySqlExtract(context, document, path) {
+	context.append("JSON_EXTRACT(");
+	context.render(document);
+	context.append(", ");
+	appendPath(context, path);
+	context.append(")");
+}
+function mysqlType(kind) {
+	return kind === "text" ? "STRING" : kind === "number" ? "INTEGER" : "BOOLEAN";
+}
+const mysqlJson = {
+	renderScalar(context, document, path, kind) {
+		context.append("(CASE JSON_TYPE(");
+		renderMySqlExtract(context, document, path);
+		context.append(`) WHEN '${mysqlType(kind)}' THEN `);
+		if (kind === "boolean") context.append("(");
+		renderSqlJsonValue(context, document, path, kind === "text" ? "CHAR" : kind === "number" ? "DOUBLE" : "CHAR");
+		if (kind === "boolean") context.append(" = 'true')");
+		context.append(" END)");
+	},
+	renderExists(context, document, path) {
+		context.append("COALESCE(JSON_CONTAINS_PATH(");
+		context.render(document);
+		context.append(", 'one', ");
+		appendPath(context, path);
+		context.append("), FALSE)");
+	}
+};
+function renderSqliteExtract(context, document, path) {
+	context.append("json_extract(");
+	context.render(document);
+	context.append(", ");
+	appendPath(context, path);
+	context.append(")");
+}
+function renderSqliteType(context, document, path) {
+	context.append("json_type(");
+	context.render(document);
+	context.append(", ");
+	appendPath(context, path);
+	context.append(")");
+}
+const sqliteJson = {
+	renderScalar(context, document, path, kind) {
+		context.append("(CASE ");
+		renderSqliteType(context, document, path);
+		if (kind === "text") {
+			context.append(" WHEN 'text' THEN ");
+			renderSqliteExtract(context, document, path);
+		} else if (kind === "number") {
+			context.append(" WHEN 'integer' THEN ");
+			renderSqliteExtract(context, document, path);
+			context.append(" WHEN 'real' THEN ");
+			renderSqliteExtract(context, document, path);
+		} else context.append(" WHEN 'true' THEN TRUE WHEN 'false' THEN FALSE");
+		context.append(" END)");
+	},
+	renderExists(context, document, path) {
+		context.append("(");
+		renderSqliteType(context, document, path);
+		context.append(" IS NOT NULL)");
+	}
+};
+//#endregion
+//#region src/result.ts
+const resultValueMetadata = Symbol("qubu.result-value-metadata");
+function resultValue(type, decoder, sqlType) {
+	return type === void 0 && decoder === void 0 && sqlType === void 0 ? void 0 : Object.freeze({
+		...type === void 0 ? {} : { type },
+		...decoder === void 0 ? {} : { decoder },
+		...sqlType === void 0 ? {} : { sqlType }
+	});
+}
+function resultValueOf(value) {
+	if (typeof value !== "object" || value === null) return;
+	return value[resultValueMetadata];
+}
+function attachResultValue(value, metadata) {
+	if (metadata === void 0) return value;
+	return Object.freeze({
+		...value,
+		[resultValueMetadata]: metadata
+	});
+}
+function createResultShape(fields) {
+	return Object.freeze({ fields: Object.freeze(fields.map((field) => Object.freeze({ ...field }))) });
+}
+function resultShapeValue(shape, name) {
+	const field = shape.fields.find((candidate) => candidate.name === name);
+	return field === void 0 ? void 0 : resultValue(field.type, field.decoder, field.sqlType);
+}
+/** Decode SQLite/MySQL-style boolean values while accepting native booleans. */
+const booleanResultDecoder = (value) => {
+	if (typeof value === "boolean") return value;
+	if (value === 0 || value === 0n) return false;
+	if (value === 1 || value === 1n) return true;
+	throw new TypeError("Expected a boolean or numeric 0/1 result");
+};
+/** Decode a SQL DATE string as a JavaScript Date at UTC midnight. */
+const dateResultDecoder = (value) => {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/u.test(value)) throw new TypeError("Expected a valid Date or YYYY-MM-DD result");
+	const decoded = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	if (Number.isNaN(decoded.getTime()) || decoded.toISOString().slice(0, 10) !== value) throw new TypeError("Expected a valid calendar date result");
+	return decoded;
+};
+/** Decode a SQL/ISO timestamp string while accepting driver-created Dates. */
+const timestampResultDecoder = (value) => {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string") throw new TypeError("Expected a valid Date or timestamp string result");
+	const normalized = value.includes("T") ? value : value.replace(" ", "T");
+	const decoded = new Date(/(?:Z|[+-]\d{2}:?\d{2})$/u.test(normalized) ? normalized : `${normalized}Z`);
+	if (Number.isNaN(decoded.getTime())) throw new TypeError("Expected a valid timestamp result");
+	return decoded;
+};
+/** Decode a serialized JSON result. Use only when the adapter returns JSON text. */
+const jsonTextResultDecoder = (value) => {
+	if (typeof value !== "string") return value;
+	return JSON.parse(value);
+};
+/** Decode an exact integer result without ever accepting an unsafe JavaScript number. */
+const bigintResultDecoder = (value) => {
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number") {
+		if (Number.isSafeInteger(value)) return BigInt(value);
+		throw new TypeError("Expected a bigint, canonical integer string, or safe integer result");
+	}
+	if (typeof value !== "string" || !/^[+-]?\d+$/u.test(value)) throw new TypeError("Expected a bigint, canonical integer string, or safe integer result");
+	return BigInt(value);
+};
+/** Error raised when a projected driver value cannot be decoded. */
+var ResultDecodingError = class extends TypeError {
+	name = "ResultDecodingError";
+	field;
+	rowIndex;
+	resultType;
+	constructor(field, rowIndex, resultType) {
+		super(`Could not decode result field "${field}" in row ${rowIndex}${resultType === void 0 ? "" : ` as ${resultType}`}`);
+		this.field = field;
+		this.rowIndex = rowIndex;
+		this.resultType = resultType;
+	}
+};
+function decodeResultRow(row, shape, decoders, dialect, rowIndex) {
+	let decoded;
+	for (const field of shape.fields) {
+		const decoder = field.decoder ?? (field.type === "bigint" ? decoders?.bigint ?? bigintResultDecoder : field.type ? decoders?.[field.type] : void 0);
+		if (decoder === void 0 || row[field.name] === null) continue;
+		try {
+			decoded ??= { ...row };
+			decoded[field.name] = decoder(row[field.name], {
+				dialect,
+				field: field.name,
+				rowIndex
+			});
+		} catch {
+			throw new ResultDecodingError(field.name, rowIndex, field.type);
+		}
+	}
+	return decoded ?? row;
+}
+//#endregion
+//#region src/core/fragment.ts
+function fragment(render) {
+	return Object.freeze({ render });
+}
+function sequence(parts, separator = " ") {
+	return fragment((context) => {
+		let first = true;
+		for (const part of parts) {
+			if (!first) context.append(separator);
+			context.render(part);
+			first = false;
+		}
+	});
+}
+function parenthesize(part) {
+	return fragment((context) => {
+		context.append("(");
+		context.render(part);
+		context.append(")");
+	});
+}
+function isFragment(value) {
+	return typeof value === "object" && value !== null && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/expressions/types.ts
+/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
+const schemaExpressionBrand = Symbol("qubu.schema-expression");
+/** Add a concrete dialect requirement without dropping expression metadata. */
+function withDialectCapability(expression, capability) {
+	const wrapped = makeExpression(expression.expressionKind, (context) => {
+		assertDialectCapability(context.dialect, capability);
+		context.render(expression);
+	}, expression.expressionCategory, resultValueOf(expression));
+	return isSchemaExpression(expression) ? markSchemaExpression(wrapped) : wrapped;
+}
+function makeExpression(expressionKind, render, expressionCategory, result) {
+	return attachResultValue(Object.freeze({
+		expressionKind,
+		...expressionCategory ? { expressionCategory } : {},
+		...fragment(render)
+	}), result);
+}
+/** Mark a query-only expression category without changing its SQL renderer. */
+function markExpressionCategory(expression, category) {
+	return Object.freeze({
+		...expression,
+		expressionCategory: category
+	});
+}
+/**
+* Mark a built-in or explicitly audited renderer as schema-deterministic. Prefer
+* {@link defineSchemaExpression} for application extensions because it supplies a restricted schema
+* rendering context.
+*/
+function makeSchemaExpression(expressionKind, render, result) {
+	const expression = makeExpression(expressionKind, render, void 0, result);
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Add the schema-determinism brand to an explicitly audited expression. */
+function markSchemaExpression(expression) {
+	if (isSchemaExpression(expression)) return expression;
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Test the runtime brand used by schema rendering and validation. */
+function isSchemaExpression(value) {
+	return typeof value === "object" && value !== null && schemaExpressionBrand in value && value[schemaExpressionBrand] === true;
+}
+function isExpression(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/core/naming.ts
+/** Convert an application-facing field name to a SQL-facing identifier. */
+function snakeCaseIdentifier(name) {
+	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function resolveSqlNames(fields) {
+	const sqlNames = {};
+	const fieldsBySqlName = /* @__PURE__ */ new Map();
+	for (const field of fields) {
+		const sqlName = field.sqlName ?? snakeCaseIdentifier(field.fieldName);
+		if (sqlName.length === 0) throw new Error(`SQL name for field "${field.fieldName}" cannot be empty`);
+		const existingField = fieldsBySqlName.get(sqlName);
+		if (existingField) throw new Error(`Fields "${existingField}" and "${field.fieldName}" both resolve to SQL name "${sqlName}"`);
+		fieldsBySqlName.set(sqlName, field.fieldName);
+		sqlNames[field.fieldName] = sqlName;
+	}
+	return Object.freeze(sqlNames);
+}
+//#endregion
+//#region src/schema/metadata.ts
+/** Error raised when relational metadata cannot be represented safely. */
+var SchemaMetadataValidationError = class extends TypeError {
+	name = "SchemaMetadataValidationError";
+	diagnostics;
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+			...diagnostic,
+			path: Object.freeze([...diagnostic.path]),
+			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
+		})));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+/** Generate the version-one physical name for a relational object ID. */
+function generatedSchemaObjectName(id) {
+	return snakeCaseIdentifier(id);
+}
+/** Deep-freeze plain metadata values without introducing executable nodes. */
+function freezeSchemaMetadata(value) {
+	if (Array.isArray(value)) return Object.freeze(value.map((item) => freezeSchemaMetadata(item)));
+	if (typeof value !== "object" || value === null) return value;
+	const frozen = Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, freezeSchemaMetadata(nested)]));
+	return Object.freeze(frozen);
+}
+/** Check the portable identifier subset used for generated metadata names. */
+function isValidSchemaObjectName(name) {
+	return name.length > 0 && name === name.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(name);
+}
+/**
+* Attach a record key and resolved physical name without changing the enumerable shape of legacy
+* constraint/index values. The properties are still ordinary read-only runtime metadata and are
+* available to snapshot traversals.
+*/
+function materializeSchemaObjectIdentity(value, id, physicalName) {
+	const materialized = { ...value };
+	Object.defineProperties(materialized, {
+		id: {
+			configurable: false,
+			enumerable: false,
+			value: id,
+			writable: false
+		},
+		physicalName: {
+			configurable: false,
+			enumerable: false,
+			value: physicalName ?? generatedSchemaObjectName(id),
+			writable: false
+		}
+	});
+	return Object.freeze(materialized);
+}
+/**
+* Resolve and validate names for one metadata record. The caller decides whether constraint and
+* index names share a database namespace.
+*/
+function materializeSchemaObjectRecord(record, kind) {
+	const diagnostics = [];
+	const names = /* @__PURE__ */ new Map();
+	const result = {};
+	for (const [id, value] of Object.entries(record)) {
+		const physicalName = value.physicalName ?? generatedSchemaObjectName(id);
+		const path = [kind === "constraint" ? "constraints" : "indexes", id];
+		if (!isValidSchemaObjectName(physicalName)) diagnostics.push({
+			code: "invalid-physical-name",
+			message: `The ${kind} "${id}" has invalid physical name "${physicalName}"`,
+			path: [...path, "physicalName"]
+		});
+		const previousId = names.get(physicalName);
+		if (previousId !== void 0) diagnostics.push({
+			code: "duplicate-physical-name",
+			message: `The ${kind}s "${previousId}" and "${id}" both use physical name "${physicalName}"`,
+			path: [...path, "physicalName"],
+			relatedPaths: [[
+				kind === "constraint" ? "constraints" : "indexes",
+				previousId,
+				"physicalName"
+			]]
+		});
+		else names.set(physicalName, id);
+		result[id] = materializeSchemaObjectIdentity(value, id, physicalName);
+	}
+	if (diagnostics.length > 0) throw new SchemaMetadataValidationError(diagnostics);
+	return Object.freeze(result);
+}
+/** Return a diagnostic when a dialect extension is used by another adapter. */
+function dialectMismatchDiagnostic(extension, dialect, path) {
+	if (extension.dialect === dialect) return;
+	return {
+		code: "dialect-mismatch",
+		message: `Dialect extension belongs to "${extension.dialect}" but the active schema dialect is "${dialect}"`,
+		path,
+		dialect
+	};
+}
+/** Throw a structured error for one or more dialect capability findings. */
+function assertSchemaDialectSupport(diagnostics) {
+	if (diagnostics.length > 0) throw new SchemaMetadataValidationError(diagnostics);
+}
+//#endregion
+//#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?.options === void 0 ? {} : { options: freezeIdentityOptions(options.options) },
+		...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.options === void 0 ? {} : { options: freezeIdentityOptions(value.options) },
+		...value.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(value.dialect) }
+	});
+}
+function freezeIdentityOptions(value) {
+	return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, item])));
+}
+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");
+	}
+	if (value.options !== void 0) {
+		if (typeof value.options !== "object" || value.options === null || Array.isArray(value.options)) throw new ColumnBehaviorError("invalid-identity", "Identity options must be an object", "identity.options");
+		for (const [key, option] of Object.entries(value.options)) if (typeof option === "number" && !Number.isFinite(option) || typeof option !== "string" && typeof option !== "number" && typeof option !== "boolean" && option !== null && !isSchemaExpression(option)) throw new ColumnBehaviorError("invalid-identity", `Identity option "${key}" must be a finite literal or schema expression`, `identity.options.${key}`);
+	}
+}
+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/core/primitives/identifier.ts
+function identifier(name) {
+	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
+}
+function qualifiedIdentifier(...parts) {
+	return fragment((context) => {
+		parts.forEach((part, index) => {
+			if (index > 0) context.append(".");
+			context.append(context.dialect.quoteIdentifier(part));
+		});
+	});
+}
+//#endregion
+//#region src/expressions/column.ts
+function createColumnReference(columnName, sourceReference, fieldName, result) {
+	const expression = makeSchemaExpression("column", (context) => {
+		if (context.renderColumnReference) {
+			context.renderColumnReference(columnName);
+			return;
+		}
+		context.render(sourceReference);
+		context.append(".");
+		context.render(identifier(columnName));
+	}, result);
+	return Object.freeze({
+		...expression,
+		fieldName,
+		columnName
+	});
+}
+function isColumnReference(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && value.expressionKind === "column";
+}
+/** Turn an expression into a fragment that renders it without changing it. */
+function expressionFragment(expression) {
+	return fragment((context) => context.render(expression));
+}
+//#endregion
+export { resolveCastTarget as $, fragment as A, decodeResultRow as B, isExpression as C, markExpressionCategory as D, makeSchemaExpression as E, attachResultValue as F, timestampResultDecoder as G, resultShapeValue as H, bigintResultDecoder as I, sqliteJson as J, mysqlJson as K, booleanResultDecoder as L, parenthesize as M, sequence as N, markSchemaExpression as O, ResultDecodingError as P, extendDialect as Q, createResultShape as R, snakeCaseIdentifier as S, makeExpression as T, resultValue as U, jsonTextResultDecoder as V, resultValueOf as W, assertDialectCapability as X, standardJson as Y, createDialect as Z, generatedSchemaObjectName as _, qualifiedIdentifier as a, materializeSchemaObjectRecord as b, externalDefault as c, identityColumn as d, resolveColumnBehavior as f, freezeSchemaMetadata as g, dialectMismatchDiagnostic as h, identifier as i, isFragment as j, withDialectCapability as k, externalGeneratedColumn as l, assertSchemaDialectSupport as m, expressionFragment as n, ColumnBehaviorError as o, SchemaMetadataValidationError as p, postgresJson as q, isColumnReference as r, canonicalLiteral as s, createColumnReference as t, generatedColumn as u, isValidSchemaObjectName as v, isSchemaExpression as w, resolveSqlNames as x, materializeSchemaObjectIdentity as y, dateResultDecoder as z };