@prisma-next/sql-contract-ts 0.16.0-dev.3 → 0.16.0-dev.30

package/dist/contract-builder.mjs

@@ -1,10 +1,11 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-CAX6inbk.mjs";
+import { n as contractError, t as buildSqlContractFromDefinition } from "./build-contract-DbUeVkiu.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { isColumnDefault } from "@prisma-next/contract/types";
 import { bindEnumType, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member } from "@prisma-next/contract-authoring";
 import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 import { toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { InternalError } from "@prisma-next/utils/internal-error";
 import { providesEntityHandleLowering } from "@prisma-next/sql-contract/entity-handle-lowering-hook";
 //#region src/authoring-helper-runtime.ts
 function isNamedConstraintOptionsLike(value) {
@@ -19,7 +20,10 @@ const blockedSegments = /* @__PURE__ */ new Set([
 	"prototype"
 ]);
 function assertSafeHelperKey(key, path) {
-	if (blockedSegments.has(key)) throw new Error(`Invalid authoring helper "${[...path, key].join(".")}". Helper path segments must not use "${key}".`);
+	if (blockedSegments.has(key)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Invalid authoring helper "${[...path, key].join(".")}". Helper path segments must not use "${key}".`, { meta: {
+		helperPath: [...path, key].join("."),
+		segment: key
+	} });
 }
 function createTypeHelpersFromNamespace(namespace, path = []) {
 	const helpers = {};
@@ -47,12 +51,16 @@ function createFieldPresetHelper(options) {
 	return (...rawArgs) => {
 		const acceptsNamedConstraintOptions = options.descriptor.output.id === true || options.descriptor.output.unique === true;
 		const declaredArguments = options.descriptor.args ?? [];
-		if (acceptsNamedConstraintOptions && rawArgs.length > declaredArguments.length + 1) throw new Error(`${options.helperPath} expects at most ${declaredArguments.length + 1} argument(s), received ${rawArgs.length}`);
+		if (acceptsNamedConstraintOptions && rawArgs.length > declaredArguments.length + 1) throw contractError("CONTRACT.ARGUMENT_INVALID", `${options.helperPath} expects at most ${declaredArguments.length + 1} argument(s), received ${rawArgs.length}`, { meta: {
+			helperPath: options.helperPath,
+			expected: declaredArguments.length + 1,
+			received: rawArgs.length
+		} });
 		let args = rawArgs;
 		let namedConstraintOptions;
 		if (acceptsNamedConstraintOptions && rawArgs.length === declaredArguments.length + 1) {
 			const maybeNamedConstraintOptions = rawArgs.at(-1);
-			if (!isNamedConstraintOptionsLike(maybeNamedConstraintOptions)) throw new Error(`${options.helperPath} accepts an optional trailing { name?: string } constraint options object`);
+			if (!isNamedConstraintOptionsLike(maybeNamedConstraintOptions)) throw contractError("CONTRACT.ARGUMENT_INVALID", `${options.helperPath} accepts an optional trailing { name?: string } constraint options object`, { meta: { helperPath: options.helperPath } });
 			namedConstraintOptions = maybeNamedConstraintOptions;
 			args = rawArgs.slice(0, -1);
 		}
@@ -150,8 +158,8 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 	sql(spec) {
 		const idSpec = "id" in spec ? spec.id : void 0;
 		const uniqueSpec = "unique" in spec ? spec.unique : void 0;
-		if (idSpec && !this.state.id) throw new Error("field.sql({ id }) requires an existing inline .id(...) declaration.");
-		if (uniqueSpec && !this.state.unique) throw new Error("field.sql({ unique }) requires an existing inline .unique(...) declaration.");
+		if (idSpec && !this.state.id) throw contractError("CONTRACT.ARGUMENT_INVALID", "field.sql({ id }) requires an existing inline .id(...) declaration.");
+		if (uniqueSpec && !this.state.unique) throw contractError("CONTRACT.ARGUMENT_INVALID", "field.sql({ unique }) requires an existing inline .unique(...) declaration.");
 		return new ScalarFieldBuilder(blindCast({
 			...this.state,
 			...spec.column ? { columnName: spec.column } : {},
@@ -179,7 +187,7 @@ var EnumScalarFieldBuilder = class EnumScalarFieldBuilder extends ScalarFieldBui
 		}, this.#handle));
 	}
 	defaultSql(_expression) {
-		throw new Error("defaultSql is not available on an enum field; use .default(members.X) instead");
+		throw contractError("CONTRACT.DEFAULT_INVALID", "defaultSql is not available on an enum field; use .default(members.X) instead", { meta: { reason: "defaultSql-on-enum-field" } });
 	}
 };
 function columnField(descriptor) {
@@ -230,7 +238,7 @@ var RelationBuilder = class RelationBuilder {
 		this.state = state;
 	}
 	sql(spec) {
-		if (this.state.kind !== "belongsTo") throw new Error("relation.sql(...) is only supported for belongsTo relations.");
+		if (this.state.kind !== "belongsTo") throw contractError("CONTRACT.RELATION_INVALID", "relation.sql(...) is only supported for belongsTo relations.", { meta: { relationKind: this.state.kind } });
 		return new RelationBuilder({
 			...this.state,
 			sql: spec
@@ -246,11 +254,18 @@ function normalizeFieldRefInput(input) {
 function normalizeTargetFieldRefInput(input) {
 	const refs = Array.isArray(input) ? input : [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)");
+	if (!first) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", "Expected at least one target ref", { meta: { reason: "empty-target-refs" } });
+	if (refs.some((ref) => ref.modelName !== first.modelName)) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", "All target refs in a foreign key must point to the same model", { meta: {
+		mismatch: "modelName",
+		models: refs.map((ref) => ref.modelName)
+	} });
+	if (refs.some((ref) => ref.spaceId !== first.spaceId)) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", `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>"}")`, { meta: {
+		mismatch: "spaceId",
+		first: first.spaceId,
+		second: refs.find((r) => r.spaceId !== first.spaceId)?.spaceId
+	} });
+	if (refs.some((ref) => ref.namespaceId !== first.namespaceId)) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", "All target refs in a compound foreign key must share the same namespaceId (found mismatch)", { meta: { mismatch: "namespaceId" } });
+	if (refs.some((ref) => ref.tableName !== first.tableName)) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", "All target refs in a compound foreign key must share the same tableName (found mismatch)", { meta: { mismatch: "tableName" } });
 	return {
 		modelName: first.modelName,
 		fieldNames: refs.map((ref) => ref.columnName ?? ref.fieldName),
@@ -392,7 +407,7 @@ var ContractModelBuilder = class ContractModelBuilder {
 	}
 	ref(fieldName) {
 		const modelName = this.stageOne.modelName;
-		if (!modelName) throw new Error("Model tokens require model(\"ModelName\", ...) before calling .ref(...)");
+		if (!modelName) throw contractError("CONTRACT.MODEL_TOKEN_INVALID", "Model tokens require model(\"ModelName\", ...) before calling .ref(...)");
 		return {
 			kind: "targetFieldRef",
 			source: "token",
@@ -402,7 +417,11 @@ var ContractModelBuilder = class ContractModelBuilder {
 	}
 	relations(relations) {
 		const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
-		if (duplicateRelationName) throw new Error(`Model "${this.stageOne.modelName ?? "<anonymous>"}" already defines relation "${duplicateRelationName}".`);
+		if (duplicateRelationName) throw contractError("CONTRACT.NAME_DUPLICATE", `Model "${this.stageOne.modelName ?? "<anonymous>"}" already defines relation "${duplicateRelationName}".`, { meta: {
+			kind: "relation",
+			name: duplicateRelationName,
+			modelName: this.stageOne.modelName
+		} });
 		return new ContractModelBuilder({
 			...this.stageOne,
 			relations: {
@@ -438,7 +457,7 @@ function isLazyRelationModelName(value) {
 }
 function resolveNamedModelTokenName(token) {
 	const modelName = token.stageOne.modelName;
-	if (!modelName) throw new Error("Relation targets require named model tokens. Use model(\"ModelName\", ...) before passing a token to rel.*(...).");
+	if (!modelName) throw contractError("CONTRACT.MODEL_TOKEN_INVALID", "Relation targets require named model tokens. Use model(\"ModelName\", ...) before passing a token to rel.*(...).");
 	return modelName;
 }
 function normalizeRelationModelSource(target) {
@@ -460,7 +479,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.");
+	if (!input) throw contractError("CONTRACT.ARGUMENT_INVALID", "model(\"ModelName\", ...) requires a model definition.");
 	return new ContractModelBuilder({
 		...typeof modelNameOrInput === "string" ? { modelName: modelNameOrInput } : {},
 		...input.namespace !== void 0 ? { namespace: input.namespace } : {},
@@ -632,7 +651,10 @@ const RESERVED_HELPER_KEYS = [
 ];
 function assertNoBuiltInEntityCollisions(namespace) {
 	const collisions = Object.keys(namespace).filter((name) => RESERVED_HELPER_KEYS.includes(name));
-	if (collisions.length > 0) throw new Error(`Pack-contributed entity type(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the reserved built-in helper key(s) on the composed helpers surface. Reserved keys: ${RESERVED_HELPER_KEYS.map((k) => `"${k}"`).join(", ")}.`);
+	if (collisions.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack-contributed entity type(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the reserved built-in helper key(s) on the composed helpers surface. Reserved keys: ${RESERVED_HELPER_KEYS.map((k) => `"${k}"`).join(", ")}.`, { meta: {
+		collisions,
+		reservedKeys: RESERVED_HELPER_KEYS
+	} });
 }
 function createComposedFieldHelpers(fieldNamespace) {
 	const helperNamespace = createFieldHelpersFromNamespace(fieldNamespace, ({ helperPath, descriptor }) => createFieldPresetHelper({
@@ -646,14 +668,14 @@ function createComposedFieldHelpers(fieldNamespace) {
 		namedType: field.namedType
 	};
 	const coreHelperNames = new Set(Object.keys(coreFieldHelpers));
-	for (const helperName of Object.keys(helperNamespace)) if (coreHelperNames.has(helperName)) throw new Error(`Duplicate authoring field helper "${helperName}". Core field helpers reserve that name.`);
+	for (const helperName of Object.keys(helperNamespace)) if (coreHelperNames.has(helperName)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Duplicate authoring field helper "${helperName}". Core field helpers reserve that name.`, { meta: { helperName } });
 	return {
 		...coreFieldHelpers,
 		...helperNamespace
 	};
 }
 function createComposedAuthoringHelpers(options) {
-	const extensionValues = Object.values(options.extensionPacks ?? {});
+	const extensionValues = Object.values(options.extensions ?? {});
 	const components = [
 		options.family,
 		options.target,
@@ -785,27 +807,46 @@ function resolveFieldDescriptor(modelName, fieldName, fieldState, storageTypes,
 			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`);
+		if (!typeRef) throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" references a storage type instance that is not present in definition.types`, { meta: {
+			modelName,
+			fieldName,
+			reason: "instance-not-in-definition-types"
+		} });
 		const referencedType = storageTypes[typeRef];
-		if (!referencedType) throw new Error(`Field "${modelName}.${fieldName}" references unknown storage type "${typeRef}"`);
+		if (!referencedType) throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" references unknown storage type "${typeRef}"`, { meta: {
+			modelName,
+			fieldName,
+			typeRef
+		} });
 		return {
 			codecId: referencedType.codecId,
 			nativeType: referencedType.nativeType,
 			typeRef
 		};
 	}
-	throw new Error(`Field "${modelName}.${fieldName}" does not resolve to a storage descriptor`);
+	throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" does not resolve to a storage descriptor`, { meta: {
+		modelName,
+		fieldName,
+		reason: "unresolved-storage-descriptor"
+	} });
 }
 function mapFieldNamesToColumnNames(modelName, fieldNames, fieldToColumn) {
 	return fieldNames.map((fieldName) => {
 		const columnName = fieldToColumn[fieldName];
-		if (!columnName) throw new Error(`Unknown field "${modelName}.${fieldName}" in contract definition`);
+		if (!columnName) throw contractError("CONTRACT.FIELD_UNKNOWN", `Unknown field "${modelName}.${fieldName}" in contract definition`, { meta: {
+			modelName,
+			fieldName
+		} });
 		return columnName;
 	});
 }
 function assertRelationFieldArity(params) {
 	if (params.leftFields.length === params.rightFields.length) return;
-	throw new Error(`Relation "${params.modelName}.${params.relationName}" maps ${params.leftFields.length} ${params.leftLabel} field(s) to ${params.rightFields.length} ${params.rightLabel} field(s).`);
+	throw contractError("CONTRACT.RELATION_INVALID", `Relation "${params.modelName}.${params.relationName}" maps ${params.leftFields.length} ${params.leftLabel} field(s) to ${params.rightFields.length} ${params.rightLabel} field(s).`, { meta: {
+		modelName: params.modelName,
+		relationName: params.relationName,
+		reason: "field-count-mismatch"
+	} });
 }
 function resolveInlineIdConstraint(spec) {
 	const inlineIdFields = [];
@@ -817,7 +858,11 @@ function resolveInlineIdConstraint(spec) {
 		if (fieldState.id.name) idName = fieldState.id.name;
 	}
 	if (inlineIdFields.length === 0) return;
-	if (inlineIdFields.length > 1) throw new Error(`Model "${spec.modelName}" marks multiple fields with .id(). Use .attributes(...) for compound identities.`);
+	if (inlineIdFields.length > 1) throw contractError("CONTRACT.IDENTITY_INVALID", `Model "${spec.modelName}" marks multiple fields with .id(). Use .attributes(...) for compound identities.`, { meta: {
+		modelName: spec.modelName,
+		reason: "multiple-inline-ids",
+		fields: inlineIdFields
+	} });
 	const [inlineIdField] = inlineIdFields;
 	if (!inlineIdField) return;
 	return {
@@ -842,14 +887,20 @@ function collectInlineUniqueConstraints(spec) {
 function resolveModelIdConstraint(spec) {
 	const inlineId = resolveInlineIdConstraint(spec);
 	const attributeId = spec.attributesSpec?.id;
-	if (inlineId && attributeId) throw new Error(`Model "${spec.modelName}" defines identity both inline and in .attributes(...). Pick one identity style.`);
+	if (inlineId && attributeId) throw contractError("CONTRACT.IDENTITY_INVALID", `Model "${spec.modelName}" defines identity both inline and in .attributes(...). Pick one identity style.`, { meta: {
+		modelName: spec.modelName,
+		reason: "inline-and-attributes"
+	} });
 	const resolvedId = attributeId ?? inlineId;
-	if (resolvedId && resolvedId.fields.length === 0) throw new Error(`Model "${spec.modelName}" defines an empty identity. Add at least one field.`);
+	if (resolvedId && resolvedId.fields.length === 0) throw contractError("CONTRACT.IDENTITY_INVALID", `Model "${spec.modelName}" defines an empty identity. Add at least one field.`, { meta: {
+		modelName: spec.modelName,
+		reason: "empty-identity"
+	} });
 	return resolvedId;
 }
 function resolveModelUniqueConstraints(spec) {
 	const attributeUniques = spec.attributesSpec?.uniques ?? [];
-	for (const unique of attributeUniques) if (unique.fields.length === 0) throw new Error(`Model "${spec.modelName}" defines an empty unique constraint. Add at least one field.`);
+	for (const unique of attributeUniques) if (unique.fields.length === 0) throw contractError("CONTRACT.CONSTRAINT_INVALID", `Model "${spec.modelName}" defines an empty unique constraint. Add at least one field.`, { meta: { modelName: spec.modelName } });
 	return [...collectInlineUniqueConstraints(spec), ...attributeUniques];
 }
 function resolveRelationForeignKeys(spec, allSpecs) {
@@ -885,7 +936,11 @@ function resolveRelationForeignKeys(spec, allSpecs) {
 			});
 			continue;
 		}
-		if (!allSpecs.has(targetModelName)) throw new Error(`Relation "${spec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
+		if (!allSpecs.has(targetModelName)) throw contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${spec.modelName}.${relationName}" references unknown model "${targetModelName}"`, { meta: {
+			sourceModel: spec.modelName,
+			relationName,
+			targetModel: targetModelName
+		} });
 		const fields = normalizeRelationFieldNames(relation.from);
 		const targetFields = normalizeRelationFieldNames(relation.to);
 		assertRelationFieldArity({
@@ -914,9 +969,12 @@ function resolveRelationAnchorFields(spec) {
 	const idFields = spec.idConstraint?.fields;
 	if (idFields && idFields.length > 0) return idFields;
 	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`);
+	throw contractError("CONTRACT.IDENTITY_INVALID", `Model "${spec.modelName}" needs an explicit id or an "id" field to anchor non-owning relations`, { meta: {
+		modelName: spec.modelName,
+		reason: "missing-anchor-id"
+	} });
 }
-function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks) {
+function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensions) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
 	const fromFields = normalizeRelationFieldNames(relation.from);
 	const toFields = normalizeRelationFieldNames(relation.to);
@@ -929,7 +987,7 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, e
 		rightFields: toFields
 	});
 	if (relation.spaceId !== void 0) {
-		assertKnownExtensionPack(extensionPacks, relation.spaceId, `Relation "${currentSpec.modelName}.${relationName}"`);
+		assertKnownExtensionPack(extensions, relation.spaceId, `Relation "${currentSpec.modelName}.${relationName}"`);
 		const targetTable = relation.tableName ?? targetModelName.toLowerCase();
 		const parentColumns = mapFieldNamesToColumnNames(currentSpec.modelName, fromFields, currentSpec.fieldToColumn);
 		return {
@@ -948,7 +1006,11 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, e
 		};
 	}
 	const targetSpec = allSpecs.get(targetModelName);
-	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
+	if (!targetSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`, { meta: {
+		sourceModel: currentSpec.modelName,
+		relationName,
+		targetModel: targetModelName
+	} });
 	return {
 		fieldName: relationName,
 		toModel: targetModelName,
@@ -965,7 +1027,11 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, e
 function lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
 	const targetSpec = allSpecs.get(targetModelName);
-	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
+	if (!targetSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`, { meta: {
+		sourceModel: currentSpec.modelName,
+		relationName,
+		targetModel: targetModelName
+	} });
 	const parentFields = resolveRelationAnchorFields(currentSpec);
 	const childFields = normalizeRelationFieldNames(relation.by);
 	assertRelationFieldArity({
@@ -992,15 +1058,27 @@ function lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs
 function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
 	const targetSpec = allSpecs.get(targetModelName);
-	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
+	if (!targetSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`, { meta: {
+		sourceModel: currentSpec.modelName,
+		relationName,
+		targetModel: targetModelName
+	} });
 	const throughModelName = resolveRelationModelName(relation.through);
 	const throughSpec = allSpecs.get(throughModelName);
-	if (!throughSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown through model "${throughModelName}"`);
+	if (!throughSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${currentSpec.modelName}.${relationName}" references unknown through model "${throughModelName}"`, { meta: {
+		sourceModel: currentSpec.modelName,
+		relationName,
+		targetModel: throughModelName
+	} });
 	const currentAnchorFields = resolveRelationAnchorFields(currentSpec);
 	const targetAnchorFields = resolveRelationAnchorFields(targetSpec);
 	const throughFromFields = normalizeRelationFieldNames(relation.from);
 	const throughToFields = normalizeRelationFieldNames(relation.to);
-	if (currentAnchorFields.length !== throughFromFields.length || targetAnchorFields.length !== throughToFields.length) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" has mismatched many-to-many field counts.`);
+	if (currentAnchorFields.length !== throughFromFields.length || targetAnchorFields.length !== throughToFields.length) throw contractError("CONTRACT.RELATION_INVALID", `Relation "${currentSpec.modelName}.${relationName}" has mismatched many-to-many field counts.`, { meta: {
+		modelName: currentSpec.modelName,
+		relationName,
+		reason: "many-to-many-field-count-mismatch"
+	} });
 	return {
 		fieldName: relationName,
 		toModel: targetModelName,
@@ -1020,8 +1098,8 @@ function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs)
 		}
 	};
 }
-function resolveRelationNode(relationName, relation, currentSpec, allSpecs, extensionPacks) {
-	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks);
+function resolveRelationNode(relationName, relation, currentSpec, allSpecs, extensions) {
+	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensions);
 	if (relation.kind === "hasMany" || relation.kind === "hasOne") return lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs);
 	return lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs);
 }
@@ -1057,44 +1135,53 @@ function lowerCrossSpaceForeignKeyNode(spec, foreignKey) {
 		...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 assertKnownExtensionPack(extensions, spaceId, context) {
+	if (extensions !== void 0 && Object.hasOwn(extensions, spaceId)) return;
+	throw contractError("CONTRACT.PACK_MISSING", `${context} references contract space "${spaceId}" but "${spaceId}" is not declared in extensions. Add the pack to extensions.`, { meta: {
+		spaceId,
+		context
+	} });
 }
-function resolveForeignKeyNodes(spec, allSpecs, extensionPacks) {
+function resolveForeignKeyNodes(spec, allSpecs, extensions) {
 	const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
 		if (foreignKey.targetSpaceId !== void 0) {
-			assertKnownExtensionPack(extensionPacks, foreignKey.targetSpaceId, `Relation-derived foreign key on "${spec.modelName}"`);
+			assertKnownExtensionPack(extensions, 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}"`);
+		if (!targetSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`, { meta: {
+			sourceModel: spec.modelName,
+			targetModel: foreignKey.targetModel
+		} });
 		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}"`);
+			assertKnownExtensionPack(extensions, 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}"`);
+		if (!targetSpec) throw contractError("CONTRACT.MODEL_UNKNOWN", `Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`, { meta: {
+			sourceModel: spec.modelName,
+			targetModel: foreignKey.targetModel
+		} });
 		return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
 	});
 	return [...relationForeignKeys, ...sqlForeignKeys];
 }
-function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, extensionPacks) {
+function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, extensions) {
 	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}"`);
+		if (!columnName) throw new InternalError(`Column name resolution failed for "${spec.modelName}.${fieldName}"`);
 		const enumHandle = "typeRef" in fieldState && isEnumTypeHandle(fieldState.typeRef) ? fieldState.typeRef : void 0;
 		fields.push({
 			fieldName,
@@ -1118,8 +1205,8 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...ifDefined("type", index.type),
 		...ifDefined("options", index.options)
 	}));
-	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs, extensionPacks);
-	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs, extensionPacks));
+	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs, extensions);
+	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs, extensions));
 	return {
 		modelName: spec.modelName,
 		tableName: spec.tableName,
@@ -1144,21 +1231,34 @@ function collectRuntimeModelSpecs(definition) {
 	const tableOwners = /* @__PURE__ */ new Map();
 	for (const [modelName, modelDefinition] of Object.entries(models)) {
 		const tokenModelName = modelDefinition.stageOne.modelName;
-		if (tokenModelName && tokenModelName !== modelName) throw new Error(`Model token "${tokenModelName}" must be assigned to models.${tokenModelName}. Received models.${modelName}.`);
+		if (tokenModelName && tokenModelName !== modelName) throw contractError("CONTRACT.MODEL_TOKEN_INVALID", `Model token "${tokenModelName}" must be assigned to models.${tokenModelName}. Received models.${modelName}.`, { meta: {
+			tokenModelName,
+			assignedKey: modelName
+		} });
 		const attributesSpec = modelDefinition.buildAttributesSpec();
 		const sqlSpec = modelDefinition.buildSqlSpec();
 		const tableName = sqlSpec?.table ?? applyNaming(modelName, definition.naming?.tables);
 		const namespaceId = modelDefinition.stageOne.namespace ?? definition.target.defaultNamespaceId;
 		const tableKey = JSON.stringify([namespaceId, tableName]);
 		const existingModel = tableOwners.get(tableKey);
-		if (existingModel) throw new Error(`Models "${existingModel}" and "${modelName}" both map to table "${tableName}".`);
+		if (existingModel) throw contractError("CONTRACT.NAME_DUPLICATE", `Models "${existingModel}" and "${modelName}" both map to table "${tableName}".`, { meta: {
+			kind: "table",
+			name: tableName,
+			first: existingModel,
+			second: modelName
+		} });
 		tableOwners.set(tableKey, modelName);
 		const fieldToColumn = {};
 		const columnOwners = /* @__PURE__ */ new Map();
 		for (const [fieldName, fieldBuilder] of Object.entries(modelDefinition.stageOne.fields)) {
 			const columnName = fieldBuilder.build().columnName ?? applyNaming(fieldName, definition.naming?.columns);
 			const existingField = columnOwners.get(columnName);
-			if (existingField) throw new Error(`Model "${modelName}" maps both "${existingField}" and "${fieldName}" to column "${columnName}".`);
+			if (existingField) throw contractError("CONTRACT.NAME_DUPLICATE", `Model "${modelName}" maps both "${existingField}" and "${fieldName}" to column "${columnName}".`, { meta: {
+				kind: "column",
+				name: columnName,
+				first: existingField,
+				second: fieldName
+			} });
 			columnOwners.set(columnName, fieldName);
 			fieldToColumn[fieldName] = columnName;
 		}
@@ -1186,10 +1286,10 @@ function collectRuntimeModelSpecs(definition) {
 		modelSpecs
 	};
 }
-function lowerModels(collection, extensionPacks) {
+function lowerModels(collection, extensions) {
 	emitTypedCrossModelFallbackWarnings(collection);
 	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensionPacks));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensions));
 }
 /**
 * Kind-agnostic walk over the author-declared `entities` handle list:
@@ -1214,7 +1314,7 @@ function lowerModels(collection, extensionPacks) {
 function lowerPackEntityHandles(definition, modelSpecs) {
 	const entities = definition.entities;
 	if (entities === void 0 || entities.length === 0) return void 0;
-	const components = [definition.target, ...Object.values(definition.extensionPacks ?? {})];
+	const components = [definition.target, ...Object.values(definition.extensions ?? {})];
 	const owningComponent = /* @__PURE__ */ new Map();
 	const walkEntityTypes = (namespace, component) => {
 		for (const value of Object.values(namespace)) if (isAuthoringEntityTypeDescriptor(value)) owningComponent.set(value.discriminator, component);
@@ -1269,7 +1369,7 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 	const claimed = /* @__PURE__ */ new Map();
 	for (const handle of entities) {
 		const component = owningComponent.get(handle.entityKind);
-		if (component === void 0) throw new Error(`defineContract: entities contains a handle with entityKind "${handle.entityKind}", which no composed pack registers. Compose a pack whose entityTypes contribution claims "${handle.entityKind}", or remove the handle.`);
+		if (component === void 0) throw contractError("CONTRACT.ENTITY_KIND_UNKNOWN", `defineContract: entities contains a handle with entityKind "${handle.entityKind}", which no composed pack registers. Compose a pack whose entityTypes contribution claims "${handle.entityKind}", or remove the handle.`, { meta: { entityKind: handle.entityKind } });
 		const refs = {};
 		for (const [refName, refValue] of Object.entries(handle.refs ?? {})) refs[refName] = resolveRef(refValue);
 		const forComponent = claimed.get(component) ?? [];
@@ -1284,7 +1384,10 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 		const authoring = component.authoring;
 		if (!providesEntityHandleLowering(authoring)) {
 			const kinds = [...new Set(handles.map((entry) => entry.handle.entityKind))].sort();
-			throw new Error(`defineContract: entityKind(s) ${kinds.map((kind) => `"${kind}"`).join(", ")} are registered by a pack that does not implement entity-handle lowering (no lowerEntityHandles on its authoring contributions).`);
+			throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `defineContract: entityKind(s) ${kinds.map((kind) => `"${kind}"`).join(", ")} are registered by a pack that does not implement entity-handle lowering (no lowerEntityHandles on its authoring contributions).`, { meta: {
+				entityKinds: kinds,
+				reason: "missing-lowerEntityHandles"
+			} });
 		}
 		for (const row of authoring.lowerEntityHandles({
 			handles,
@@ -1295,7 +1398,11 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 			const forKind = forNamespace[row.entityKind] ?? {};
 			forNamespace[row.entityKind] = forKind;
 			const existing = forKind[row.key];
-			if (existing !== void 0 && existing !== row.entity) throw new Error(`defineContract: two different "${row.entityKind}" entities named "${row.key}" in namespace "${row.namespaceId}" — pack-entity names must be unique per namespace.`);
+			if (existing !== void 0 && existing !== row.entity) throw contractError("CONTRACT.NAME_DUPLICATE", `defineContract: two different "${row.entityKind}" entities named "${row.key}" in namespace "${row.namespaceId}" — pack-entity names must be unique per namespace.`, { meta: {
+				kind: row.entityKind,
+				name: row.key,
+				namespaceId: row.namespaceId
+			} });
 			forKind[row.key] = row.entity;
 		}
 	}
@@ -1303,12 +1410,12 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 }
 function buildContractDefinition(definition) {
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerModels(collection, definition.extensionPacks);
+	const models = lowerModels(collection, definition.extensions);
 	const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
 	return {
 		target: definition.target,
 		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
-		...definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {},
+		...definition.extensions ? { extensions: definition.extensions } : {},
 		...definition.storageHash ? { storageHash: definition.storageHash } : {},
 		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
 		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
@@ -1322,8 +1429,16 @@ function buildContractDefinition(definition) {
 //#endregion
 //#region src/contract-builder.ts
 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}".`);
+	if (family.familyId !== "sql") throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `defineContract only accepts SQL family packs. Received family "${family.familyId}".`, { meta: {
+		packId: family.id,
+		packFamilyId: family.familyId,
+		contractFamilyId: "sql"
+	} });
+	if (target.familyId !== family.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`, { meta: {
+		packId: target.id,
+		packFamilyId: target.familyId,
+		contractFamilyId: family.familyId
+	} });
 }
 /**
 * Per-target reserved namespace names enforced by `defineContract` for
@@ -1342,14 +1457,32 @@ function validateTargetPackRef(family, target) {
 */
 function validateNamespaceDeclarations(target, namespaces) {
 	if (!namespaces) return;
-	if (target.targetId === "sqlite" && namespaces.length > 0) throw new Error(`defineContract: SQLite contracts cannot declare namespaces (SQLite has no schema concept; emitted DDL is always unqualified). Received namespaces: [${namespaces.map((name) => `"${name}"`).join(", ")}].`);
+	if (target.targetId === "sqlite" && namespaces.length > 0) throw contractError("CONTRACT.NAMESPACE_UNSUPPORTED", `defineContract: SQLite contracts cannot declare namespaces (SQLite has no schema concept; emitted DDL is always unqualified). Received namespaces: [${namespaces.map((name) => `"${name}"`).join(", ")}].`, { meta: {
+		namespaces,
+		targetId: target.targetId
+	} });
 	const seen = /* @__PURE__ */ new Set();
 	for (const namespace of namespaces) {
-		if (namespace.length === 0) throw new Error("defineContract: namespace names cannot be empty.");
-		if (namespace.trim().length === 0) throw new Error(`defineContract: namespace name "${namespace}" cannot be whitespace-only.`);
-		if (namespace === "__unbound__" || namespace === "__unspecified__") throw new Error(`defineContract: namespace name "${namespace}" is a reserved IR sentinel and cannot appear in the declared namespaces list.`);
-		if (target.targetId === "postgres" && namespace === "unbound") throw new Error(`defineContract: namespace name "unbound" is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead of declaring it as a regular schema).`);
-		if (seen.has(namespace)) throw new Error(`defineContract: namespaces list contains duplicate entry "${namespace}".`);
+		if (namespace.length === 0) throw contractError("CONTRACT.NAMESPACE_INVALID", "defineContract: namespace names cannot be empty.", { meta: {
+			namespace,
+			reason: "empty"
+		} });
+		if (namespace.trim().length === 0) throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: namespace name "${namespace}" cannot be whitespace-only.`, { meta: {
+			namespace,
+			reason: "whitespace-only"
+		} });
+		if (namespace === "__unbound__" || namespace === "__unspecified__") throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: namespace name "${namespace}" is a reserved IR sentinel and cannot appear in the declared namespaces list.`, { meta: {
+			namespace,
+			reason: "reserved-ir-sentinel"
+		} });
+		if (target.targetId === "postgres" && namespace === "unbound") throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: namespace name "unbound" is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead of declaring it as a regular schema).`, { meta: {
+			namespace,
+			reason: "reserved-by-postgres"
+		} });
+		if (seen.has(namespace)) throw contractError("CONTRACT.NAME_DUPLICATE", `defineContract: namespaces list contains duplicate entry "${namespace}".`, { meta: {
+			kind: "namespace",
+			name: namespace
+		} });
 		seen.add(namespace);
 	}
 }
@@ -1379,26 +1512,50 @@ function validatePerModelNamespaces(target, namespaces, models) {
 	for (const [modelKey, modelBuilder] of Object.entries(models)) {
 		const perModelNamespace = modelBuilder.stageOne.namespace;
 		if (perModelNamespace === void 0) continue;
-		if (target.targetId === "sqlite") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is SQLite (SQLite has no schema concept; remove the per-model \`namespace\` field).`);
-		if (perModelNamespace === "__unbound__" || perModelNamespace === "__unspecified__") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is a reserved IR sentinel and cannot appear in user code.`);
-		if (target.targetId === "postgres" && perModelNamespace === "unbound") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "unbound"\` but that name is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`);
-		if (!declaredNamespaces.has(perModelNamespace)) {
-			const hint = declaredNamespaces.size > 0 ? ` Declared namespaces: [${[...declaredNamespaces].map((name) => `"${name}"`).join(", ")}].` : " The contract does not declare any namespaces; add `namespaces: [\"…\"]` to `defineContract` first.";
-			throw new Error(`defineContract: model "${modelKey}" references namespace "${perModelNamespace}" but that name does not appear in the contract's declared \`namespaces\` list.${hint}`);
-		}
+		if (target.targetId === "sqlite") throw contractError("CONTRACT.NAMESPACE_UNSUPPORTED", `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is SQLite (SQLite has no schema concept; remove the per-model \`namespace\` field).`, { meta: {
+			modelKey,
+			namespace: perModelNamespace,
+			targetId: target.targetId
+		} });
+		if (perModelNamespace === "__unbound__" || perModelNamespace === "__unspecified__") throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is a reserved IR sentinel and cannot appear in user code.`, { meta: {
+			modelKey,
+			namespace: perModelNamespace,
+			reason: "reserved-ir-sentinel"
+		} });
+		if (target.targetId === "postgres" && perModelNamespace === "unbound") throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: model "${modelKey}" sets \`namespace: "unbound"\` but that name is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`, { meta: {
+			modelKey,
+			namespace: perModelNamespace,
+			reason: "reserved-by-postgres"
+		} });
+		if (!declaredNamespaces.has(perModelNamespace)) throw contractError("CONTRACT.NAMESPACE_UNKNOWN", `defineContract: model "${modelKey}" references namespace "${perModelNamespace}" but that name does not appear in the contract's declared \`namespaces\` list.${declaredNamespaces.size > 0 ? ` Declared namespaces: [${[...declaredNamespaces].map((name) => `"${name}"`).join(", ")}].` : " The contract does not declare any namespaces; add `namespaces: [\"…\"]` to `defineContract` first."}`, { meta: {
+			modelKey,
+			namespace: perModelNamespace,
+			declared: [...declaredNamespaces]
+		} });
 	}
 }
-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}".`);
+function validateExtensionPackRefs(target, extensions) {
+	if (!extensions) return;
+	for (const packRef of Object.values(extensions)) {
+		if (packRef.kind !== "extension") throw contractError("CONTRACT.PACK_REF_INVALID", `defineContract only accepts extension pack refs in extensions. Received kind "${packRef.kind}".`, { meta: {
+			packId: packRef.id,
+			kind: packRef.kind
+		} });
+		if (packRef.familyId !== target.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `extension pack "${packRef.id}" targets family "${packRef.familyId}" but contract target family is "${target.familyId}".`, { meta: {
+			packId: packRef.id,
+			packFamilyId: packRef.familyId,
+			contractFamilyId: target.familyId
+		} });
+		if (packRef.targetId && packRef.targetId !== target.targetId) throw contractError("CONTRACT.PACK_TARGET_MISMATCH", `extension pack "${packRef.id}" targets "${packRef.targetId}" but contract target is "${target.targetId}".`, { meta: {
+			packId: packRef.id,
+			packTargetId: packRef.targetId,
+			contractTargetId: target.targetId
+		} });
 	}
 }
 function buildContractFromDsl(definition) {
 	validateTargetPackRef(definition.family, definition.target);
-	validateExtensionPackRefs(definition.target, definition.extensionPacks);
+	validateExtensionPackRefs(definition.target, definition.extensions);
 	validateNamespaceDeclarations(definition.target, definition.namespaces);
 	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
 	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
@@ -1414,7 +1571,7 @@ function buildBoundContract(family, target, definition, factory) {
 		const built = factory(createComposedAuthoringHelpers({
 			family,
 			target,
-			extensionPacks: definition.extensionPacks
+			extensions: definition.extensions
 		}));
 		const mergedEnums = {
 			...definition.enums ?? {},