@prisma-next/sql-contract-ts 0.3.0-dev.135 → 0.3.0-dev.146

package/dist/contract-builder.mjs

@@ -1,9 +1,274 @@
-import { ContractBuilder, ModelBuilder, TableBuilder, createTable } from "@prisma-next/contract-authoring";
-import { instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/contract/framework-components";
-import { ifDefined } from "@prisma-next/utils/defined";
+import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
+import { coreHash } from "@prisma-next/contract/types";
 import { applyFkDefaults } from "@prisma-next/sql-contract/types";
 import { validateStorageSemantics } from "@prisma-next/sql-contract/validators";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 
+//#region src/build-contract.ts
+function encodeDefaultLiteralValue(value, codecId, codecLookup) {
+	const codec = codecLookup?.get(codecId);
+	if (codec) return codec.encodeJson(value);
+	return value;
+}
+function encodeColumnDefault(defaultInput, codecId, codecLookup) {
+	if (defaultInput.kind === "function") return {
+		kind: "function",
+		expression: defaultInput.expression
+	};
+	return {
+		kind: "literal",
+		value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup)
+	};
+}
+function assertStorageSemantics(storage) {
+	const semanticErrors = validateStorageSemantics(storage);
+	if (semanticErrors.length > 0) throw new Error(`Contract semantic validation failed: ${semanticErrors.join("; ")}`);
+}
+function assertKnownTargetModel(modelsByName, sourceModelName, targetModelName, context) {
+	const targetModel = modelsByName.get(targetModelName);
+	if (!targetModel) throw new Error(`${context} on model "${sourceModelName}" references unknown model "${targetModelName}"`);
+	return targetModel;
+}
+function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
+	if (targetModel.tableName !== referencedTableName) throw new Error(`${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`);
+}
+function isValueObjectField(field$1) {
+	return "valueObjectName" in field$1;
+}
+const JSONB_CODEC_ID = "pg/jsonb@1";
+const JSONB_NATIVE_TYPE = "jsonb";
+function buildStorageColumn(field$1, codecLookup) {
+	if (isValueObjectField(field$1)) {
+		const encodedDefault$1 = field$1.default !== void 0 ? encodeColumnDefault(field$1.default, JSONB_CODEC_ID, codecLookup) : void 0;
+		return {
+			nativeType: JSONB_NATIVE_TYPE,
+			codecId: JSONB_CODEC_ID,
+			nullable: field$1.nullable,
+			...ifDefined("default", encodedDefault$1)
+		};
+	}
+	if (field$1.many) return {
+		nativeType: JSONB_NATIVE_TYPE,
+		codecId: JSONB_CODEC_ID,
+		nullable: field$1.nullable
+	};
+	const codecId = field$1.descriptor.codecId;
+	const encodedDefault = field$1.default !== void 0 ? encodeColumnDefault(field$1.default, codecId, codecLookup) : void 0;
+	return {
+		nativeType: field$1.descriptor.nativeType,
+		codecId,
+		nullable: field$1.nullable,
+		...ifDefined("typeParams", field$1.descriptor.typeParams),
+		...ifDefined("default", encodedDefault),
+		...ifDefined("typeRef", field$1.descriptor.typeRef)
+	};
+}
+function buildDomainField(field$1, column) {
+	if (isValueObjectField(field$1)) return {
+		type: {
+			kind: "valueObject",
+			name: field$1.valueObjectName
+		},
+		nullable: field$1.nullable,
+		...field$1.many ? { many: true } : {}
+	};
+	return {
+		type: {
+			kind: "scalar",
+			codecId: column.codecId,
+			...ifDefined("typeParams", column.typeParams)
+		},
+		nullable: column.nullable,
+		...field$1.many ? { many: true } : {}
+	};
+}
+function buildSqlContractFromDefinition(definition, codecLookup) {
+	const target = definition.target.targetId;
+	const targetFamily = "sql";
+	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
+	const storageTables = {};
+	const executionDefaults = [];
+	const models = {};
+	const roots = {};
+	for (const semanticModel of definition.models) {
+		const tableName = semanticModel.tableName;
+		roots[tableName] = semanticModel.modelName;
+		const columns = {};
+		const fieldToColumn = {};
+		const domainFields = {};
+		const domainFieldRefs = {};
+		for (const field$1 of semanticModel.fields) {
+			if (field$1.executionDefault) {
+				if (field$1.default !== void 0) throw new Error(`Field "${semanticModel.modelName}.${field$1.fieldName}" cannot define both default and executionDefault.`);
+				if (field$1.nullable) throw new Error(`Field "${semanticModel.modelName}.${field$1.fieldName}" cannot be nullable when executionDefault is present.`);
+			}
+			const column = buildStorageColumn(field$1, codecLookup);
+			columns[field$1.columnName] = column;
+			fieldToColumn[field$1.fieldName] = field$1.columnName;
+			domainFields[field$1.fieldName] = buildDomainField(field$1, column);
+			if (isValueObjectField(field$1)) domainFieldRefs[field$1.fieldName] = {
+				kind: "valueObject",
+				name: field$1.valueObjectName,
+				...field$1.many ? { many: true } : {}
+			};
+			else if (field$1.many) domainFieldRefs[field$1.fieldName] = {
+				kind: "scalar",
+				many: true
+			};
+			if ("executionDefault" in field$1 && field$1.executionDefault) executionDefaults.push({
+				ref: {
+					table: tableName,
+					column: field$1.columnName
+				},
+				onCreate: field$1.executionDefault
+			});
+		}
+		if (semanticModel.id) {
+			const fieldsByColumnName = new Map(semanticModel.fields.map((field$1) => [field$1.columnName, field$1]));
+			for (const columnName of semanticModel.id.columns) {
+				const field$1 = fieldsByColumnName.get(columnName);
+				if (field$1?.nullable) throw new Error(`Model "${semanticModel.modelName}" uses nullable field "${field$1.fieldName}" in its identity.`);
+			}
+		}
+		const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
+			const targetModel = assertKnownTargetModel(modelsByName, semanticModel.modelName, fk.references.model, "Foreign key");
+			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
+			return {
+				columns: fk.columns,
+				references: {
+					table: fk.references.table,
+					columns: fk.references.columns
+				},
+				...applyFkDefaults({
+					...ifDefined("constraint", fk.constraint),
+					...ifDefined("index", fk.index)
+				}, definition.foreignKeyDefaults),
+				...ifDefined("name", fk.name),
+				...ifDefined("onDelete", fk.onDelete),
+				...ifDefined("onUpdate", fk.onUpdate)
+			};
+		});
+		storageTables[tableName] = {
+			columns,
+			uniques: (semanticModel.uniques ?? []).map((u) => ({
+				columns: u.columns,
+				...ifDefined("name", u.name)
+			})),
+			indexes: (semanticModel.indexes ?? []).map((i) => ({
+				columns: i.columns,
+				...ifDefined("name", i.name),
+				...ifDefined("using", i.using),
+				...ifDefined("config", i.config)
+			})),
+			foreignKeys,
+			...semanticModel.id ? { primaryKey: {
+				columns: semanticModel.id.columns,
+				...ifDefined("name", semanticModel.id.name)
+			} } : {}
+		};
+		const storageFields = {};
+		for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
+		const columnToField = new Map(Object.entries(fieldToColumn).map(([field$1, col]) => [col, field$1]));
+		const modelRelations = {};
+		for (const relation of semanticModel.relations ?? []) {
+			const targetModel = assertKnownTargetModel(modelsByName, semanticModel.modelName, relation.toModel, "Relation");
+			assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, "Relation");
+			if (relation.cardinality === "N:M" && !relation.through) throw new Error(`Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`);
+			const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
+			modelRelations[relation.fieldName] = {
+				to: relation.toModel,
+				cardinality: relation.cardinality,
+				on: {
+					localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+					targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
+				},
+				...relation.through ? { through: {
+					table: relation.through.table,
+					parentCols: relation.through.parentColumns,
+					childCols: relation.through.childColumns
+				} } : void 0
+			};
+		}
+		models[semanticModel.modelName] = {
+			storage: {
+				table: tableName,
+				fields: storageFields
+			},
+			fields: domainFields,
+			relations: modelRelations
+		};
+	}
+	const storageWithoutHash = {
+		tables: storageTables,
+		types: definition.storageTypes ?? {}
+	};
+	const storageHash = definition.storageHash ? coreHash(definition.storageHash) : computeStorageHash({
+		target,
+		targetFamily,
+		storage: storageWithoutHash
+	});
+	const storage = {
+		...storageWithoutHash,
+		storageHash
+	};
+	const executionSection = executionDefaults.length > 0 ? { mutations: { defaults: executionDefaults.sort((a, b) => {
+		const tableCompare = a.ref.table.localeCompare(b.ref.table);
+		if (tableCompare !== 0) return tableCompare;
+		return a.ref.column.localeCompare(b.ref.column);
+	}) } } : void 0;
+	const extensionNamespaces = definition.extensionPacks ? Object.values(definition.extensionPacks).map((pack) => pack.id) : void 0;
+	const extensionPacks = { ...definition.extensionPacks || {} };
+	if (extensionNamespaces) {
+		for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensionPacks, namespace)) extensionPacks[namespace] = {};
+	}
+	const capabilities = definition.capabilities || {};
+	const profileHash = computeProfileHash({
+		target,
+		targetFamily,
+		capabilities
+	});
+	const executionWithHash = executionSection ? {
+		...executionSection,
+		executionHash: computeExecutionHash({
+			target,
+			targetFamily,
+			execution: executionSection
+		})
+	} : void 0;
+	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, isValueObjectField(f) ? {
+		type: {
+			kind: "valueObject",
+			name: f.valueObjectName
+		},
+		nullable: f.nullable,
+		...f.many ? { many: true } : {}
+	} : {
+		type: {
+			kind: "scalar",
+			codecId: f.descriptor.codecId,
+			...ifDefined("typeParams", f.descriptor.typeParams)
+		},
+		nullable: f.nullable
+	}])) }])) : void 0;
+	const contract = {
+		target,
+		targetFamily,
+		models,
+		roots,
+		storage,
+		...executionWithHash ? { execution: executionWithHash } : {},
+		...ifDefined("valueObjects", valueObjects),
+		extensionPacks,
+		capabilities,
+		profileHash,
+		meta: {}
+	};
+	assertStorageSemantics(contract.storage);
+	return contract;
+}
+
+//#endregion
 //#region src/authoring-helper-runtime.ts
 function isNamedConstraintOptionsLike(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -74,7 +339,7 @@ function createFieldHelpersFromNamespace(namespace, createLeafHelper, path = [])
 }
 
 //#endregion
-//#region src/staged-contract-dsl.ts
+//#region src/contract-dsl.ts
 function isColumnDefault(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const kind = value.kind;
@@ -310,7 +575,7 @@ function createColumnRefs(fields) {
 function findDuplicateRelationName(existingRelations, nextRelations) {
 	return Object.keys(nextRelations).find((relationName) => Object.hasOwn(existingRelations, relationName));
 }
-var StagedModelBuilder = class StagedModelBuilder {
+var ContractModelBuilder = class ContractModelBuilder {
 	refs;
 	constructor(stageOne, attributesFactory, sqlFactory) {
 		this.stageOne = stageOne;
@@ -331,7 +596,7 @@ var StagedModelBuilder = class StagedModelBuilder {
 	relations(relations) {
 		const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
 		if (duplicateRelationName) throw new Error(`Model "${this.stageOne.modelName ?? "<anonymous>"}" already defines relation "${duplicateRelationName}".`);
-		return new StagedModelBuilder({
+		return new ContractModelBuilder({
 			...this.stageOne,
 			relations: {
 				...this.stageOne.relations,
@@ -340,10 +605,10 @@ var StagedModelBuilder = class StagedModelBuilder {
 		}, this.attributesFactory, this.sqlFactory);
 	}
 	attributes(specOrFactory) {
-		return new StagedModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
+		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
 	}
 	sql(specOrFactory) {
-		return new StagedModelBuilder(this.stageOne, this.attributesFactory, specOrFactory);
+		return new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory);
 	}
 	buildAttributesSpec() {
 		if (!this.attributesFactory) return;
@@ -388,7 +653,7 @@ function normalizeRelationModelSource(target) {
 function model(modelNameOrInput, maybeInput) {
 	const input = typeof modelNameOrInput === "string" ? maybeInput : modelNameOrInput;
 	if (!input) throw new Error("model(\"ModelName\", ...) requires a model definition.");
-	return new StagedModelBuilder({
+	return new ContractModelBuilder({
 		...typeof modelNameOrInput === "string" ? { modelName: modelNameOrInput } : {},
 		fields: input.fields,
 		relations: input.relations ?? {}
@@ -436,7 +701,7 @@ const field = {
 	generated: generatedField,
 	namedType: namedTypeField
 };
-function isStagedContractInput(value) {
+function isContractInput(value) {
 	if (typeof value !== "object" || value === null || !("target" in value) || !("family" in value)) return false;
 	const target = value.target;
 	const family = value.family;
@@ -550,291 +815,7 @@ function createComposedAuthoringHelpers(options) {
 }
 
 //#endregion
-//#region src/contract-ir-builder.ts
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-function isJsonValue(value) {
-	if (value === null) return true;
-	const valueType = typeof value;
-	if (valueType === "string" || valueType === "number" || valueType === "boolean") return true;
-	if (Array.isArray(value)) return value.every((item) => isJsonValue(item));
-	if (isPlainObject(value)) return Object.values(value).every((item) => isJsonValue(item));
-	return false;
-}
-function encodeDefaultLiteralValue(value) {
-	if (typeof value === "bigint") return {
-		$type: "bigint",
-		value: value.toString()
-	};
-	if (value instanceof Date) return value.toISOString();
-	if (isJsonValue(value)) {
-		if (isPlainObject(value) && "$type" in value) return {
-			$type: "raw",
-			value
-		};
-		return value;
-	}
-	throw new Error("Unsupported column default literal value: expected JSON-safe value, bigint, or Date.");
-}
-function encodeColumnDefault(defaultInput) {
-	if (defaultInput.kind === "function") return {
-		kind: "function",
-		expression: defaultInput.expression
-	};
-	return {
-		kind: "literal",
-		value: encodeDefaultLiteralValue(defaultInput.value)
-	};
-}
-function assertStorageSemantics(storage) {
-	const semanticErrors = validateStorageSemantics(storage);
-	if (semanticErrors.length > 0) throw new Error(`Contract semantic validation failed: ${semanticErrors.join("; ")}`);
-}
-function buildContractIR(state) {
-	if (!state.target) throw new Error("target is required. Call .target() before .build()");
-	const target = state.target;
-	const storageTables = {};
-	const executionDefaults = [];
-	for (const tableName of Object.keys(state.tables)) {
-		const tableState = state.tables[tableName];
-		if (!tableState) continue;
-		const columns = {};
-		for (const columnName in tableState.columns) {
-			const columnState = tableState.columns[columnName];
-			if (!columnState) continue;
-			const encodedDefault = columnState.default !== void 0 ? encodeColumnDefault(columnState.default) : void 0;
-			columns[columnName] = {
-				nativeType: columnState.nativeType,
-				codecId: columnState.type,
-				nullable: columnState.nullable ?? false,
-				...ifDefined("typeParams", columnState.typeParams),
-				...ifDefined("default", encodedDefault),
-				...ifDefined("typeRef", columnState.typeRef)
-			};
-			if ("executionDefault" in columnState && columnState.executionDefault) executionDefaults.push({
-				ref: {
-					table: tableName,
-					column: columnName
-				},
-				onCreate: columnState.executionDefault
-			});
-		}
-		storageTables[tableName] = {
-			columns,
-			uniques: (tableState.uniques ?? []).map((u) => ({
-				columns: u.columns,
-				...u.name ? { name: u.name } : {}
-			})),
-			indexes: (tableState.indexes ?? []).map((i) => ({
-				columns: i.columns,
-				...i.name ? { name: i.name } : {},
-				...i.using ? { using: i.using } : {},
-				...i.config ? { config: i.config } : {}
-			})),
-			foreignKeys: (tableState.foreignKeys ?? []).map((fk) => ({
-				columns: fk.columns,
-				references: fk.references,
-				...applyFkDefaults(fk, state.foreignKeyDefaults),
-				...fk.name ? { name: fk.name } : {},
-				...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
-				...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
-			})),
-			...tableState.primaryKey ? { primaryKey: {
-				columns: tableState.primaryKey,
-				...tableState.primaryKeyName ? { name: tableState.primaryKeyName } : {}
-			} } : {}
-		};
-	}
-	const storage = {
-		tables: storageTables,
-		types: state.storageTypes ?? {}
-	};
-	const execution = executionDefaults.length > 0 ? { mutations: { defaults: executionDefaults.sort((a, b) => {
-		const tableCompare = a.ref.table.localeCompare(b.ref.table);
-		if (tableCompare !== 0) return tableCompare;
-		return a.ref.column.localeCompare(b.ref.column);
-	}) } } : void 0;
-	const models = {};
-	for (const modelName in state.models) {
-		const modelState = state.models[modelName];
-		if (!modelState) continue;
-		const tableName = modelState.table;
-		const tableState = state.tables[tableName];
-		const tableColumns = tableState ? tableState.columns : {};
-		const storageFields = {};
-		const domainFields = {};
-		for (const fieldName in modelState.fields) {
-			const columnName = modelState.fields[fieldName];
-			if (!columnName) continue;
-			storageFields[fieldName] = { column: columnName };
-			const column = tableColumns[columnName];
-			if (column) domainFields[fieldName] = {
-				codecId: column.type,
-				nullable: column.nullable ?? false
-			};
-		}
-		const modelRelations = {};
-		if (modelState.relations) for (const relName in modelState.relations) {
-			const rel$1 = modelState.relations[relName];
-			if (!rel$1) continue;
-			modelRelations[relName] = {
-				to: rel$1.to,
-				cardinality: rel$1.cardinality,
-				on: {
-					localFields: rel$1.on.parentCols,
-					targetFields: rel$1.on.childCols
-				}
-			};
-		}
-		models[modelName] = {
-			storage: {
-				table: tableName,
-				fields: storageFields
-			},
-			fields: domainFields,
-			relations: modelRelations
-		};
-	}
-	const extensionNamespaces = state.extensionNamespaces ?? [];
-	const extensionPacks = { ...state.extensionPacks || {} };
-	for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensionPacks, namespace)) extensionPacks[namespace] = {};
-	const contract = {
-		schemaVersion: "1",
-		target,
-		targetFamily: "sql",
-		storageHash: state.storageHash || "sha256:ts-builder-placeholder",
-		models,
-		roots: {},
-		storage,
-		...execution ? { execution } : {},
-		extensionPacks,
-		capabilities: state.capabilities || {},
-		meta: {},
-		sources: {}
-	};
-	assertStorageSemantics(contract.storage);
-	return contract;
-}
-function assertKnownTargetModel(modelsByName, sourceModelName, targetModelName, context) {
-	const targetModel = modelsByName.get(targetModelName);
-	if (!targetModel) throw new Error(`${context} on model "${sourceModelName}" references unknown model "${targetModelName}"`);
-	return targetModel;
-}
-function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
-	if (targetModel.tableName !== referencedTableName) throw new Error(`${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`);
-}
-function buildSqlContractFromSemanticDefinition(definition) {
-	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
-	const tables = {};
-	for (const model$1 of definition.models) {
-		const columns = {};
-		for (const field$1 of model$1.fields) {
-			if (field$1.executionDefault) {
-				if (field$1.default !== void 0) throw new Error(`Field "${model$1.modelName}.${field$1.fieldName}" cannot define both default and executionDefault.`);
-				if (field$1.nullable) throw new Error(`Field "${model$1.modelName}.${field$1.fieldName}" cannot be nullable when executionDefault is present.`);
-				columns[field$1.columnName] = {
-					name: field$1.columnName,
-					type: field$1.descriptor.codecId,
-					nativeType: field$1.descriptor.nativeType,
-					nullable: false,
-					...ifDefined("typeParams", field$1.descriptor.typeParams),
-					...ifDefined("typeRef", field$1.descriptor.typeRef),
-					executionDefault: field$1.executionDefault
-				};
-				continue;
-			}
-			columns[field$1.columnName] = {
-				name: field$1.columnName,
-				type: field$1.descriptor.codecId,
-				nativeType: field$1.descriptor.nativeType,
-				nullable: field$1.nullable,
-				...ifDefined("typeParams", field$1.descriptor.typeParams),
-				...ifDefined("typeRef", field$1.descriptor.typeRef),
-				...ifDefined("default", field$1.default)
-			};
-		}
-		if (model$1.id) {
-			const fieldsByColumnName = new Map(model$1.fields.map((field$1) => [field$1.columnName, field$1]));
-			for (const columnName of model$1.id.columns) {
-				const field$1 = fieldsByColumnName.get(columnName);
-				if (field$1?.nullable) throw new Error(`Model "${model$1.modelName}" uses nullable field "${field$1.fieldName}" in its identity.`);
-			}
-		}
-		const foreignKeys = (model$1.foreignKeys ?? []).map((fk) => {
-			const targetModel = assertKnownTargetModel(modelsByName, model$1.modelName, fk.references.model, "Foreign key");
-			assertTargetTableMatches(model$1.modelName, targetModel, fk.references.table, "Foreign key");
-			return {
-				columns: fk.columns,
-				references: {
-					table: fk.references.table,
-					columns: fk.references.columns
-				},
-				...ifDefined("name", fk.name),
-				...ifDefined("onDelete", fk.onDelete),
-				...ifDefined("onUpdate", fk.onUpdate),
-				...ifDefined("constraint", fk.constraint),
-				...ifDefined("index", fk.index)
-			};
-		});
-		tables[model$1.tableName] = {
-			name: model$1.tableName,
-			columns,
-			...model$1.id ? { primaryKey: model$1.id.columns } : {},
-			...model$1.id?.name ? { primaryKeyName: model$1.id.name } : {},
-			uniques: model$1.uniques ?? [],
-			indexes: model$1.indexes ?? [],
-			foreignKeys
-		};
-	}
-	const modelStates = {};
-	for (const model$1 of definition.models) {
-		const fields = {};
-		for (const field$1 of model$1.fields) fields[field$1.fieldName] = field$1.columnName;
-		const relations = {};
-		for (const relation of model$1.relations ?? []) {
-			const targetModel = assertKnownTargetModel(modelsByName, model$1.modelName, relation.toModel, "Relation");
-			assertTargetTableMatches(model$1.modelName, targetModel, relation.toTable, "Relation");
-			if (relation.cardinality === "N:M" && !relation.through) throw new Error(`Relation "${model$1.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`);
-			relations[relation.fieldName] = {
-				to: relation.toModel,
-				cardinality: relation.cardinality,
-				on: {
-					parentCols: relation.on.parentColumns,
-					childCols: relation.on.childColumns
-				},
-				...relation.through ? { through: {
-					table: relation.through.table,
-					parentCols: relation.through.parentColumns,
-					childCols: relation.through.childColumns
-				} } : void 0
-			};
-		}
-		modelStates[model$1.modelName] = {
-			name: model$1.modelName,
-			table: model$1.tableName,
-			fields,
-			relations
-		};
-	}
-	const extensionNamespaces = definition.extensionPacks ? Object.values(definition.extensionPacks).map((pack) => pack.id) : void 0;
-	return buildContractIR({
-		target: definition.target.targetId,
-		tables,
-		models: modelStates,
-		...ifDefined("storageTypes", definition.storageTypes),
-		...ifDefined("storageHash", definition.storageHash),
-		...ifDefined("extensionPacks", definition.extensionPacks),
-		...ifDefined("capabilities", definition.capabilities),
-		...ifDefined("foreignKeyDefaults", definition.foreignKeyDefaults),
-		...ifDefined("extensionNamespaces", extensionNamespaces)
-	});
-}
-
-//#endregion
-//#region src/staged-contract-warnings.ts
+//#region src/contract-warnings.ts
 function hasNamedModelToken(models, modelName) {
 	return models[modelName]?.stageOne.modelName === modelName;
 }
@@ -872,11 +853,11 @@ function flushWarnings(warnings) {
 		for (const message of warnings) process.emitWarning(message, { code: "PN_CONTRACT_TYPED_FALLBACK_AVAILABLE" });
 		return;
 	}
-	process.emitWarning(`${warnings.length} staged contract references use string fallbacks where typed alternatives are available. Use named model tokens and typed storage type refs for autocomplete and type safety.
+	process.emitWarning(`${warnings.length} contract references use string fallbacks where typed alternatives are available. Use named model tokens and typed storage type refs for autocomplete and type safety.
 ` + warnings.map((w) => `  - ${w}`).join("\n"), { code: "PN_CONTRACT_TYPED_FALLBACK_AVAILABLE" });
 }
 function formatFallbackWarning(location, current, suggested) {
-	return `Staged contract ${location} uses ${current}. Use ${suggested} when the named model token is available in the same contract to keep typed relation targets and model refs.`;
+	return `Contract ${location} uses ${current}. Use ${suggested} when the named model token is available in the same contract to keep typed relation targets and model refs.`;
 }
 function emitTypedNamedTypeFallbackWarnings(models, storageTypes) {
 	const warnings = [];
@@ -887,7 +868,7 @@ function emitTypedNamedTypeFallbackWarnings(models, storageTypes) {
 		const warningKey = `${modelName}.${fieldName}`;
 		if (warnedFields.has(warningKey)) continue;
 		warnedFields.add(warningKey);
-		warnings.push(`Staged contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). Use field.namedType(types.${fieldState.typeRef}) when the storage type is declared in the same contract to keep autocomplete and typed local refs.`);
+		warnings.push(`Contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). Use field.namedType(types.${fieldState.typeRef}) when the storage type is declared in the same contract to keep autocomplete and typed local refs.`);
 	}
 	flushWarnings(warnings);
 }
@@ -930,7 +911,7 @@ function emitTypedCrossModelFallbackWarnings(collection) {
 }
 
 //#endregion
-//#region src/staged-contract-lowering.ts
+//#region src/contract-lowering.ts
 function buildStorageTypeReverseLookup(storageTypes) {
 	const lookup = /* @__PURE__ */ new Map();
 	for (const [key, instance] of Object.entries(storageTypes)) lookup.set(instance, key);
@@ -954,7 +935,7 @@ function resolveFieldDescriptor(modelName, fieldName, fieldState, storageTypes,
 function mapFieldNamesToColumnNames(modelName, fieldNames, fieldToColumn) {
 	return fieldNames.map((fieldName) => {
 		const columnName = fieldToColumn[fieldName];
-		if (!columnName) throw new Error(`Unknown field "${modelName}.${fieldName}" in staged contract definition`);
+		if (!columnName) throw new Error(`Unknown field "${modelName}.${fieldName}" in contract definition`);
 		return columnName;
 	});
 }
@@ -1128,7 +1109,7 @@ function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs)
 		}
 	};
 }
-function resolveSemanticRelationNode(relationName, relation, currentSpec, allSpecs) {
+function resolveRelationNode(relationName, relation, currentSpec, allSpecs) {
 	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs);
 	if (relation.kind === "hasMany" || relation.kind === "hasOne") return lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs);
 	return lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs);
@@ -1148,7 +1129,7 @@ function lowerForeignKeyNode(spec, targetSpec, foreignKey) {
 		...foreignKey.index !== void 0 ? { index: foreignKey.index } : {}
 	};
 }
-function resolveSemanticForeignKeyNodes(spec, allSpecs) {
+function resolveForeignKeyNodes(spec, allSpecs) {
 	const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
 		const targetSpec = allSpecs.get(foreignKey.targetModel);
 		if (!targetSpec) throw new Error(`Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`);
@@ -1161,7 +1142,7 @@ function resolveSemanticForeignKeyNodes(spec, allSpecs) {
 	});
 	return [...relationForeignKeys, ...sqlForeignKeys];
 }
-function resolveSemanticModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup) {
+function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup) {
 	const fields = [];
 	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
 		const fieldState = fieldBuilder.build();
@@ -1188,8 +1169,8 @@ function resolveSemanticModelNode(spec, allSpecs, storageTypes, storageTypeRever
 		...index.using ? { using: index.using } : {},
 		...index.config ? { config: index.config } : {}
 	}));
-	const foreignKeys = resolveSemanticForeignKeyNodes(spec, allSpecs);
-	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveSemanticRelationNode(relationName, relationBuilder.build(), spec, allSpecs));
+	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
+	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs));
 	return {
 		modelName: spec.modelName,
 		tableName: spec.tableName,
@@ -1251,14 +1232,14 @@ function collectRuntimeModelSpecs(definition) {
 		modelSpecs
 	};
 }
-function lowerSemanticModels(collection) {
+function lowerModels(collection) {
 	emitTypedCrossModelFallbackWarnings(collection);
 	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveSemanticModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup));
 }
-function buildStagedSemanticContractDefinition(definition) {
+function buildContractDefinition(definition) {
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerSemanticModels(collection);
+	const models = lowerModels(collection);
 	return {
 		target: definition.target,
 		...definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {},
@@ -1272,122 +1253,36 @@ function buildStagedSemanticContractDefinition(definition) {
 
 //#endregion
 //#region src/contract-builder.ts
-function buildStagedContract(definition) {
-	return buildSqlContractFromSemanticDefinition(buildStagedSemanticContractDefinition(definition));
-}
-var SqlContractBuilder = class SqlContractBuilder extends ContractBuilder {
-	/**
-	* This method is responsible for normalizing the contract IR by setting default values
-	* for all required fields:
-	* - `nullable`: defaults to `false` if not provided
-	* - `uniques`: defaults to `[]` (empty array)
-	* - `indexes`: defaults to `[]` (empty array)
-	* - `foreignKeys`: defaults to `[]` (empty array)
-	* - model `relations`: defaults to `{}` (empty object) when not populated by the builder
-	* - `nativeType`: required field set from column type descriptor when columns are defined
-	*
-	* The contract builder is the **only** place where normalization should occur.
-	* Validators, parsers, and emitters should assume the contract is already normalized.
-	*
-	* **Required**: Use column type descriptors (e.g., `int4Column`, `textColumn`) when defining columns.
-	* This ensures `nativeType` is set correctly at build time.
-	*
-	* @returns A normalized SqlContract with all required fields present
-	*/
-	build() {
-		return buildContractIR(this.state);
+function validateTargetPackRef(family, target) {
+	if (family.familyId !== "sql") throw new Error(`defineContract only accepts SQL family packs. Received family "${family.familyId}".`);
+	if (target.familyId !== family.familyId) throw new Error(`target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`);
+}
+function validateExtensionPackRefs(target, extensionPacks) {
+	if (!extensionPacks) return;
+	for (const packRef of Object.values(extensionPacks)) {
+		if (packRef.kind !== "extension") throw new Error(`defineContract only accepts extension pack refs in extensionPacks. Received kind "${packRef.kind}".`);
+		if (packRef.familyId !== target.familyId) throw new Error(`extension pack "${packRef.id}" targets family "${packRef.familyId}" but contract target family is "${target.familyId}".`);
+		if (packRef.targetId && packRef.targetId !== target.targetId) throw new Error(`extension pack "${packRef.id}" targets "${packRef.targetId}" but contract target is "${target.targetId}".`);
 	}
-	target(packRef) {
-		return new SqlContractBuilder({
-			...this.state,
-			target: packRef.targetId
-		});
-	}
-	extensionPacks(packs) {
-		if (!this.state.target) throw new Error("extensionPacks() requires target() to be called first");
-		const namespaces = new Set(this.state.extensionNamespaces ?? []);
-		const nextExtensionPacks = { ...this.state.extensionPacks ?? {} };
-		for (const [name, packRef] of Object.entries(packs)) {
-			if (!packRef) continue;
-			if (packRef.kind !== "extension") throw new Error(`extensionPacks() only accepts extension pack refs. Received kind "${packRef.kind}".`);
-			if (packRef.familyId !== "sql") throw new Error(`extension pack "${packRef.id}" targets family "${packRef.familyId}" but this builder targets "sql".`);
-			if (packRef.targetId && packRef.targetId !== this.state.target) throw new Error(`extension pack "${packRef.id}" targets "${packRef.targetId}" but builder target is "${this.state.target}".`);
-			namespaces.add(packRef.id);
-			nextExtensionPacks[name] = packRef;
-		}
-		return new SqlContractBuilder({
-			...this.state,
-			extensionPacks: nextExtensionPacks,
-			extensionNamespaces: [...namespaces]
-		});
-	}
-	capabilities(capabilities) {
-		return new SqlContractBuilder({
-			...this.state,
-			capabilities
-		});
-	}
-	storageHash(hash) {
-		return new SqlContractBuilder({
-			...this.state,
-			storageHash: hash
-		});
-	}
-	table(name, callback) {
-		const tableBuilder = createTable(name);
-		const result = callback(tableBuilder);
-		const tableState = (result instanceof TableBuilder ? result : tableBuilder).build();
-		return new SqlContractBuilder({
-			...this.state,
-			tables: {
-				...this.state.tables,
-				[name]: tableState
-			}
-		});
-	}
-	model(name, table, callback) {
-		const modelBuilder = new ModelBuilder(name, table);
-		const result = callback(modelBuilder);
-		const modelState = (result instanceof ModelBuilder ? result : modelBuilder).build();
-		return new SqlContractBuilder({
-			...this.state,
-			models: {
-				...this.state.models,
-				[name]: modelState
-			}
-		});
-	}
-	foreignKeyDefaults(config) {
-		return new SqlContractBuilder({
-			...this.state,
-			foreignKeyDefaults: config
-		});
-	}
-	storageType(name, typeInstance) {
-		return new SqlContractBuilder({
-			...this.state,
-			storageTypes: {
-				...this.state.storageTypes ?? {},
-				[name]: typeInstance
-			}
-		});
-	}
-};
+}
+function buildContractFromDsl(definition) {
+	validateTargetPackRef(definition.family, definition.target);
+	validateExtensionPackRefs(definition.target, definition.extensionPacks);
+	return buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup);
+}
 function defineContract(definition, factory) {
-	if (definition && isStagedContractInput(definition)) {
-		if (factory) return buildStagedContract({
-			...definition,
-			...factory(createComposedAuthoringHelpers({
-				family: definition.family,
-				target: definition.target,
-				extensionPacks: definition.extensionPacks
-			}))
-		});
-		return buildStagedContract(definition);
-	}
-	return new SqlContractBuilder();
+	if (!isContractInput(definition)) throw new TypeError("defineContract expects a contract definition object. Define your contract with defineContract({ family, target, models, ... }).");
+	if (!factory) return buildContractFromDsl(definition);
+	return buildContractFromDsl({
+		...definition,
+		...factory(createComposedAuthoringHelpers({
+			family: definition.family,
+			target: definition.target,
+			extensionPacks: definition.extensionPacks
+		}))
+	});
 }
 
 //#endregion
-export { buildSqlContractFromSemanticDefinition, defineContract, field, model, rel };
+export { buildSqlContractFromDefinition, defineContract, field, model, rel };
 //# sourceMappingURL=contract-builder.mjs.map