qubu 0.6.0 → 0.6.2

package/dist/codegen.d.mts

@@ -1,4 +1,4 @@
-import { St as IntrospectionDiagnostic, dt as IntrospectionResult, i as CatalogClassificationConfidence, p as CatalogDialect, z as CatalogPortableStorageType } from "./types-CTCqtFlS.mjs";
+import { V as CatalogPortableStorageType, i as CatalogClassificationConfidence, p as CatalogDialect, pt as IntrospectionResult, wt as IntrospectionDiagnostic } from "./types-CiMvKi5V.mjs";
 //#region src/codegen/types.d.ts
 /** TypeScript value types that the controlled source printer can emit. */
 type CodegenApplicationType = "unknown" | "string" | "number" | "boolean" | "bigint" | "Date" | "Uint8Array";
@@ -84,7 +84,7 @@ type SchemaCodegenResult = SchemaCodegenSuccess | SchemaCodegenFailure;
  *   expressions use dialect-tagged schema data, checks use `catalogCheck()`, and foreign keys use
  *   lazy `catalogForeignKey()` targets. Foreign keys must have equal local and target arity and
  *   target an exact primary key, strict unique key, or candidate index. Nullable database UNIQUE
- *   constraints do not provide that candidate-key proof and fail generation. Application output,
+ *   constraints and indexes with lossy candidate-key facts do not provide that proof. Application output,
  *   insert, and update types default independently to `unknown`. The generator may attach a
  *   conservative SQL semantic domain, and {@link SchemaCodegenOptions.mapColumn} can override either
  *   type axis with a fixed token. Naming callbacks can replace suggested camelCase IDs, but they

package/dist/codegen.mjs

@@ -1,5 +1,5 @@
-import { l as decodeSchemaSnapshot } from "./canonical-DMvR9yBe.mjs";
-import { t as mapCatalogToSnapshot } from "./snapshot-Xam8-q0j.mjs";
+import { c as candidateKeyIndexColumns, l as hasCandidateKeyShape, t as mapCatalogToSnapshot, u as isCandidateKeyIndex } from "./snapshot-mIb-Zzb5.mjs";
+import { l as decodeSchemaSnapshot } from "./canonical-B5_ouh-c.mjs";
 //#region src/codegen/source.ts
 const header = `/* Generated by Qubu. Do not edit this machine-owned file. */
 import * as _qubu from 'qubu'
@@ -62,7 +62,22 @@ function printTable(schema, table, diagnostics) {
 	const tableTypeName = `${typePrefix}Table`;
 	const constraintTypes = table.constraints.map((constraint) => printConstraintType(table, constraint, columnsName, diagnostics));
 	const indexTypes = table.indexes.map((index) => printIndexType(table, index, columnsName, diagnostics));
-	if (constraintTypes.some((value) => value === void 0) || indexTypes.some((value) => value === void 0)) return;
+	const tableDialect = table.snapshot.dialect === void 0 ? void 0 : printExtension(table.snapshot.dialect, schema, [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"dialect"
+	], diagnostics);
+	if (constraintTypes.some((value) => value === void 0) || indexTypes.some((value) => value === void 0) || table.snapshot.dialect !== void 0 && tableDialect === void 0) return;
+	const tableMetadata = [
+		`constraints: {
+${constraints.map((value) => indent(value ?? "", 6)).join("\n")}
+    }`,
+		`indexes: {
+${indexes.map((value) => indent(value ?? "", 6)).join("\n")}
+    }`,
+		...tableDialect === void 0 ? [] : [`dialect: ${tableDialect}`]
+	];
 	return `const ${definitionsName} = {
 ${columns.map((value) => indent(value ?? "", 2)).join("\n")}
 }
@@ -93,12 +108,7 @@ export const ${table.name}: ${tableTypeName} = _qubu.table(
   ${literal(table.snapshot.physicalName)},
   ${definitionsName},
   _current => ({
-    constraints: {
-${constraints.map((value) => indent(value ?? "", 6)).join("\n")}
-    },
-    indexes: {
-${indexes.map((value) => indent(value ?? "", 6)).join("\n")}
-    },
+${tableMetadata.map((value) => indent(value, 4)).join(",\n")}
   })
 )`;
 }
@@ -117,7 +127,7 @@ function printConstraintType(table, constraint, columnsName, diagnostics) {
 	if (snapshot.kind === "foreign-key") return `readonly ${literal(constraint.name)}: _qubu.ForeignKeyConstraint<${columns}>`;
 	if (snapshot.kind === "unique-constraint") return `readonly ${literal(constraint.name)}: _qubu.UniqueConstraint<
   ${columns},
-  ${literal(snapshot.nulls)}
+  ${literal(snapshot.nulls ?? "distinct")}
 >`;
 	return `readonly ${literal(constraint.name)}: _qubu.KeyConstraint<
   ${literal(snapshot.kind)},
@@ -155,9 +165,9 @@ ${properties.map((property) => `  ${property}`).join("\n")}
 }`;
 }
 function printIndexTermType(table, term, columnsName, path, diagnostics) {
-	if (term.kind !== "order") return printIndexTermExpressionType(table, term, columnsName, path, diagnostics);
-	const expression = printIndexTermExpressionType(table, term.expression, columnsName, [...path, "expression"], diagnostics);
-	return expression === void 0 ? void 0 : `_qubu.OrderTerm<unknown, ${expression}>`;
+	const expression = printIndexTermExpressionType(table, term, columnsName, path, diagnostics);
+	if (expression === void 0) return;
+	return term.direction === void 0 && term.nulls === void 0 ? expression : `_qubu.OrderTerm<unknown, ${expression}>`;
 }
 function printIndexTermExpressionType(table, expression, columnsName, path, diagnostics) {
 	if (expression.kind === "expression") return "_qubu.AnyExpression";
@@ -198,6 +208,11 @@ function printColumn(schema, table, column, diagnostics) {
 		return;
 	}
 	const options = [`nullable: ${snapshot.nullable ? "true" : "false"}`, `sqlName: ${literal(snapshot.physicalName)}`];
+	if (snapshot.dialect !== void 0) {
+		const extension = printExtension(snapshot.dialect, schema, [...path, "dialect"], diagnostics);
+		if (extension === void 0) return;
+		options.push(`dialect: ${extension}`);
+	}
 	if (snapshot.default !== void 0) {
 		if (snapshot.default.kind === "external") options.push("default: _qubu.externalDefault()");
 		else if (snapshot.default.kind === "literal") {
@@ -233,7 +248,16 @@ function printColumn(schema, table, column, diagnostics) {
 			"dialect"
 		], diagnostics) : void 0;
 		if (snapshot.identity.dialect !== void 0 && extension === void 0) return;
-		options.push(extension === void 0 ? `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)})` : `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)}, { dialect: ${extension} })`);
+		const identityProperties = [];
+		const identityOptions = printValueFactRecord(snapshot.identity.options, schema, [
+			...path,
+			"identity",
+			"options"
+		], diagnostics);
+		if (identityOptions === void 0) return;
+		if (identityOptions !== "{}") identityProperties.push(`options: ${identityOptions}`);
+		if (extension !== void 0) identityProperties.push(`dialect: ${extension}`);
+		options.push(identityProperties.length === 0 ? `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)})` : `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)}, { ${identityProperties.join(", ")} })`);
 	}
 	if (snapshot.onUpdate !== void 0) {
 		const expression = printExpression(snapshot.onUpdate, schema, [...path, "onUpdate"], diagnostics);
@@ -264,7 +288,7 @@ function printConstraint(schema, table, constraint, diagnostics) {
 		"constraints",
 		snapshot.id
 	];
-	const options = printConstraintOptions(snapshot, schema, path, diagnostics);
+	const options = printConstraintOptions(snapshot, schema, table, path, diagnostics);
 	if (options === void 0) return;
 	let expression;
 	if (snapshot.kind === "check") {
@@ -273,9 +297,9 @@ function printConstraint(schema, table, constraint, diagnostics) {
 		expression = `_qubu.catalogCheck(${sql}, ${options})`;
 	} else if (snapshot.kind === "foreign-key") {
 		const local = printColumns(table, snapshot.columns, path, diagnostics);
-		const targetTable = schema.tablesBySnapshotId.get(snapshot.target.table);
+		const targetTable = schema.tablesBySnapshotId.get(snapshot.target.table.id);
 		if (targetTable === void 0) {
-			diagnostics.push(sourceError(`Foreign-key target table "${snapshot.target.table}" was not resolved`, [
+			diagnostics.push(sourceError(`Foreign-key target table "${snapshot.target.table.id}" was not resolved`, [
 				...path,
 				"target",
 				"table"
@@ -296,9 +320,9 @@ function printConstraint(schema, table, constraint, diagnostics) {
 	}
 	return `${literal(constraint.name)}: ${expression},`;
 }
-function printConstraintOptions(constraint, schema, path, diagnostics) {
+function printConstraintOptions(constraint, schema, table, path, diagnostics) {
 	const properties = [`physicalName: ${literal(constraint.physicalName)}`];
-	if (constraint.kind === "unique-constraint") properties.push(`nulls: ${literal(constraint.nulls)}`);
+	if (constraint.kind === "unique-constraint") properties.push(`nulls: ${literal(constraint.nulls ?? "distinct")}`);
 	if (constraint.kind === "foreign-key") {
 		if (constraint.onUpdate !== void 0) properties.push(`onUpdate: ${literal(constraint.onUpdate)}`);
 		if (constraint.onDelete !== void 0) properties.push(`onDelete: ${literal(constraint.onDelete)}`);
@@ -306,6 +330,15 @@ function printConstraintOptions(constraint, schema, path, diagnostics) {
 	}
 	if (constraint.deferrable !== void 0) properties.push(`deferrable: ${constraint.deferrable ? "true" : "false"}`);
 	if (constraint.initially !== void 0) properties.push(`initially: ${literal(constraint.initially)}`);
+	if (constraint.validated !== void 0) properties.push(`validated: ${constraint.validated ? "true" : "false"}`);
+	if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") && constraint.backingIndex !== void 0) {
+		const backingIndex = table.indexes.find((index) => index.snapshot.id === constraint.backingIndex?.id);
+		if (backingIndex === void 0) {
+			diagnostics.push(sourceError(`Backing index "${constraint.backingIndex.id}" was not resolved`, [...path, "backingIndex"]));
+			return;
+		}
+		properties.push(`backingIndex: ${literal(backingIndex.name)}`);
+	}
 	if (constraint.dialect !== void 0) {
 		const extension = printExtension(constraint.dialect, schema, [...path, "dialect"], diagnostics);
 		if (extension === void 0) return;
@@ -328,6 +361,43 @@ function printIndex(schema, table, index, diagnostics) {
 	], diagnostics));
 	if (terms.some((term) => term === void 0)) return;
 	const options = [`physicalName: ${literal(index.snapshot.physicalName)}`, `unique: ${index.snapshot.unique ? "true" : "false"}`];
+	if (index.snapshot.method !== void 0) options.push(`method: ${literal(index.snapshot.method)}`);
+	if (index.snapshot.backingConstraint !== void 0) {
+		const backingConstraint = table.constraints.find((constraint) => constraint.snapshot.id === index.snapshot.backingConstraint?.id);
+		if (backingConstraint === void 0) {
+			diagnostics.push(sourceError(`Backing constraint "${index.snapshot.backingConstraint.id}" was not resolved`, [...path, "backingConstraint"]));
+			return;
+		}
+		options.push(`backingConstraint: ${literal(backingConstraint.name)}`);
+	}
+	const termOptions = index.snapshot.terms.map((term, termIndex) => {
+		const termPrefixLength = term.kind === "column" ? term.prefixLength : void 0;
+		if (termPrefixLength === void 0 && term.operatorClass === void 0) return "undefined";
+		const properties = [];
+		if (termPrefixLength !== void 0) {
+			if (term.kind !== "column") {
+				diagnostics.push(sourceError("Index prefix lengths require column terms", [
+					...path,
+					"terms",
+					termIndex,
+					"prefixLength"
+				]));
+				return;
+			}
+			const prefixLength = printValueFact(termPrefixLength, schema, [
+				...path,
+				"terms",
+				termIndex,
+				"prefixLength"
+			], diagnostics);
+			if (prefixLength === void 0) return;
+			properties.push(`prefixLength: ${prefixLength}`);
+		}
+		if (term.operatorClass !== void 0) properties.push(`operatorClass: ${literal(term.operatorClass)}`);
+		return `{ ${properties.join(", ")} }`;
+	});
+	if (termOptions.some((value) => value === void 0)) return;
+	if (termOptions.some((value) => value !== "undefined")) options.push(`termOptions: [${termOptions.join(", ")}]`);
 	if (index.snapshot.predicate !== void 0) {
 		const predicate = catalogExpressionData(index.snapshot.predicate, schema, [...path, "predicate"], diagnostics);
 		if (predicate === void 0) return;
@@ -349,10 +419,9 @@ function printIndex(schema, table, index, diagnostics) {
 ),`;
 }
 function printIndexTerm(schema, table, term, path, diagnostics) {
-	if (term.kind !== "order") return printIndexTermExpression(schema, table, term, path, diagnostics);
-	const expression = printIndexTermExpression(schema, table, term.expression, [...path, "expression"], diagnostics);
+	const expression = printIndexTermExpression(schema, table, term, path, diagnostics);
 	if (expression === void 0) return;
-	return `_qubu.order(${expression}, ${term.direction === void 0 ? "undefined" : literal(term.direction)}, ${term.nulls === void 0 ? "undefined" : literal(term.nulls)})`;
+	return term.direction === void 0 && term.nulls === void 0 ? expression : `_qubu.order(${expression}, ${term.direction === void 0 ? "undefined" : literal(term.direction)}, ${term.nulls === void 0 ? "undefined" : literal(term.nulls)})`;
 }
 function printIndexTermExpression(schema, table, expression, path, diagnostics) {
 	if (expression.kind === "expression") return printExpression(expression.expression, schema, [...path, "expression"], diagnostics);
@@ -399,6 +468,23 @@ function printExtension(extension, schema, path, diagnostics) {
 	const entries = Object.keys(data).sort().map((key) => `[${literal(key)}]: ${printJsonValue(data[key])}`);
 	return `{ dialect: ${literal(extension.dialect)}${entries.length === 0 ? "" : `, ${entries.join(", ")}`} }`;
 }
+function printValueFactRecord(record, schema, path, diagnostics) {
+	const entries = [];
+	for (const key of Object.keys(record).sort()) {
+		const value = record[key];
+		const printed = value.kind === "literal" ? printSnapshotLiteral(value.value, [...path, key], diagnostics) : printExpression(value.expression, schema, [
+			...path,
+			key,
+			"expression"
+		], diagnostics);
+		if (printed === void 0) return;
+		entries.push(`[${literal(key)}]: ${printed}`);
+	}
+	return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+}
+function printValueFact(value, schema, path, diagnostics) {
+	return value.kind === "literal" ? printSnapshotLiteral(value.value, path, diagnostics) : printExpression(value.expression, schema, [...path, "expression"], diagnostics);
+}
 function printSnapshotLiteral(value, path, diagnostics) {
 	switch (value.kind) {
 		case "null": return "null";
@@ -408,7 +494,7 @@ function printSnapshotLiteral(value, path, diagnostics) {
 		case "number": {
 			const number = Number(value.value);
 			if (!Number.isFinite(number)) {
-				diagnostics.push(sourceError("Default number literals must be finite", [...path, "default"]));
+				diagnostics.push(sourceError("Number literals must be finite", path));
 				return;
 			}
 			return Object.is(number, -0) ? "0" : String(number);
@@ -550,7 +636,7 @@ const reservedBindings = /* @__PURE__ */ new Set([
 	"with",
 	"yield"
 ]);
-const excludedFamilies = [
+const unsupportedSnapshotFamilies = [
 	["views", "views"],
 	["sequences", "sequences"],
 	["enums", "enums"],
@@ -560,7 +646,7 @@ const excludedFamilies = [
 	["routines", "routines"],
 	["partitions", "partitions"],
 	["policies", "policies"],
-	["extensionObjects", "extension objects"],
+	["extensions", "extensions"],
 	["deferredObjects", "deferred objects"],
 	["opaqueObjects", "opaque objects"],
 	["comments", "comments"],
@@ -578,7 +664,7 @@ const excludedFamilies = [
 *   expressions use dialect-tagged schema data, checks use `catalogCheck()`, and foreign keys use
 *   lazy `catalogForeignKey()` targets. Foreign keys must have equal local and target arity and
 *   target an exact primary key, strict unique key, or candidate index. Nullable database UNIQUE
-*   constraints do not provide that candidate-key proof and fail generation. Application output,
+*   constraints and indexes with lossy candidate-key facts do not provide that proof. Application output,
 *   insert, and update types default independently to `unknown`. The generator may attach a
 *   conservative SQL semantic domain, and {@link SchemaCodegenOptions.mapColumn} can override either
 *   type axis with a fixed token. Naming callbacks can replace suggested camelCase IDs, but they
@@ -599,8 +685,8 @@ function generateSchemaSource(input, options = {}) {
 			diagnostics.push(errorDiagnostic("invalid-input", "Code generation requires an introspection result", []));
 			return failure(diagnostics);
 		}
+		if (!validateOptions(options, diagnostics)) return failure(diagnostics);
 		diagnostics.push(...input.diagnostics);
-		appendExcludedFamilyDiagnostics(input.catalog, diagnostics);
 		if (!input.ok) {
 			diagnostics.push(errorDiagnostic("invalid-input", "Code generation requires a successful introspection result", []));
 			return failure(diagnostics);
@@ -613,6 +699,8 @@ function generateSchemaSource(input, options = {}) {
 			return failure(diagnostics);
 		}
 		const snapshot = decoded.value;
+		appendUnsupportedSnapshotFamilyDiagnostics(snapshot, diagnostics);
+		if (hasErrors(diagnostics)) return failure(diagnostics);
 		validateInputEnvelope(input.catalog, snapshot, diagnostics);
 		validatePhysicalFacts(input.catalog, snapshot, diagnostics);
 		validateSchemaProofs(snapshot, diagnostics);
@@ -641,7 +729,7 @@ function validateInputEnvelope(catalog, snapshot, diagnostics) {
 		"dialect",
 		"version"
 	]));
-	if (snapshot.namespace !== catalog.namespace.name) diagnostics.push(errorDiagnostic("unsupported-snapshot", "Snapshot and catalog namespaces do not match", ["snapshot", "namespace"], void 0, [[
+	if (snapshot.namespace.name !== catalog.namespace.name) diagnostics.push(errorDiagnostic("unsupported-snapshot", "Snapshot and catalog namespaces do not match", ["snapshot", "namespace"], void 0, [[
 		"catalog",
 		"namespace",
 		"name"
@@ -679,8 +767,7 @@ function validateSchemaProofs(snapshot, diagnostics) {
 		}
 		for (const index of table.indexes) {
 			if (!index.candidateKey) continue;
-			const candidateColumns = candidateIndexColumns(index);
-			if (candidateColumns === void 0 || candidateColumns.some((column) => columns.get(column)?.nullable !== false)) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Index "${index.physicalName}" is marked as a candidate key without an exact non-null column key`, [
+			if (!hasCandidateKeyShape(index, columns)) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Index "${index.physicalName}" is marked as a candidate key without an exact non-null column key`, [
 				...path,
 				"indexes",
 				index.id,
@@ -702,7 +789,7 @@ function validateSchemaProofs(snapshot, diagnostics) {
 				]));
 				continue;
 			}
-			const target = tables.get(constraint.target.table);
+			const target = tables.get(constraint.target.table.id);
 			if (target === void 0) continue;
 			if (!hasCandidateKey(target, constraint.target.columns)) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Foreign key "${constraint.physicalName}" does not target an exact primary key, strict unique key, or candidate index`, [
 				...constraintPath,
@@ -716,21 +803,11 @@ function hasCandidateKey(table, targetColumns) {
 	const columns = new Map(table.columns.map((column) => [column.id, column]));
 	if (table.constraints.some((constraint) => (constraint.kind === "primary-key" || constraint.kind === "unique") && constraint.columns.every((column) => columns.get(column)?.nullable === false) && sameColumns(constraint.columns, targetColumns))) return true;
 	return table.indexes.some((index) => {
-		if (!index.candidateKey) return false;
-		const candidateColumns = candidateIndexColumns(index);
-		return candidateColumns !== void 0 && candidateColumns.every((column) => columns.get(column)?.nullable === false) && sameColumns(candidateColumns, targetColumns);
+		if (!isCandidateKeyIndex(index, columns)) return false;
+		const candidateColumns = candidateKeyIndexColumns(index);
+		return candidateColumns !== void 0 && sameColumns(candidateColumns, targetColumns);
 	});
 }
-function candidateIndexColumns(index) {
-	if (!index.candidateKey || !index.unique || index.predicate !== void 0) return;
-	const columns = [];
-	for (const term of index.terms) {
-		const expression = term.kind === "order" ? term.expression : term;
-		if (expression.kind !== "column") return;
-		columns.push(expression.column);
-	}
-	return columns.length > 0 ? columns : void 0;
-}
 function sameColumns(left, right) {
 	return left.length === right.length && left.every((column, index) => column === right[index]);
 }
@@ -792,7 +869,7 @@ function resolveTable(snapshot, catalogTable, tableName, catalog, options, diagn
 	], diagnostics);
 	const columns = [];
 	const columnNames = /* @__PURE__ */ new Map();
-	for (const column of [...snapshot.columns].sort(comparePhysicalName)) {
+	for (const column of [...snapshot.columns].sort(comparePhysicalPosition)) {
 		const path = [
 			"snapshot",
 			"tables",
@@ -855,7 +932,7 @@ function resolveTable(snapshot, catalogTable, tableName, catalog, options, diagn
 	const constraints = resolveObjects(snapshot.constraints, "constraint", snapshot, tableName, options, diagnostics);
 	const indexes = resolveObjects(snapshot.indexes, "index", snapshot, tableName, options, diagnostics);
 	if (hasErrors(diagnostics)) return;
-	const orderedColumns = columns.sort(compareName);
+	const orderedColumns = columns;
 	return {
 		name: tableName,
 		snapshot,
@@ -943,9 +1020,9 @@ function resolveColumnMapping(catalog, tablePhysicalName, tableName, column, col
 }
 function validateResolvedDomains(schema, diagnostics) {
 	for (const table of schema.tables) for (const index of table.indexes) for (const term of index.snapshot.terms) {
-		const ordered = term.kind === "order" ? term : void 0;
-		if (ordered?.expression.kind !== "column") continue;
-		const column = table.columnsBySnapshotId.get(ordered.expression.column);
+		const ordered = term.direction !== void 0 || term.nulls !== void 0 ? term : void 0;
+		if (ordered?.kind !== "column") continue;
+		const column = table.columnsBySnapshotId.get(ordered.column);
 		if (column === void 0 || orderableDomains.has(column.sqlDomain)) continue;
 		if (column.explicitSqlDomain) diagnostics.push(errorDiagnostic("invalid-option", `SQL domain "${column.sqlDomain}" cannot represent an ordered index term`, [
 			"snapshot",
@@ -959,7 +1036,7 @@ function validateResolvedDomains(schema, diagnostics) {
 	}
 	for (const table of schema.tables) for (const constraint of table.constraints) {
 		if (constraint.snapshot.kind !== "foreign-key") continue;
-		const targetTable = schema.tablesBySnapshotId.get(constraint.snapshot.target.table);
+		const targetTable = schema.tablesBySnapshotId.get(constraint.snapshot.target.table.id);
 		if (targetTable === void 0) continue;
 		for (const [index, localId] of constraint.snapshot.columns.entries()) {
 			const targetId = constraint.snapshot.target.columns[index];
@@ -1065,47 +1142,41 @@ function toPhysicalFacts(snapshot) {
 	const columnNames = new Map(snapshot.tables.map((table) => [table.id, new Map(table.columns.map((column) => [column.id, column.physicalName]))]));
 	return {
 		dialect: snapshot.dialect,
-		namespace: snapshot.namespace ?? null,
+		namespace: snapshot.namespace.name,
 		tables: [...snapshot.tables].sort(comparePhysicalName).map((table) => ({
 			physicalName: table.physicalName,
-			columns: [...table.columns].sort(comparePhysicalName).map((column) => ({
-				...column,
-				id: column.physicalName
-			})),
+			...table.dialect === void 0 ? {} : { dialect: stripEvidence(table.dialect) },
+			columns: [...table.columns].sort(comparePhysicalPosition).map((column) => stripObjectIdentity(column)),
 			constraints: [...table.constraints].sort(comparePhysicalName).map((constraint) => physicalConstraint(constraint, table, tableById, columnNames)),
 			indexes: [...table.indexes].sort(comparePhysicalName).map((index) => physicalIndex(index, table, columnNames))
 		}))
 	};
 }
 function physicalConstraint(constraint, table, tables, columns) {
-	if (constraint.kind === "check") return {
-		...constraint,
-		id: constraint.physicalName
-	};
+	if (constraint.kind === "check") return stripObjectIdentity(constraint);
 	const localColumns = constraint.columns.map((id) => columns.get(table.id)?.get(id) ?? `missing:${id}`);
 	if (constraint.kind !== "foreign-key") return {
-		...constraint,
-		id: constraint.physicalName,
-		columns: localColumns
+		...stripObjectIdentity(constraint),
+		columns: localColumns,
+		...constraint.backingIndex === void 0 ? {} : { backingIndex: physicalReference(constraint.backingIndex, table.indexes) }
 	};
-	const targetTable = tables.get(constraint.target.table);
+	const targetTable = tables.get(constraint.target.table.id);
 	return {
-		...constraint,
-		id: constraint.physicalName,
+		...stripObjectIdentity(constraint),
 		columns: localColumns,
 		target: {
-			table: targetTable?.physicalName ?? `missing:${constraint.target.table}`,
-			columns: constraint.target.columns.map((id) => columns.get(constraint.target.table)?.get(id) ?? `missing:${id}`)
+			table: targetTable?.physicalName ?? `missing:${constraint.target.table.id}`,
+			columns: constraint.target.columns.map((id) => columns.get(constraint.target.table.id)?.get(id) ?? `missing:${id}`)
 		}
 	};
 }
 function physicalIndex(index, table, columns) {
 	const names = columns.get(table.id);
 	return {
-		...index,
-		id: index.physicalName,
-		terms: index.terms.map((term) => physicalIndexTerm(term, names)),
-		...index.includedColumns === void 0 ? {} : { includedColumns: index.includedColumns.map((id) => names?.get(id) ?? `missing:${id}`) }
+		...stripObjectIdentity(index),
+		terms: [...index.terms].sort((left, right) => left.position - right.position).map((term) => physicalIndexTerm(term, names)),
+		...index.includedColumns === void 0 ? {} : { includedColumns: index.includedColumns.map((id) => names?.get(id) ?? `missing:${id}`) },
+		...index.backingConstraint === void 0 ? {} : { backingConstraint: physicalReference(index.backingConstraint, table.constraints) }
 	};
 }
 function physicalIndexTerm(term, columns) {
@@ -1114,28 +1185,33 @@ function physicalIndexTerm(term, columns) {
 		column: columns?.get(term.column) ?? `missing:${term.column}`
 	};
 	if (term.kind === "expression") return term;
-	return {
-		...term,
-		expression: term.expression.kind === "column" ? {
-			...term.expression,
-			column: columns?.get(term.expression.column) ?? `missing:${term.expression.column}`
-		} : term.expression
-	};
+	return term;
 }
-function appendExcludedFamilyDiagnostics(catalog, diagnostics) {
-	if (catalog === void 0) return;
-	for (const [property, label] of excludedFamilies) {
-		const values = catalog[property];
-		if (values === void 0 || values.length === 0) continue;
-		diagnostics.push({
-			severity: "warning",
-			code: "excluded-object-family",
-			message: `Snapshot v1 source generation excludes ${values.length} ${label}`,
-			path: Object.freeze(["catalog", property]),
-			remediation: "Use the complete normalized catalog or Snapshot v2 for this object family."
-		});
+function appendUnsupportedSnapshotFamilyDiagnostics(snapshot, diagnostics) {
+	for (const [property, label] of unsupportedSnapshotFamilies) {
+		const values = snapshot[property];
+		if (values.length === 0) continue;
+		diagnostics.push(errorDiagnostic("excluded-object-family", `Snapshot v1 source generation cannot represent ${values.length} ${label}`, ["snapshot", property], "Generate source from a snapshot containing tables only."));
 	}
 }
+function stripObjectIdentity(value) {
+	const stripped = stripEvidence(value);
+	if (typeof stripped !== "object" || stripped === null || Array.isArray(stripped)) return {};
+	const { id: _id, ...facts } = stripped;
+	return facts;
+}
+function stripEvidence(value) {
+	if (Array.isArray(value)) return value.map(stripEvidence);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([key, item]) => key === "provenance" || key === "physicalReference" ? [] : [[key, stripEvidence(item)]]));
+}
+function physicalReference(reference, objects) {
+	const target = objects.find((object) => object.id === reference.id);
+	return {
+		...reference,
+		id: target?.physicalName ?? `missing:${reference.id}`
+	};
+}
 function groupUnique(values, keyOf, path, diagnostics) {
 	const result = /* @__PURE__ */ new Map();
 	for (const [index, value] of values.entries()) {
@@ -1182,12 +1258,26 @@ function hasErrors(diagnostics) {
 function comparePhysicalName(left, right) {
 	return left.physicalName < right.physicalName ? -1 : left.physicalName > right.physicalName ? 1 : 0;
 }
+function comparePhysicalPosition(left, right) {
+	return left.ordinalPosition - right.ordinalPosition || comparePhysicalName(left, right);
+}
 function compareName(left, right) {
 	return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
 }
 function isOptions(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function validateOptions(options, diagnostics) {
+	let valid = true;
+	for (const key of ["naming", "mapColumn"]) {
+		const callback = options[key];
+		if (callback !== void 0 && typeof callback !== "function") {
+			diagnostics.push(errorDiagnostic("invalid-option", `${key} must be a function`, ["options", key]));
+			valid = false;
+		}
+	}
+	return valid;
+}
 function isIntrospectionResult(value) {
 	return typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean" && "lossy" in value && typeof value.lossy === "boolean" && "diagnostics" in value && Array.isArray(value.diagnostics);
 }

package/dist/column-Cyc2CMnG.mjs

@@ -0,0 +1,116 @@
+import { U as resultValue, f as resolveColumnBehavior } from "./column-DDRvD7SF.mjs";
+//#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),
+		sqlType: type === "numeric" ? "decimal" : type
+	});
+}
+function column(options) {
+	return Object.freeze({
+		definitionKind: "column",
+		nullable: options?.nullable === true,
+		...resolveColumnBehavior(options ?? {}),
+		sqlName: options?.sqlName,
+		...options?.sqlType === void 0 ? {} : { sqlType: options.sqlType },
+		storage: options?.storage ? Object.freeze({ ...options.storage }) : void 0,
+		dialect: options?.dialect,
+		...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 sqlType = columnSqlType(definition);
+	return resultValue(sqlType === "boolean" || sqlType === "date" || sqlType === "timestamp" || sqlType === "json" || sqlType === "bigint" ? sqlType : void 0, definition.resultDecoder, sqlType);
+}
+/** Resolve a column's explicit runtime semantic SQL domain for driver-facing metadata. */
+function columnSqlType(definition) {
+	return definition.sqlType;
+}
+/** 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 { timestamp as _, columnResultValue as a, encodeColumnParameter as c, nativeColumn as d, nativeStorage as f, text as g, portableStorage as h, column as i, integer as l, numeric as m, binary as n, columnSqlType as o, nullable as p, boolean as r, date as s, bigint as t, json as u, uuid as v };