@prisma/orm-family-sql 0.16.0-dev.36

package/dist/contract-builder-YjMQcvZ1.mjs

@@ -0,0 +1,1615 @@
+import { t as providesEntityHandleLowering } from "./entity-handle-lowering-hook-DwLIKNiS.mjs";
+import { u as toStorageTypeInstance } from "./types-CMMQS6aG.mjs";
+import { n as contractError, t as buildSqlContractFromDefinition } from "./build-contract-DBCz_YSs-DO0wMHai.mjs";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { isColumnDefault } from "@prisma/orm-framework/contract/types";
+import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { bindEnumType, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member } from "@prisma/orm-framework/contract-authoring";
+//#region ../../../2-sql/2-authoring/contract-ts/dist/contract-builder.mjs
+function isNamedConstraintOptionsLike(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (Object.keys(value).some((key) => key !== "name")) return false;
+	const name = value.name;
+	return name === void 0 || typeof name === "string";
+}
+const blockedSegments = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function assertSafeHelperKey(key, path) {
+	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 = {};
+	for (const [key, value] of Object.entries(namespace)) {
+		assertSafeHelperKey(key, path);
+		const currentPath = [...path, key];
+		if (isAuthoringTypeConstructorDescriptor(value)) {
+			const helperPath = currentPath.join(".");
+			helpers[key] = (...args) => {
+				validateAuthoringHelperArguments(helperPath, value.args, args);
+				const triple = instantiateAuthoringTypeConstructor(value, args);
+				return toStorageTypeInstance({
+					codecId: triple.codecId,
+					nativeType: triple.nativeType,
+					typeParams: triple.typeParams ?? {}
+				});
+			};
+			continue;
+		}
+		helpers[key] = createTypeHelpersFromNamespace(value, currentPath);
+	}
+	return helpers;
+}
+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 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 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);
+		}
+		validateAuthoringHelperArguments(options.helperPath, options.descriptor.args, args);
+		return options.build({
+			args,
+			...namedConstraintOptions ? { namedConstraintOptions } : {}
+		});
+	};
+}
+function createFieldHelpersFromNamespace(namespace, createLeafHelper, path = []) {
+	const helpers = {};
+	for (const [key, value] of Object.entries(namespace)) {
+		assertSafeHelperKey(key, path);
+		const currentPath = [...path, key];
+		if (isAuthoringFieldPresetDescriptor(value)) {
+			helpers[key] = createLeafHelper({
+				helperPath: currentPath.join("."),
+				descriptor: value
+			});
+			continue;
+		}
+		helpers[key] = createFieldHelpersFromNamespace(value, createLeafHelper, currentPath);
+	}
+	return helpers;
+}
+function toColumnDefault(value) {
+	if (isColumnDefault(value)) return value;
+	return {
+		kind: "literal",
+		value
+	};
+}
+var ScalarFieldBuilder = class ScalarFieldBuilder {
+	state;
+	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(blindCast({
+			...this.state,
+			nullable: true
+		}));
+	}
+	column(name) {
+		return new ScalarFieldBuilder(blindCast({
+			...this.state,
+			columnName: name
+		}));
+	}
+	many() {
+		return new ScalarFieldBuilder(blindCast({
+			...this.state,
+			many: true
+		}));
+	}
+	default(value) {
+		return new ScalarFieldBuilder({
+			...this.state,
+			default: toColumnDefault(value)
+		});
+	}
+	defaultSql(expression) {
+		return new ScalarFieldBuilder({
+			...this.state,
+			default: {
+				kind: "function",
+				expression
+			}
+		});
+	}
+	id(options) {
+		return new ScalarFieldBuilder(blindCast({
+			...this.state,
+			id: options?.name ? { name: options.name } : {}
+		}));
+	}
+	unique(options) {
+		return new ScalarFieldBuilder(blindCast({
+			...this.state,
+			unique: options?.name ? { name: options.name } : {}
+		}));
+	}
+	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 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 } : {},
+			...idSpec ? { id: { name: idSpec.name } } : {},
+			...uniqueSpec ? { unique: { name: uniqueSpec.name } } : {}
+		}));
+	}
+	build() {
+		return this.state;
+	}
+};
+var EnumScalarFieldBuilder = class EnumScalarFieldBuilder extends ScalarFieldBuilder {
+	#handle;
+	constructor(state, handle) {
+		super(state);
+		this.#handle = handle;
+	}
+	default(value) {
+		return blindCast(new EnumScalarFieldBuilder({
+			...this.build(),
+			default: {
+				kind: "literal",
+				value
+			}
+		}, this.#handle));
+	}
+	defaultSql(_expression) {
+		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) {
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor,
+		nullable: false
+	});
+}
+function generatedField(spec) {
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor: {
+			...spec.type,
+			...spec.typeParams ? { typeParams: spec.typeParams } : {}
+		},
+		nullable: false,
+		executionDefaults: { onCreate: spec.generated }
+	});
+}
+function namedTypeField(typeRef) {
+	if (isEnumTypeHandle(typeRef)) return new EnumScalarFieldBuilder(blindCast({
+		kind: "scalar",
+		typeRef,
+		nullable: false
+	}), typeRef);
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		typeRef,
+		nullable: false
+	});
+}
+function buildFieldPreset(descriptor, args, namedConstraintOptions) {
+	const preset = instantiateAuthoringFieldPreset(descriptor, args);
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor: preset.descriptor,
+		nullable: preset.nullable,
+		...ifDefined("default", preset.default),
+		...ifDefined("executionDefaults", preset.executionDefaults),
+		...preset.id ? { id: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {} } : {},
+		...preset.unique ? { unique: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {} } : {}
+	});
+}
+var RelationBuilder = class RelationBuilder {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	sql(spec) {
+		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
+		});
+	}
+	build() {
+		return this.state;
+	}
+};
+function normalizeFieldRefInput(input) {
+	return (Array.isArray(input) ? input : [input]).map((ref) => ref.fieldName);
+}
+function normalizeTargetFieldRefInput(input) {
+	const refs = Array.isArray(input) ? input : [input];
+	const [first] = refs;
+	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),
+		source: refs.some((ref) => ref.source === "string") ? "string" : "token",
+		spaceId: first.spaceId,
+		namespaceId: first.namespaceId,
+		tableName: first.tableName
+	};
+}
+function createConstraintsDsl() {
+	function ref(modelName, fieldName) {
+		return {
+			kind: "targetFieldRef",
+			source: "string",
+			modelName,
+			fieldName
+		};
+	}
+	function id(fieldOrFields, options) {
+		return {
+			kind: "id",
+			fields: normalizeFieldRefInput(fieldOrFields),
+			...options?.name ? { name: options.name } : {}
+		};
+	}
+	function unique(fieldOrFields, options) {
+		return {
+			kind: "unique",
+			fields: normalizeFieldRefInput(fieldOrFields),
+			...options?.name ? { name: options.name } : {}
+		};
+	}
+	function index(fieldsOrOptions, options) {
+		const isExpressionForm = !Array.isArray(fieldsOrOptions) && typeof fieldsOrOptions === "object" && "expression" in fieldsOrOptions;
+		const opts = isExpressionForm ? fieldsOrOptions : options;
+		const carried = {
+			kind: "index",
+			...opts?.name !== void 0 ? { name: opts.name } : {},
+			...opts?.map !== void 0 ? { map: opts.map } : {},
+			...opts?.where !== void 0 ? { where: opts.where } : {},
+			...opts?.unique !== void 0 ? { unique: opts.unique } : {},
+			...opts?.type !== void 0 ? { type: opts.type } : {},
+			...opts?.options !== void 0 ? { options: blindCast(opts.options) } : {}
+		};
+		return isExpressionForm ? {
+			...carried,
+			expression: fieldsOrOptions.expression
+		} : {
+			...carried,
+			fields: normalizeFieldRefInput(fieldsOrOptions)
+		};
+	}
+	function foreignKey(fieldOrFields, target, options) {
+		const normalizedTarget = normalizeTargetFieldRefInput(target);
+		return {
+			kind: "fk",
+			fields: normalizeFieldRefInput(fieldOrFields),
+			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 } : {},
+			...options?.constraint !== void 0 ? { constraint: options.constraint } : {},
+			...options?.index !== void 0 ? { index: options.index } : {}
+		};
+	}
+	return {
+		ref,
+		id,
+		unique,
+		index,
+		foreignKey
+	};
+}
+function createFieldRefs(fields) {
+	const refs = {};
+	for (const fieldName of Object.keys(fields)) refs[fieldName] = {
+		kind: "columnRef",
+		fieldName
+	};
+	return refs;
+}
+function createModelTokenRefs(modelName, fields, crossSpaceCoordinate) {
+	const refs = {};
+	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) {
+	if (typeof stageInput === "function") return stageInput(context);
+	return stageInput;
+}
+function createAttributeConstraintsDsl() {
+	const constraints = createConstraintsDsl();
+	return {
+		id: constraints.id,
+		unique: constraints.unique
+	};
+}
+function createSqlConstraintsDsl() {
+	const constraints = createConstraintsDsl();
+	return {
+		index: constraints.index,
+		foreignKey: constraints.foreignKey,
+		ref: constraints.ref
+	};
+}
+function createColumnRefs(fields) {
+	return createFieldRefs(fields);
+}
+function findDuplicateRelationName(existingRelations, nextRelations) {
+	return Object.keys(nextRelations).find((relationName) => Object.hasOwn(existingRelations, relationName));
+}
+var ContractModelBuilder = class ContractModelBuilder {
+	stageOne;
+	attributesFactory;
+	sqlFactory;
+	spaceId;
+	tableName;
+	refs;
+	constructor(stageOne, attributesFactory, sqlFactory, spaceId, tableName) {
+		this.stageOne = stageOne;
+		this.attributesFactory = attributesFactory;
+		this.sqlFactory = sqlFactory;
+		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;
+		if (!modelName) throw contractError("CONTRACT.MODEL_TOKEN_INVALID", "Model tokens require model(\"ModelName\", ...) before calling .ref(...)");
+		return {
+			kind: "targetFieldRef",
+			source: "token",
+			modelName,
+			fieldName
+		};
+	}
+	relations(relations) {
+		const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
+		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: {
+				...this.stageOne.relations,
+				...relations
+			}
+		}, this.attributesFactory, this.sqlFactory, this.spaceId, this.tableName);
+	}
+	attributes(specOrFactory) {
+		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory, this.spaceId, this.tableName);
+	}
+	sql(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;
+		return buildStageSpec(this.attributesFactory, {
+			fields: createFieldRefs(this.stageOne.fields),
+			constraints: createAttributeConstraintsDsl()
+		});
+	}
+	buildSqlSpec() {
+		if (!this.sqlFactory) return;
+		return buildStageSpec(this.sqlFactory, {
+			cols: createColumnRefs(this.stageOne.fields),
+			constraints: createSqlConstraintsDsl()
+		});
+	}
+};
+function isLazyRelationModelName(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "lazyRelationModelName" && "resolve" in value && typeof value.resolve === "function";
+}
+function resolveNamedModelTokenName(token) {
+	const modelName = token.stageOne.modelName;
+	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) {
+	if (typeof target === "string") return {
+		kind: "relationModelName",
+		source: "string",
+		modelName: target
+	};
+	if (typeof target === "function") return {
+		kind: "lazyRelationModelName",
+		source: "lazyToken",
+		resolve: () => resolveNamedModelTokenName(target())
+	};
+	return {
+		kind: "relationModelName",
+		source: "token",
+		modelName: resolveNamedModelTokenName(target)
+	};
+}
+function model(modelNameOrInput, maybeInput) {
+	const input = typeof modelNameOrInput === "string" ? maybeInput : modelNameOrInput;
+	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 } : {},
+		fields: input.fields,
+		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,
+		...crossSpaceCoordinate !== void 0 ? crossSpaceCoordinate : {}
+	});
+}
+function hasMany(toModel, options) {
+	return new RelationBuilder({
+		kind: "hasMany",
+		toModel: normalizeRelationModelSource(toModel),
+		by: options.by
+	});
+}
+function hasOne(toModel, options) {
+	return new RelationBuilder({
+		kind: "hasOne",
+		toModel: normalizeRelationModelSource(toModel),
+		by: options.by
+	});
+}
+function manyToMany(toModel, options) {
+	return new RelationBuilder({
+		kind: "manyToMany",
+		toModel: normalizeRelationModelSource(toModel),
+		through: normalizeRelationModelSource(options.through),
+		from: options.from,
+		to: options.to
+	});
+}
+const rel = {
+	belongsTo,
+	hasMany,
+	hasOne,
+	manyToMany
+};
+const field = {
+	column: columnField,
+	generated: generatedField,
+	namedType: namedTypeField
+};
+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;
+	return typeof target === "object" && target !== null && "kind" in target && target.kind === "target" && typeof family === "object" && family !== null && "kind" in family && family.kind === "family";
+}
+function isRelationFieldArray(value) {
+	return Array.isArray(value);
+}
+function normalizeRelationFieldNames(value) {
+	if (isRelationFieldArray(value)) return value;
+	return [value];
+}
+function resolveRelationModelName(value) {
+	if (isLazyRelationModelName(value)) return value.resolve();
+	return value.modelName;
+}
+function applyNaming(name, strategy) {
+	if (!strategy || strategy === "identity") return name;
+	let result = "";
+	for (let index = 0; index < name.length; index += 1) {
+		const char = name[index];
+		if (!char) continue;
+		const lower = char.toLowerCase();
+		if (char !== lower && index > 0) {
+			const prev = name[index - 1];
+			const next = name[index + 1];
+			const prevIsLower = !!prev && prev === prev.toLowerCase();
+			const nextIsLower = !!next && next === next.toLowerCase();
+			if (prevIsLower || nextIsLower) result += "_";
+		}
+		result += lower;
+	}
+	return result;
+}
+function extractTypeNamespace(pack) {
+	return pack.authoring?.type ?? {};
+}
+function extractFieldNamespace(pack) {
+	return pack.authoring?.field ?? {};
+}
+function extractEntitiesNamespace(pack) {
+	return pack.authoring?.entityTypes ?? {};
+}
+function composeTypeNamespace(components) {
+	const merged = {};
+	for (const component of components) {
+		const ns = extractTypeNamespace(component);
+		if (Object.keys(ns).length > 0) mergeAuthoringNamespaces(merged, ns, [], "typeConstructor", "type");
+	}
+	return merged;
+}
+function composeFieldNamespace(components) {
+	const merged = {};
+	for (const component of components) {
+		const ns = extractFieldNamespace(component);
+		if (Object.keys(ns).length > 0) mergeAuthoringNamespaces(merged, ns, [], "fieldPreset", "field");
+	}
+	return merged;
+}
+function composeEntityNamespace(components) {
+	const merged = {};
+	for (const component of components) {
+		const ns = extractEntitiesNamespace(component);
+		if (Object.keys(ns).length > 0) mergeAuthoringNamespaces(merged, ns, [], "entity", "entity");
+	}
+	return merged;
+}
+/**
+* Reserved top-level keys on the composed helpers surface — the
+* built-in `model` / `rel` helpers, the `field` / `type` namespace
+* objects. Pack-contributed entity types are flattened to the same
+* top-level shape (e.g. `helpers.enum({...})`), so a pack cannot
+* contribute an entity type whose name collides with one of these
+* reserved keys without silently overwriting at runtime. Detect the
+* collision at compose time and fail loudly with a guidance message.
+*/
+const RESERVED_HELPER_KEYS = [
+	"field",
+	"model",
+	"rel",
+	"type"
+];
+function assertNoBuiltInEntityCollisions(namespace) {
+	const collisions = Object.keys(namespace).filter((name) => RESERVED_HELPER_KEYS.includes(name));
+	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({
+		helperPath,
+		descriptor,
+		build: ({ args, namedConstraintOptions }) => buildFieldPreset(descriptor, args, namedConstraintOptions)
+	}));
+	const coreFieldHelpers = {
+		column: field.column,
+		generated: field.generated,
+		namedType: field.namedType
+	};
+	const coreHelperNames = new Set(Object.keys(coreFieldHelpers));
+	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.extensions ?? {});
+	const components = [
+		options.family,
+		options.target,
+		...extensionValues
+	];
+	const typeNamespace = composeTypeNamespace(components);
+	const fieldNamespace = composeFieldNamespace(components);
+	const entityNamespace = composeEntityNamespace(components);
+	assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityNamespace);
+	assertNoBuiltInEntityCollisions(entityNamespace);
+	return {
+		...createEntityHelpersFromNamespace(entityNamespace, { ctx: {
+			family: options.family.familyId,
+			target: options.target.targetId
+		} }),
+		field: createComposedFieldHelpers(fieldNamespace),
+		model,
+		rel,
+		type: createTypeHelpersFromNamespace(typeNamespace)
+	};
+}
+function hasNamedModelToken(models, modelName) {
+	return models[modelName]?.stageOne.modelName === modelName;
+}
+function formatFieldSelection(fieldNames) {
+	if (fieldNames.length === 1) return `'${fieldNames[0]}'`;
+	return `[${fieldNames.map((fieldName) => `'${fieldName}'`).join(", ")}]`;
+}
+function formatTokenFieldSelection(modelName, fieldNames) {
+	if (fieldNames.length === 1) return `${modelName}.refs.${fieldNames[0]}`;
+	return `[${fieldNames.map((fieldName) => `${modelName}.refs.${fieldName}`).join(", ")}]`;
+}
+function formatConstraintsRefCall(modelName, fieldNames) {
+	if (fieldNames.length === 1) return `constraints.ref('${modelName}', '${fieldNames[0]}')`;
+	return `[${fieldNames.map((fieldName) => `constraints.ref('${modelName}', '${fieldName}')`).join(", ")}]`;
+}
+function formatRelationModelDisplay(relationModel) {
+	if (relationModel.kind === "lazyRelationModelName") return `() => ${relationModel.resolve()}`;
+	return relationModel.source === "string" ? `'${relationModel.modelName}'` : relationModel.modelName;
+}
+function formatRelationCall(relation, targetModelDisplay) {
+	if (relation.kind === "belongsTo") return `rel.belongsTo(${targetModelDisplay}, { from: ${formatFieldSelection(normalizeRelationFieldNames(relation.from))}, to: ${formatFieldSelection(normalizeRelationFieldNames(relation.to))} })`;
+	if (relation.kind === "hasMany" || relation.kind === "hasOne") {
+		const by = formatFieldSelection(normalizeRelationFieldNames(relation.by));
+		return `rel.${relation.kind}(${targetModelDisplay}, { by: ${by} })`;
+	}
+	return `rel.manyToMany(${targetModelDisplay}, { through: ${formatRelationModelDisplay(relation.through)}, from: ${formatFieldSelection(normalizeRelationFieldNames(relation.from))}, to: ${formatFieldSelection(normalizeRelationFieldNames(relation.to))} })`;
+}
+function formatManyToManyCallWithThrough(relation, throughDisplay) {
+	return `rel.manyToMany(${formatRelationModelDisplay(relation.toModel)}, { through: ${throughDisplay}, from: ${formatFieldSelection(normalizeRelationFieldNames(relation.from))}, to: ${formatFieldSelection(normalizeRelationFieldNames(relation.to))} })`;
+}
+const WARNING_BATCH_THRESHOLD = 5;
+function flushWarnings(warnings) {
+	if (warnings.length === 0) return;
+	if (warnings.length <= WARNING_BATCH_THRESHOLD) {
+		for (const message of warnings) process.emitWarning(message, { code: "PN_CONTRACT_TYPED_FALLBACK_AVAILABLE" });
+		return;
+	}
+	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 `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 = [];
+	const warnedFields = /* @__PURE__ */ new Set();
+	for (const [modelName, modelDefinition] of Object.entries(models)) for (const [fieldName, fieldBuilder] of Object.entries(modelDefinition.stageOne.fields)) {
+		const fieldState = fieldBuilder.build();
+		if (typeof fieldState.typeRef !== "string" || !(fieldState.typeRef in storageTypes)) continue;
+		const warningKey = `${modelName}.${fieldName}`;
+		if (warnedFields.has(warningKey)) continue;
+		warnedFields.add(warningKey);
+		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);
+}
+function emitTypedCrossModelFallbackWarnings(collection) {
+	const warnings = [];
+	const warnedKeys = /* @__PURE__ */ new Set();
+	for (const spec of collection.modelSpecs.values()) {
+		for (const [relationName, relationBuilder] of Object.entries(spec.relations)) {
+			const relation = relationBuilder.build();
+			if (relation.toModel.kind === "relationModelName" && relation.toModel.source === "string" && hasNamedModelToken(collection.models, relation.toModel.modelName)) {
+				const warningKey = `${spec.modelName}.${relationName}.toModel`;
+				if (!warnedKeys.has(warningKey)) {
+					warnedKeys.add(warningKey);
+					const current = formatRelationCall(relation, `'${relation.toModel.modelName}'`);
+					const suggested = formatRelationCall(relation, relation.toModel.modelName);
+					warnings.push(formatFallbackWarning(`relation "${spec.modelName}.${relationName}"`, current, suggested));
+				}
+			}
+			if (relation.kind === "manyToMany" && relation.through.kind === "relationModelName" && relation.through.source === "string" && hasNamedModelToken(collection.models, relation.through.modelName)) {
+				const warningKey = `${spec.modelName}.${relationName}.through`;
+				if (!warnedKeys.has(warningKey)) {
+					warnedKeys.add(warningKey);
+					const current = formatManyToManyCallWithThrough(relation, `'${relation.through.modelName}'`);
+					const suggested = formatManyToManyCallWithThrough(relation, relation.through.modelName);
+					warnings.push(formatFallbackWarning(`relation "${spec.modelName}.${relationName}"`, current, suggested));
+				}
+			}
+		}
+		for (const [foreignKeyIndex, foreignKey] of (spec.sqlSpec?.foreignKeys ?? []).entries()) {
+			if (foreignKey.targetSource !== "string" || !hasNamedModelToken(collection.models, foreignKey.targetModel)) continue;
+			const warningKey = `${spec.modelName}.sql.foreignKeys.${foreignKeyIndex}`;
+			if (warnedKeys.has(warningKey)) continue;
+			warnedKeys.add(warningKey);
+			const current = formatConstraintsRefCall(foreignKey.targetModel, foreignKey.targetFields);
+			const suggested = formatTokenFieldSelection(foreignKey.targetModel, foreignKey.targetFields);
+			warnings.push(formatFallbackWarning(`model "${spec.modelName}"`, `${current} in .sql(...)`, suggested));
+		}
+	}
+	flushWarnings(warnings);
+}
+function buildStorageTypeReverseLookup(storageTypes) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const [key, instance] of Object.entries(storageTypes)) lookup.set(instance, key);
+	return lookup;
+}
+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 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 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 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 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 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 = [];
+	let idName;
+	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
+		const fieldState = fieldBuilder.build();
+		if (!fieldState.id) continue;
+		inlineIdFields.push(fieldName);
+		if (fieldState.id.name) idName = fieldState.id.name;
+	}
+	if (inlineIdFields.length === 0) return;
+	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 {
+		kind: "id",
+		fields: [inlineIdField],
+		...idName ? { name: idName } : {}
+	};
+}
+function collectInlineUniqueConstraints(spec) {
+	const constraints = [];
+	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
+		const fieldState = fieldBuilder.build();
+		if (!fieldState.unique) continue;
+		constraints.push({
+			kind: "unique",
+			fields: [fieldName],
+			...fieldState.unique.name ? { name: fieldState.unique.name } : {}
+		});
+	}
+	return constraints;
+}
+function resolveModelIdConstraint(spec) {
+	const inlineId = resolveInlineIdConstraint(spec);
+	const attributeId = spec.attributesSpec?.id;
+	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 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 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) {
+	const foreignKeys = [];
+	for (const [relationName, relationBuilder] of Object.entries(spec.relations)) {
+		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 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({
+			modelName: spec.modelName,
+			relationName,
+			leftLabel: "source",
+			leftFields: fields,
+			rightLabel: "target",
+			rightFields: targetFields
+		});
+		foreignKeys.push({
+			kind: "fk",
+			fields,
+			targetModel: targetModelName,
+			targetFields,
+			...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 } : {}
+		});
+	}
+	return foreignKeys;
+}
+function resolveRelationAnchorFields(spec) {
+	const idFields = spec.idConstraint?.fields;
+	if (idFields && idFields.length > 0) return idFields;
+	if ("id" in spec.fieldToColumn) return ["id"];
+	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, extensions) {
+	const targetModelName = resolveRelationModelName(relation.toModel);
+	const fromFields = normalizeRelationFieldNames(relation.from);
+	const toFields = normalizeRelationFieldNames(relation.to);
+	assertRelationFieldArity({
+		modelName: currentSpec.modelName,
+		relationName,
+		leftLabel: "source",
+		leftFields: fromFields,
+		rightLabel: "target",
+		rightFields: toFields
+	});
+	if (relation.spaceId !== void 0) {
+		assertKnownExtensionPack(extensions, 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 contractError("CONTRACT.MODEL_UNKNOWN", `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`, { meta: {
+		sourceModel: currentSpec.modelName,
+		relationName,
+		targetModel: targetModelName
+	} });
+	return {
+		fieldName: relationName,
+		toModel: targetModelName,
+		toTable: targetSpec.tableName,
+		cardinality: "N:1",
+		on: {
+			parentTable: currentSpec.tableName,
+			parentColumns: mapFieldNamesToColumnNames(currentSpec.modelName, fromFields, currentSpec.fieldToColumn),
+			childTable: targetSpec.tableName,
+			childColumns: mapFieldNamesToColumnNames(targetSpec.modelName, toFields, targetSpec.fieldToColumn)
+		}
+	};
+}
+function lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs) {
+	const targetModelName = resolveRelationModelName(relation.toModel);
+	const targetSpec = allSpecs.get(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({
+		modelName: currentSpec.modelName,
+		relationName,
+		leftLabel: "anchor",
+		leftFields: parentFields,
+		rightLabel: "child",
+		rightFields: childFields
+	});
+	return {
+		fieldName: relationName,
+		toModel: targetModelName,
+		toTable: targetSpec.tableName,
+		cardinality: relation.kind === "hasMany" ? "1:N" : "1:1",
+		on: {
+			parentTable: currentSpec.tableName,
+			parentColumns: mapFieldNamesToColumnNames(currentSpec.modelName, parentFields, currentSpec.fieldToColumn),
+			childTable: targetSpec.tableName,
+			childColumns: mapFieldNamesToColumnNames(targetSpec.modelName, childFields, targetSpec.fieldToColumn)
+		}
+	};
+}
+function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs) {
+	const targetModelName = resolveRelationModelName(relation.toModel);
+	const targetSpec = allSpecs.get(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 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 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,
+		toTable: targetSpec.tableName,
+		cardinality: "N:M",
+		through: {
+			table: throughSpec.tableName,
+			...ifDefined("namespaceId", throughSpec.namespace),
+			parentColumns: mapFieldNamesToColumnNames(throughSpec.modelName, throughFromFields, throughSpec.fieldToColumn),
+			childColumns: mapFieldNamesToColumnNames(throughSpec.modelName, throughToFields, throughSpec.fieldToColumn)
+		},
+		on: {
+			parentTable: currentSpec.tableName,
+			parentColumns: mapFieldNamesToColumnNames(currentSpec.modelName, currentAnchorFields, currentSpec.fieldToColumn),
+			childTable: throughSpec.tableName,
+			childColumns: mapFieldNamesToColumnNames(throughSpec.modelName, throughFromFields, throughSpec.fieldToColumn)
+		}
+	};
+}
+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);
+}
+function lowerLocalForeignKeyNode(spec, targetSpec, foreignKey) {
+	return {
+		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
+		references: {
+			model: targetSpec.modelName,
+			table: targetSpec.tableName,
+			columns: mapFieldNamesToColumnNames(targetSpec.modelName, foreignKey.targetFields, targetSpec.fieldToColumn)
+		},
+		...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 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(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, extensions) {
+	const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
+		if (foreignKey.targetSpaceId !== void 0) {
+			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 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(extensions, foreignKey.targetSpaceId, `Foreign key on "${spec.modelName}"`);
+			return lowerCrossSpaceForeignKeyNode(spec, {
+				...foreignKey,
+				targetSpaceId: foreignKey.targetSpaceId
+			});
+		}
+		const targetSpec = allSpecs.get(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, 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 InternalError(`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.many === true ? { many: true } : {},
+			...fieldState.default ? { default: fieldState.default } : {},
+			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {},
+			...enumHandle !== void 0 ? { enumTypeHandle: enumHandle } : {}
+		});
+	}
+	const { idConstraint } = spec;
+	const uniques = resolveModelUniqueConstraints(spec).map((unique) => ({
+		columns: mapFieldNamesToColumnNames(spec.modelName, unique.fields, spec.fieldToColumn),
+		...unique.name ? { name: unique.name } : {}
+	}));
+	const indexes = (spec.sqlSpec?.indexes ?? []).map((index) => {
+		const method = blindCast({
+			type: index.type,
+			options: index.options
+		});
+		const carried = {
+			where: index.where,
+			unique: index.unique,
+			name: index.name,
+			map: index.map,
+			...method
+		};
+		return index.expression !== void 0 ? {
+			...carried,
+			expression: index.expression
+		} : {
+			...carried,
+			columns: mapFieldNamesToColumnNames(spec.modelName, index.fields ?? [], spec.fieldToColumn)
+		};
+	});
+	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,
+		...spec.namespace !== void 0 ? { namespaceId: spec.namespace } : {},
+		fields,
+		...idConstraint ? { id: {
+			columns: mapFieldNamesToColumnNames(spec.modelName, idConstraint.fields, spec.fieldToColumn),
+			...idConstraint.name ? { name: idConstraint.name } : {}
+		} } : {},
+		...uniques.length > 0 ? { uniques } : {},
+		...indexes.length > 0 ? { indexes } : {},
+		...foreignKeys.length > 0 ? { foreignKeys } : {},
+		...relations.length > 0 ? { relations } : {},
+		...ifDefined("control", spec.sqlSpec?.control)
+	};
+}
+function collectRuntimeModelSpecs(definition) {
+	const storageTypes = { ...definition.types ?? {} };
+	const models = { ...definition.models ?? {} };
+	emitTypedNamedTypeFallbackWarnings(models, storageTypes);
+	const modelSpecs = /* @__PURE__ */ new Map();
+	const tableOwners = /* @__PURE__ */ new Map();
+	for (const [modelName, modelDefinition] of Object.entries(models)) {
+		const tokenModelName = modelDefinition.stageOne.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 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 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;
+		}
+		const fieldBuilders = modelDefinition.stageOne.fields;
+		const idConstraint = resolveModelIdConstraint({
+			modelName,
+			fieldBuilders,
+			attributesSpec
+		});
+		modelSpecs.set(modelName, {
+			modelName,
+			tableName,
+			namespace: modelDefinition.stageOne.namespace,
+			fieldBuilders,
+			fieldToColumn,
+			relations: modelDefinition.stageOne.relations,
+			attributesSpec,
+			sqlSpec,
+			idConstraint
+		});
+	}
+	return {
+		storageTypes,
+		models,
+		modelSpecs
+	};
+}
+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, extensions));
+}
+/**
+* Kind-agnostic walk over the author-declared `entities` handle list:
+*
+* 1. Index the bound packs' `entityTypes` contributions by discriminator so
+*    each handle's `entityKind` maps to the pack that registered it; a
+*    handle whose kind no composed pack registers is an error naming the
+*    kind.
+* 2. Resolve each handle's declared model refs (`handle.refs`, actual
+*    model-handle objects) to storage table coordinates — identity against
+*    the contract's `models` record first, then the handle's declared model
+*    name against the build's model specs; never by re-deriving a table
+*    name. A cross-space (extensionModel) handle resolves to its own
+*    coordinate annotated with `spaceId`.
+* 3. Call each owning pack's batch lowering hook once with all of its
+*    claimed handles, and fold the returned rows into the namespace-scoped
+*    attachments (namespace → kind → key), rejecting two different entities
+*    in one slot. The result becomes `ContractDefinition.attachedEntities`.
+*
+* No entity kind is named anywhere in this walk.
+*/
+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.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);
+		else walkEntityTypes(value, component);
+	};
+	for (const component of components) {
+		const entityTypes = component.authoring?.entityTypes;
+		if (entityTypes !== void 0) walkEntityTypes(entityTypes, component);
+	}
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const modelNamesByIdentity = /* @__PURE__ */ new Map();
+	for (const [modelName, modelBuilder] of Object.entries(definition.models ?? {})) modelNamesByIdentity.set(modelBuilder, modelName);
+	const coordinateOf = (modelName) => {
+		const spec = modelSpecs.get(modelName);
+		if (spec === void 0) return void 0;
+		return {
+			kind: "resolved",
+			namespaceId: spec.namespace ?? defaultNamespaceId,
+			tableName: spec.tableName,
+			modelName
+		};
+	};
+	const declaredModelName = (value) => {
+		if (typeof value !== "object" || value === null || !("stageOne" in value)) return void 0;
+		const stageOne = value.stageOne;
+		if (typeof stageOne !== "object" || stageOne === null || !("modelName" in stageOne)) return;
+		return typeof stageOne.modelName === "string" ? stageOne.modelName : void 0;
+	};
+	const resolveRef = (value) => {
+		const modelName = declaredModelName(value);
+		if (isCrossSpaceHandle(value)) {
+			const tableName = value.tableName;
+			const namespaceId = value.stageOne.namespace;
+			if (tableName !== void 0 && namespaceId !== void 0) return {
+				kind: "cross-space",
+				spaceId: value.spaceId,
+				namespaceId,
+				tableName,
+				...ifDefined("modelName", modelName)
+			};
+			return {
+				kind: "unresolved",
+				...ifDefined("modelName", modelName)
+			};
+		}
+		const identityName = modelNamesByIdentity.get(value);
+		return (identityName !== void 0 ? coordinateOf(identityName) : void 0) ?? (modelName !== void 0 ? coordinateOf(modelName) : void 0) ?? {
+			kind: "unresolved",
+			...ifDefined("modelName", modelName)
+		};
+	};
+	const claimed = /* @__PURE__ */ new Map();
+	for (const handle of entities) {
+		const component = owningComponent.get(handle.entityKind);
+		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) ?? [];
+		forComponent.push({
+			handle,
+			refs
+		});
+		claimed.set(component, forComponent);
+	}
+	const pack = {};
+	for (const [component, handles] of claimed) {
+		const authoring = component.authoring;
+		if (!providesEntityHandleLowering(authoring)) {
+			const kinds = [...new Set(handles.map((entry) => entry.handle.entityKind))].sort();
+			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,
+			defaultNamespaceId
+		})) {
+			const forNamespace = pack[row.namespaceId] ?? {};
+			pack[row.namespaceId] = forNamespace;
+			const forKind = forNamespace[row.entityKind] ?? {};
+			forNamespace[row.entityKind] = forKind;
+			const existing = forKind[row.key];
+			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;
+		}
+	}
+	return pack;
+}
+function buildContractDefinition(definition) {
+	const collection = collectRuntimeModelSpecs(definition);
+	const models = lowerModels(collection, definition.extensions);
+	const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
+	return {
+		target: definition.target,
+		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
+		...definition.extensions ? { extensions: definition.extensions } : {},
+		...definition.storageHash ? { storageHash: definition.storageHash } : {},
+		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
+		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
+		...definition.namespaces ? { namespaces: definition.namespaces } : {},
+		warnings: void 0,
+		createNamespace: definition.createNamespace,
+		...definition.enums && Object.keys(definition.enums).length > 0 ? { enums: definition.enums } : {},
+		...attachedEntities && Object.keys(attachedEntities).length > 0 ? { attachedEntities } : {},
+		models
+	};
+}
+function validateTargetPackRef(family, target) {
+	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
+* SQL family contracts. Two categories:
+*
+* 1. **IR sentinels** (`__unbound__`, `__unspecified__`) — reserved on
+*    every SQL target. The double-underscore decoration marks them as
+*    framework-reserved coordinates; user code must not declare them
+*    explicitly.
+* 2. **Target-specific PSL keywords** — Postgres reserves the bare
+*    `unbound` identifier for the late-binding opt-in
+*    (`namespace unbound { … }`) so the TS surface must reject it from
+*    `defineContract({ namespaces })` lists. SQLite has no schema
+*    concept and rejects every non-empty namespaces list outright;
+*    callers should declare `namespaces: []` or omit the field.
+*/
+function validateNamespaceDeclarations(target, namespaces) {
+	if (!namespaces) return;
+	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 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);
+	}
+}
+/**
+* Per-model `namespace` validation paired with
+* {@link validateNamespaceDeclarations}. Mirrors the reserved-name
+* rules so the per-model surface stays consistent with the contract-
+* level surface:
+*
+* - `__unbound__` / `__unspecified__` — reserved IR sentinels on
+*   every SQL target.
+* - `unbound` on Postgres — reserved for the PSL
+*   `namespace unbound { … }` opt-in.
+*
+* Additionally enforces that each per-model `namespace` either
+* references an entry in the contract's declared `namespaces` list or
+* names the Postgres late-binding keyword (`unbound`) — the latter is
+* not a "declared namespace" but is a legal opt-in only via PSL today,
+* so the TS surface also rejects it on the per-model side and points
+* authors at the PSL `namespace unbound { … }` block.
+*
+* The SQLite per-model `namespace` field is rejected outright (SQLite
+* has no schema concept).
+*/
+function validatePerModelNamespaces(target, namespaces, models) {
+	const declaredNamespaces = new Set(namespaces ?? []);
+	for (const [modelKey, modelBuilder] of Object.entries(models)) {
+		const perModelNamespace = modelBuilder.stageOne.namespace;
+		if (perModelNamespace === void 0) continue;
+		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, 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.extensions);
+	validateNamespaceDeclarations(definition.target, definition.namespaces);
+	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
+	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
+}
+/** Implementation. */
+function buildBoundContract(family, target, definition, factory) {
+	const full = {
+		...definition,
+		family,
+		target
+	};
+	if (factory !== void 0) {
+		const built = factory(createComposedAuthoringHelpers({
+			family,
+			target,
+			extensions: definition.extensions
+		}));
+		const mergedEnums = {
+			...definition.enums ?? {},
+			...built.enums
+		};
+		const mergedEntities = [...definition.entities ?? [], ...built.entities ?? []];
+		return buildContractFromDsl({
+			...full,
+			...ifDefined("types", built.types),
+			...ifDefined("models", built.models),
+			...ifDefined("enums", Object.keys(mergedEnums).length > 0 ? mergedEnums : void 0),
+			...ifDefined("entities", mergedEntities.length > 0 ? mergedEntities : void 0)
+		});
+	}
+	return buildContractFromDsl(full);
+}
+function defineContract(definition, factory) {
+	if (!isContractInput(definition)) throw contractError("CONTRACT.ARGUMENT_INVALID", "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 { enumType as a, member as c, defineContract as i, model as l, buildBoundContract as n, extensionModel as o, buildContractDefinition as r, field as s, bindEnumType as t, rel as u };
+
+//# sourceMappingURL=contract-builder-YjMQcvZ1.mjs.map