@prisma-next/sql-contract-ts 0.12.0 → 0.13.0-dev.10

package/dist/contract-builder.mjs

@@ -1,9 +1,9 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-BCYW3_wE.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-HP3IjjLv.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
+import { ifDefined } from "@prisma-next/utils/defined";
 import { isColumnDefault } from "@prisma-next/contract/types";
 import { createEntityHelpersFromNamespace } from "@prisma-next/contract-authoring";
 import { isPostgresEnumStorageEntry, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { ifDefined } from "@prisma-next/utils/defined";
 import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 //#region src/authoring-helper-runtime.ts
 function isNamedConstraintOptionsLike(value) {
@@ -79,6 +79,71 @@ function createFieldHelpersFromNamespace(namespace, createLeafHelper, path = [])
 	return helpers;
 }
 //#endregion
+//#region src/enum-type.ts
+function member(name, value) {
+	return {
+		name,
+		value: blindCast(value ?? name)
+	};
+}
+/**
+* Internal brand that identifies an EnumTypeHandle in the lowering pipeline.
+* Not exported — callers only interact with `EnumTypeHandle`.
+*/
+const ENUM_TYPE_HANDLE_BRAND = Symbol("EnumTypeHandle");
+function enumType(name, codec, ...members) {
+	if (members.length === 0) throw new Error(`enumType("${name}"): must have at least one member.`);
+	const seenNames = /* @__PURE__ */ new Set();
+	const seenValues = /* @__PURE__ */ new Set();
+	for (const m of members) {
+		if (seenNames.has(m.name)) throw new Error(`enumType("${name}"): duplicate member name "${m.name}". Member names must be unique.`);
+		seenNames.add(m.name);
+		const loweredValue = String(m.value);
+		if (seenValues.has(loweredValue)) throw new Error(`enumType("${name}"): duplicate member value "${loweredValue}". Member values must be unique.`);
+		seenValues.add(loweredValue);
+	}
+	const values = Object.freeze(members.map((m) => m.value));
+	const names = Object.freeze(members.map((m) => m.name));
+	const enumMembers = Object.freeze(members.map((m) => ({
+		name: m.name,
+		value: m.value
+	})));
+	const membersAccessor = Object.freeze(Object.fromEntries(members.map((m) => [m.name, m.value])));
+	const valueSet = new Set(values);
+	const valueToName = new Map(members.map((m) => [m.value, m.name]));
+	const valueToOrdinal = new Map(values.map((v, i) => [v, i]));
+	return {
+		[ENUM_TYPE_HANDLE_BRAND]: true,
+		enumName: name,
+		codecId: codec.codecId,
+		nativeType: codec.nativeType,
+		enumMembers,
+		values,
+		names,
+		members: membersAccessor,
+		has: (v) => valueSet.has(v),
+		nameOf: (v) => valueToName.get(v),
+		ordinalOf: (v) => valueToOrdinal.get(v) ?? -1
+	};
+}
+/**
+* Bind `enumType` to a target's codec typemap. The returned function is the
+* same runtime `enumType`, retyped so member values are constrained to the
+* codec's input type. Target packages call this with their pack's
+* `ExtractCodecTypesFromPack<Pack>` to expose a codec-aware `enumType`.
+*/
+function bindEnumType() {
+	return enumType;
+}
+/**
+* Returns true when the value is an `EnumTypeHandle` produced by
+* `enumType()`. Used in the lowering pipeline to detect enum handles
+* in field state without importing the BRAND symbol at every call site.
+*/
+function isEnumTypeHandle(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, ENUM_TYPE_HANDLE_BRAND) === true;
+}
+//#endregion
 //#region src/contract-dsl.ts
 function toColumnDefault(value) {
 	if (isColumnDefault(value)) return value;
@@ -92,6 +157,15 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 	constructor(state) {
 		this.state = state;
 	}
+	/**
+	* Returns the physical column name when `.column(name)` was called, or
+	* `undefined` when the field uses the default (logical field name) mapping.
+	* Used by cross-space FK lowering to stamp the physical column name onto
+	* `TargetFieldRef.columnName` so FK target columns are resolved correctly.
+	*/
+	get physicalColumnName() {
+		return this.state.columnName;
+	}
 	optional() {
 		return new ScalarFieldBuilder({
 			...this.state,
@@ -166,6 +240,11 @@ function generatedField(spec) {
 	});
 }
 function namedTypeField(typeRef) {
+	if (isEnumTypeHandle(typeRef)) return new ScalarFieldBuilder({
+		kind: "scalar",
+		typeRef,
+		nullable: false
+	});
 	return new ScalarFieldBuilder({
 		kind: "scalar",
 		typeRef,
@@ -208,10 +287,16 @@ function normalizeTargetFieldRefInput(input) {
 	const [first] = refs;
 	if (!first) throw new Error("Expected at least one target ref");
 	if (refs.some((ref) => ref.modelName !== first.modelName)) throw new Error("All target refs in a foreign key must point to the same model");
+	if (refs.some((ref) => ref.spaceId !== first.spaceId)) throw new Error(`All target refs in a compound foreign key must share the same spaceId (found mismatch: "${first.spaceId ?? "<local>"}" vs "${refs.find((r) => r.spaceId !== first.spaceId)?.spaceId ?? "<local>"}")`);
+	if (refs.some((ref) => ref.namespaceId !== first.namespaceId)) throw new Error("All target refs in a compound foreign key must share the same namespaceId (found mismatch)");
+	if (refs.some((ref) => ref.tableName !== first.tableName)) throw new Error("All target refs in a compound foreign key must share the same tableName (found mismatch)");
 	return {
 		modelName: first.modelName,
-		fieldNames: refs.map((ref) => ref.fieldName),
-		source: refs.some((ref) => ref.source === "string") ? "string" : "token"
+		fieldNames: refs.map((ref) => ref.columnName ?? ref.fieldName),
+		source: refs.some((ref) => ref.source === "string") ? "string" : "token",
+		spaceId: first.spaceId,
+		namespaceId: first.namespaceId,
+		tableName: first.tableName
 	};
 }
 function createConstraintsDsl() {
@@ -254,6 +339,9 @@ function createConstraintsDsl() {
 			targetModel: normalizedTarget.modelName,
 			targetFields: normalizedTarget.fieldNames,
 			targetSource: normalizedTarget.source,
+			...normalizedTarget.spaceId !== void 0 ? { targetSpaceId: normalizedTarget.spaceId } : {},
+			...normalizedTarget.namespaceId !== void 0 ? { targetNamespaceId: normalizedTarget.namespaceId } : {},
+			...normalizedTarget.tableName !== void 0 ? { targetTableName: normalizedTarget.tableName } : {},
 			...options?.name ? { name: options.name } : {},
 			...options?.onDelete ? { onDelete: options.onDelete } : {},
 			...options?.onUpdate ? { onUpdate: options.onUpdate } : {},
@@ -277,14 +365,23 @@ function createFieldRefs(fields) {
 	};
 	return refs;
 }
-function createModelTokenRefs(modelName, fields) {
+function createModelTokenRefs(modelName, fields, crossSpaceCoordinate) {
 	const refs = {};
-	for (const fieldName of Object.keys(fields)) refs[fieldName] = {
-		kind: "targetFieldRef",
-		source: "token",
-		modelName,
-		fieldName
-	};
+	for (const [fieldName, fieldBuilder] of Object.entries(fields)) {
+		const physicalColumn = crossSpaceCoordinate !== void 0 ? fieldBuilder.physicalColumnName : void 0;
+		refs[fieldName] = {
+			kind: "targetFieldRef",
+			source: "token",
+			modelName,
+			fieldName,
+			...crossSpaceCoordinate !== void 0 ? {
+				spaceId: crossSpaceCoordinate.spaceId,
+				...crossSpaceCoordinate.namespaceId !== void 0 ? { namespaceId: crossSpaceCoordinate.namespaceId } : {},
+				...crossSpaceCoordinate.tableName !== void 0 ? { tableName: crossSpaceCoordinate.tableName } : {},
+				...physicalColumn !== void 0 ? { columnName: physicalColumn } : {}
+			} : {}
+		};
+	}
 	return refs;
 }
 function buildStageSpec(stageInput, context) {
@@ -316,12 +413,21 @@ var ContractModelBuilder = class ContractModelBuilder {
 	stageOne;
 	attributesFactory;
 	sqlFactory;
+	spaceId;
+	tableName;
 	refs;
-	constructor(stageOne, attributesFactory, sqlFactory) {
+	constructor(stageOne, attributesFactory, sqlFactory, spaceId, tableName) {
 		this.stageOne = stageOne;
 		this.attributesFactory = attributesFactory;
 		this.sqlFactory = sqlFactory;
-		this.refs = stageOne.modelName ? createModelTokenRefs(stageOne.modelName, stageOne.fields) : void 0;
+		this.spaceId = spaceId;
+		this.tableName = tableName;
+		const crossSpaceCoordinate = spaceId !== void 0 ? {
+			spaceId,
+			...stageOne.namespace !== void 0 ? { namespaceId: stageOne.namespace } : {},
+			...tableName !== void 0 ? { tableName } : {}
+		} : void 0;
+		this.refs = blindCast(stageOne.modelName ? createModelTokenRefs(stageOne.modelName, stageOne.fields, crossSpaceCoordinate) : void 0);
 	}
 	ref(fieldName) {
 		const modelName = this.stageOne.modelName;
@@ -342,13 +448,14 @@ var ContractModelBuilder = class ContractModelBuilder {
 				...this.stageOne.relations,
 				...relations
 			}
-		}, this.attributesFactory, this.sqlFactory);
+		}, this.attributesFactory, this.sqlFactory, this.spaceId, this.tableName);
 	}
 	attributes(specOrFactory) {
-		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
+		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory, this.spaceId, this.tableName);
 	}
 	sql(specOrFactory) {
-		return new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory);
+		const nextTableName = typeof specOrFactory !== "function" ? specOrFactory.table : this.tableName;
+		return blindCast(new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory, this.spaceId, nextTableName));
 	}
 	buildAttributesSpec() {
 		if (!this.attributesFactory) return;
@@ -400,12 +507,47 @@ function model(modelNameOrInput, maybeInput) {
 		relations: input.relations ?? {}
 	});
 }
+/**
+* Factory for building a standalone branded extension model handle.
+*
+* Use this instead of `new ContractModelBuilder(…)` when constructing handles
+* for models that live in a foreign contract space (e.g. a Supabase extension
+* model referenced by a user's contract). The `spaceId` brands the returned
+* handle so `refs.<field>.spaceId` carries the foreign space identifier.
+*
+* @param name - The domain model name as declared in the foreign contract
+*   (e.g. `'AuthUser'`, not a bare table alias like `'User'`).
+* @param input.namespace - The namespace within the foreign space (e.g. `'auth'`).
+* @param input.fields - Field definitions (use `field.column(…)`).
+* @param input.table - The physical table name in the foreign schema.
+* @param spaceId - The extension space identifier (e.g. `'supabase'`).
+*/
+function extensionModel(name, input, spaceId) {
+	return new ContractModelBuilder({
+		modelName: name,
+		namespace: input.namespace,
+		fields: input.fields,
+		relations: {}
+	}, void 0, void 0, spaceId, input.table);
+}
+function isCrossSpaceHandle(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const rec = blindCast(value);
+	return typeof rec["spaceId"] === "string" && typeof rec["stageOne"] === "object" && rec["stageOne"] !== null;
+}
 function belongsTo(toModel, options) {
+	const resolvedModel = typeof toModel === "function" ? toModel() : toModel;
+	const crossSpaceCoordinate = isCrossSpaceHandle(resolvedModel) ? {
+		spaceId: resolvedModel.spaceId,
+		...resolvedModel.tableName !== void 0 ? { tableName: resolvedModel.tableName } : {},
+		...resolvedModel.stageOne.namespace !== void 0 ? { namespaceId: resolvedModel.stageOne.namespace } : {}
+	} : void 0;
 	return new RelationBuilder({
 		kind: "belongsTo",
 		toModel: normalizeRelationModelSource(toModel),
 		from: options.from,
-		to: options.to
+		to: options.to,
+		...crossSpaceCoordinate !== void 0 ? crossSpaceCoordinate : {}
 	});
 }
 function hasMany(toModel, options) {
@@ -677,6 +819,10 @@ function buildStorageTypeReverseLookup(storageTypes) {
 function resolveFieldDescriptor(modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup) {
 	if ("descriptor" in fieldState && fieldState.descriptor) return fieldState.descriptor;
 	if ("typeRef" in fieldState && fieldState.typeRef) {
+		if (isEnumTypeHandle(fieldState.typeRef)) return {
+			codecId: fieldState.typeRef.codecId,
+			nativeType: fieldState.typeRef.nativeType
+		};
 		const typeRef = typeof fieldState.typeRef === "string" ? fieldState.typeRef : storageTypeReverseLookup.get(fieldState.typeRef);
 		if (!typeRef) throw new Error(`Field "${modelName}.${fieldName}" references a storage type instance that is not present in definition.types`);
 		const referencedType = storageTypes[typeRef];
@@ -751,6 +897,33 @@ function resolveRelationForeignKeys(spec, allSpecs) {
 		const relation = relationBuilder.build();
 		if (relation.kind !== "belongsTo" || !relation.sql?.fk) continue;
 		const targetModelName = resolveRelationModelName(relation.toModel);
+		if (relation.spaceId !== void 0) {
+			const fields = normalizeRelationFieldNames(relation.from);
+			const targetFields = normalizeRelationFieldNames(relation.to);
+			assertRelationFieldArity({
+				modelName: spec.modelName,
+				relationName,
+				leftLabel: "source",
+				leftFields: fields,
+				rightLabel: "target",
+				rightFields: targetFields
+			});
+			foreignKeys.push({
+				kind: "fk",
+				fields,
+				targetModel: targetModelName,
+				targetFields,
+				targetSpaceId: relation.spaceId,
+				...relation.namespaceId !== void 0 ? { targetNamespaceId: relation.namespaceId } : {},
+				...relation.tableName !== void 0 ? { targetTableName: relation.tableName } : {},
+				...relation.sql.fk.name ? { name: relation.sql.fk.name } : {},
+				...relation.sql.fk.onDelete ? { onDelete: relation.sql.fk.onDelete } : {},
+				...relation.sql.fk.onUpdate ? { onUpdate: relation.sql.fk.onUpdate } : {},
+				...relation.sql.fk.constraint !== void 0 ? { constraint: relation.sql.fk.constraint } : {},
+				...relation.sql.fk.index !== void 0 ? { index: relation.sql.fk.index } : {}
+			});
+			continue;
+		}
 		if (!allSpecs.has(targetModelName)) throw new Error(`Relation "${spec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 		const fields = normalizeRelationFieldNames(relation.from);
 		const targetFields = normalizeRelationFieldNames(relation.to);
@@ -782,10 +955,8 @@ function resolveRelationAnchorFields(spec) {
 	if ("id" in spec.fieldToColumn) return ["id"];
 	throw new Error(`Model "${spec.modelName}" needs an explicit id or an "id" field to anchor non-owning relations`);
 }
-function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs) {
+function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
-	const targetSpec = allSpecs.get(targetModelName);
-	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 	const fromFields = normalizeRelationFieldNames(relation.from);
 	const toFields = normalizeRelationFieldNames(relation.to);
 	assertRelationFieldArity({
@@ -796,6 +967,27 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs) {
 		rightLabel: "target",
 		rightFields: toFields
 	});
+	if (relation.spaceId !== void 0) {
+		assertKnownExtensionPack(extensionPacks, relation.spaceId, `Relation "${currentSpec.modelName}.${relationName}"`);
+		const targetTable = relation.tableName ?? targetModelName.toLowerCase();
+		const parentColumns = mapFieldNamesToColumnNames(currentSpec.modelName, fromFields, currentSpec.fieldToColumn);
+		return {
+			fieldName: relationName,
+			toModel: targetModelName,
+			toTable: targetTable,
+			cardinality: "N:1",
+			spaceId: relation.spaceId,
+			...relation.namespaceId !== void 0 ? { namespaceId: relation.namespaceId } : {},
+			on: {
+				parentTable: currentSpec.tableName,
+				parentColumns,
+				childTable: targetTable,
+				childColumns: toFields
+			}
+		};
+	}
+	const targetSpec = allSpecs.get(targetModelName);
+	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 	return {
 		fieldName: relationName,
 		toModel: targetModelName,
@@ -866,12 +1058,12 @@ function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs)
 		}
 	};
 }
-function resolveRelationNode(relationName, relation, currentSpec, allSpecs) {
-	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs);
+function resolveRelationNode(relationName, relation, currentSpec, allSpecs, extensionPacks) {
+	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks);
 	if (relation.kind === "hasMany" || relation.kind === "hasOne") return lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs);
 	return lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs);
 }
-function lowerForeignKeyNode(spec, targetSpec, foreignKey) {
+function lowerLocalForeignKeyNode(spec, targetSpec, foreignKey) {
 	return {
 		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
 		references: {
@@ -886,33 +1078,70 @@ function lowerForeignKeyNode(spec, targetSpec, foreignKey) {
 		...foreignKey.index !== void 0 ? { index: foreignKey.index } : {}
 	};
 }
-function resolveForeignKeyNodes(spec, allSpecs) {
+function lowerCrossSpaceForeignKeyNode(spec, foreignKey) {
+	return {
+		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
+		references: {
+			model: foreignKey.targetModel,
+			table: foreignKey.targetTableName ?? foreignKey.targetModel.toLowerCase(),
+			columns: foreignKey.targetFields,
+			...foreignKey.targetNamespaceId !== void 0 ? { namespaceId: foreignKey.targetNamespaceId } : {},
+			spaceId: foreignKey.targetSpaceId
+		},
+		...foreignKey.name ? { name: foreignKey.name } : {},
+		...foreignKey.onDelete ? { onDelete: foreignKey.onDelete } : {},
+		...foreignKey.onUpdate ? { onUpdate: foreignKey.onUpdate } : {},
+		...foreignKey.constraint !== void 0 ? { constraint: foreignKey.constraint } : {},
+		...foreignKey.index !== void 0 ? { index: foreignKey.index } : {}
+	};
+}
+function assertKnownExtensionPack(extensionPacks, spaceId, context) {
+	if (extensionPacks !== void 0 && Object.hasOwn(extensionPacks, spaceId)) return;
+	throw new Error(`${context} references contract space "${spaceId}" but "${spaceId}" is not declared in extensionPacks. Add the pack to extensionPacks.`);
+}
+function resolveForeignKeyNodes(spec, allSpecs, extensionPacks) {
 	const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
+		if (foreignKey.targetSpaceId !== void 0) {
+			assertKnownExtensionPack(extensionPacks, foreignKey.targetSpaceId, `Relation-derived foreign key on "${spec.modelName}"`);
+			return lowerCrossSpaceForeignKeyNode(spec, {
+				...foreignKey,
+				targetSpaceId: foreignKey.targetSpaceId
+			});
+		}
 		const targetSpec = allSpecs.get(foreignKey.targetModel);
 		if (!targetSpec) throw new Error(`Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`);
-		return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+		return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
 	});
 	const sqlForeignKeys = (spec.sqlSpec?.foreignKeys ?? []).map((foreignKey) => {
+		if (foreignKey.targetSpaceId !== void 0) {
+			assertKnownExtensionPack(extensionPacks, foreignKey.targetSpaceId, `Foreign key on "${spec.modelName}"`);
+			return lowerCrossSpaceForeignKeyNode(spec, {
+				...foreignKey,
+				targetSpaceId: foreignKey.targetSpaceId
+			});
+		}
 		const targetSpec = allSpecs.get(foreignKey.targetModel);
 		if (!targetSpec) throw new Error(`Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`);
-		return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+		return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
 	});
 	return [...relationForeignKeys, ...sqlForeignKeys];
 }
-function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup) {
+function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, extensionPacks) {
 	const fields = [];
 	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
 		const fieldState = fieldBuilder.build();
 		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup);
 		const columnName = spec.fieldToColumn[fieldName];
 		if (!columnName) throw new Error(`Column name resolution failed for "${spec.modelName}.${fieldName}"`);
+		const enumHandle = "typeRef" in fieldState && isEnumTypeHandle(fieldState.typeRef) ? fieldState.typeRef : void 0;
 		fields.push({
 			fieldName,
 			columnName,
 			descriptor,
 			nullable: fieldState.nullable,
 			...fieldState.default ? { default: fieldState.default } : {},
-			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {}
+			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {},
+			...enumHandle !== void 0 ? { enumTypeHandle: enumHandle } : {}
 		});
 	}
 	const { idConstraint } = spec;
@@ -926,8 +1155,8 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...ifDefined("type", index.type),
 		...ifDefined("options", index.options)
 	}));
-	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
-	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs));
+	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs, extensionPacks);
+	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs, extensionPacks));
 	return {
 		modelName: spec.modelName,
 		tableName: spec.tableName,
@@ -940,7 +1169,8 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...uniques.length > 0 ? { uniques } : {},
 		...indexes.length > 0 ? { indexes } : {},
 		...foreignKeys.length > 0 ? { foreignKeys } : {},
-		...relations.length > 0 ? { relations } : {}
+		...relations.length > 0 ? { relations } : {},
+		...ifDefined("control", spec.sqlSpec?.control)
 	};
 }
 function collectRuntimeModelSpecs(definition) {
@@ -991,22 +1221,24 @@ function collectRuntimeModelSpecs(definition) {
 		modelSpecs
 	};
 }
-function lowerModels(collection) {
+function lowerModels(collection, extensionPacks) {
 	emitTypedCrossModelFallbackWarnings(collection);
 	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensionPacks));
 }
 function buildContractDefinition(definition) {
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerModels(collection);
+	const models = lowerModels(collection, definition.extensionPacks);
 	return {
 		target: definition.target,
+		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
 		...definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {},
 		...definition.storageHash ? { storageHash: definition.storageHash } : {},
 		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
 		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
 		...definition.namespaces ? { namespaces: definition.namespaces } : {},
 		...definition.createNamespace ? { createNamespace: definition.createNamespace } : {},
+		...definition.enums && Object.keys(definition.enums).length > 0 ? { enums: definition.enums } : {},
 		models
 	};
 }
@@ -1094,19 +1326,38 @@ function buildContractFromDsl(definition) {
 	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
 	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
 }
-function defineContract(definition, factory) {
-	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({
+/** Implementation. */
+function buildBoundContract(family, target, definition, factory) {
+	const full = {
 		...definition,
-		...factory(createComposedAuthoringHelpers({
-			family: definition.family,
-			target: definition.target,
+		family,
+		target
+	};
+	if (factory !== void 0) {
+		const built = factory(createComposedAuthoringHelpers({
+			family,
+			target,
 			extensionPacks: definition.extensionPacks
-		}))
-	});
+		}));
+		const mergedEnums = {
+			...definition.enums ?? {},
+			...built.enums
+		};
+		return buildContractFromDsl({
+			...full,
+			...ifDefined("types", built.types),
+			...ifDefined("models", built.models),
+			...ifDefined("enums", Object.keys(mergedEnums).length > 0 ? mergedEnums : void 0)
+		});
+	}
+	return buildContractFromDsl(full);
+}
+function defineContract(definition, factory) {
+	if (!isContractInput(definition)) throw new TypeError("defineContract expects a contract definition object. Define your contract with defineContract({ family, target, models, ... }).");
+	if (factory !== void 0) return buildBoundContract(definition.family, definition.target, definition, factory);
+	return buildBoundContract(definition.family, definition.target, definition);
 }
 //#endregion
-export { buildSqlContractFromDefinition, defineContract, field, model, rel };
+export { bindEnumType, buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, extensionModel, field, member, model, rel };
 
 //# sourceMappingURL=contract-builder.mjs.map