@prisma-next/sql-contract-ts 0.14.0 → 0.15.0-dev.10

package/dist/{build-contract-CQ4u83jx.mjs → build-contract-CAX6inbk.mjs}

@@ -3,23 +3,34 @@ import { ifDefined } from "@prisma-next/utils/defined";
 import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
 import { asNamespaceId, coreHash, crossRef } from "@prisma-next/contract/types";
 import { mergeCapabilityMatrices } from "@prisma-next/contract-authoring";
+import { isAuthoringEntityTypeDescriptor } from "@prisma-next/framework-components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
+import { tableEntityKind, valueSetEntityKind } from "@prisma-next/sql-contract/entity-kinds";
+import { materializeForeignKeysAndIndexes } from "@prisma-next/sql-contract/foreign-key-materialization";
 import { validateIndexTypes } from "@prisma-next/sql-contract/index-type-validation";
 import { createIndexTypeRegistry } from "@prisma-next/sql-contract/index-types";
-import { SqlStorage, applyFkDefaults, buildSqlNamespace, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { SqlStorage, applyFkDefaults, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { validateStorageSemantics } from "@prisma-next/sql-contract/validators";
+import { deriveValueSetFromEntity } from "@prisma-next/sql-contract/value-set-derivation-hook";
 //#region src/build-contract.ts
 function encodeViaCodec(value, codecId, codecLookup) {
 	const codec = codecLookup?.get(codecId);
 	if (codec) return codec.encodeJson(value);
 	return blindCast(value);
 }
-function encodeColumnDefault(defaultInput, codecId, codecLookup) {
+function encodeColumnDefault(defaultInput, codecId, codecLookup, many = false) {
 	if (defaultInput.kind === "function") return {
 		kind: "function",
 		expression: defaultInput.expression
 	};
+	if (many) {
+		if (!Array.isArray(defaultInput.value)) throw new Error(`Literal default on a list column must be an array; received ${typeof defaultInput.value}. A scalar default on a list field must be rejected at the authoring surface.`);
+		return {
+			kind: "literal",
+			value: defaultInput.value.map((element) => encodeViaCodec(element, codecId, codecLookup))
+		};
+	}
 	return {
 		kind: "literal",
 		value: encodeViaCodec(defaultInput.value, codecId, codecLookup)
@@ -52,6 +63,116 @@ function assertTargetTableMatches(sourceModelName, targetModel, referencedTableN
 function isValueObjectField(field) {
 	return "valueObjectName" in field;
 }
+/**
+* Resolves a deferred entity-ref column descriptor (e.g. a `pg.enum(handle)`
+* column) against the field's now-known owning namespace: attaches the
+* storage `valueSet` ref the collected entity's derived value-set is stored
+* under. `nativeType` / `typeParams.typeName` stay bare here — schema
+* qualification (e.g. `auth.aal_level`) is a target concern applied in the
+* next step, `qualifyColumnDescriptor`. A descriptor with no `entityRef` (the
+* ordinary case) passes through unchanged.
+*/
+function resolveEntityRefDescriptor(descriptor, namespaceId) {
+	const entityRef = descriptor.entityRef;
+	if (entityRef === void 0) return descriptor;
+	return {
+		...descriptor,
+		valueSet: {
+			plane: "storage",
+			entityKind: "valueSet",
+			namespaceId,
+			entityName: entityRef.entityName
+		}
+	};
+}
+/**
+* Structural check for a target that contributes a `qualifyColumnType` hook
+* on its authoring contributions. Duck-typed (mirroring
+* `contract-psl`'s `hasColumnFromEntityHook`) so the SQL family stays blind
+* to the target's qualification logic and no framework/family interface has
+* to name the hook.
+*/
+function hasColumnTypeQualifier(authoring) {
+	return "qualifyColumnType" in authoring && typeof authoring.qualifyColumnType === "function";
+}
+function resolveColumnTypeQualifier(target) {
+	const authoring = target.authoring;
+	if (authoring === void 0) return void 0;
+	return hasColumnTypeQualifier(authoring) ? authoring.qualifyColumnType : void 0;
+}
+/**
+* Applies the target's `qualifyColumnType` hook to a scalar column descriptor
+* at construction, so the storage column and the domain field (which derives
+* its `type.typeParams` from the storage column) are both built already
+* qualified in a single pass. A descriptor whose codec the target leaves
+* unchanged passes through untouched.
+*/
+function qualifyColumnDescriptor(descriptor, namespaceId, qualify) {
+	if (qualify === void 0) return descriptor;
+	const qualified = qualify({
+		codecId: descriptor.codecId,
+		nativeType: descriptor.nativeType,
+		...ifDefined("typeParams", descriptor.typeParams)
+	}, namespaceId);
+	if (qualified.nativeType === descriptor.nativeType && qualified.typeParams === descriptor.typeParams) return descriptor;
+	return {
+		...descriptor,
+		nativeType: qualified.nativeType,
+		...ifDefined("typeParams", qualified.typeParams)
+	};
+}
+/**
+* Records a deferred column's entity-ref into the namespace-scoped collection
+* accumulator (`namespaceId → entityKind → entityName`) — folded into the same
+* namespace assembly `deriveEntityValueSets`/`entries.<kind>` step as the
+* entities-channel attachments, so a column-collected entity gets its
+* value-set the same way an entities-channel one does.
+*
+* The same handle reused by many columns in one namespace is normal (a native
+* enum type backs any number of columns) and records the identical entity once.
+* Two *different* entity instances sharing a name+kind in one namespace is a
+* name collision — the emitted `entries.valueSet.<name>` could only reflect one
+* of them, silently mismatching the other column's type/cast. PSL hard-errors
+* on the equivalent (`PSL_DUPLICATE_DECLARATION`); the TS path rejects it too.
+*/
+function collectEntityFromColumn(collected, namespaceId, entityRef) {
+	const forNs = collected[namespaceId] ?? {};
+	const forKind = forNs[entityRef.entityKind] ?? {};
+	const existing = forKind[entityRef.entityName];
+	if (existing !== void 0 && existing !== entityRef.entity) throw new Error(`buildSqlContractFromDefinition: two different "${entityRef.entityKind}" entities named "${entityRef.entityName}" in namespace "${namespaceId}" — pack-entity names must be unique per namespace.`);
+	forKind[entityRef.entityName] = entityRef.entity;
+	forNs[entityRef.entityKind] = forKind;
+	collected[namespaceId] = forNs;
+}
+/**
+* Merges a namespace's entities-channel attachments (lowered from the
+* `entities` handle list, carried on `ContractDefinition.attachedEntities`)
+* with the entities collected from that namespace's deferred entity-ref
+* columns. A column-collected entity that shadows a *different* attached
+* entity of the same kind+name (or vice-versa) is the same name-collision bug
+* `collectEntityFromColumn` guards against across columns, so it is rejected
+* the same way — by entity identity, so the same handle attached and used by
+* a column does not throw.
+*/
+function mergeColumnAndAttachedEntities(namespaceId, attached, columnCollected) {
+	if (attached === void 0) return columnCollected;
+	if (columnCollected === void 0) return attached;
+	const kinds = /* @__PURE__ */ new Set([...Object.keys(attached), ...Object.keys(columnCollected)]);
+	const result = {};
+	for (const kind of kinds) {
+		const attachedForKind = attached[kind];
+		const columnForKind = columnCollected[kind];
+		for (const [name, entity] of Object.entries(columnForKind ?? {})) {
+			const existing = attachedForKind?.[name];
+			if (existing !== void 0 && existing !== entity) throw new Error(`buildSqlContractFromDefinition: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a column-referenced entity conflicts with an attached one; pack-entity names must be unique per namespace.`);
+		}
+		result[kind] = {
+			...attachedForKind,
+			...columnForKind
+		};
+	}
+	return result;
+}
 const JSONB_CODEC_ID = "pg/jsonb@1";
 const JSONB_NATIVE_TYPE = "jsonb";
 function resolveModelNamespaceId(model, modelNameToNamespaceId, defaultNamespaceId) {
@@ -86,21 +207,18 @@ function buildStorageColumn(field, storageValueSetRef, codecLookup) {
 			...ifDefined("default", encodedDefault)
 		};
 	}
-	if (field.many) return {
-		nativeType: JSONB_NATIVE_TYPE,
-		codecId: JSONB_CODEC_ID,
-		nullable: field.nullable
-	};
 	const codecId = field.descriptor.codecId;
-	const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, codecId, codecLookup) : void 0;
+	const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, codecId, codecLookup, field.many === true) : void 0;
+	const valueSet = storageValueSetRef ?? field.descriptor.valueSet;
 	return {
 		nativeType: field.descriptor.nativeType,
 		codecId,
 		nullable: field.nullable,
+		...field.many ? { many: true } : {},
 		...ifDefined("typeParams", field.descriptor.typeParams),
 		...ifDefined("default", encodedDefault),
 		...ifDefined("typeRef", field.descriptor.typeRef),
-		...ifDefined("valueSet", storageValueSetRef)
+		...ifDefined("valueSet", valueSet)
 	};
 }
 function buildDomainField(field, column, domainValueSetRef) {
@@ -128,23 +246,99 @@ function collectStorageNamespaceCoordinateIds(definition) {
 	ids.add(definition.target.defaultNamespaceId);
 	for (const id of definition.namespaces ?? []) if (id.length > 0) ids.add(id);
 	for (const model of definition.models) if (model.namespaceId !== void 0 && model.namespaceId.length > 0) ids.add(model.namespaceId);
+	for (const id of Object.keys(definition.attachedEntities ?? {})) if (id.length > 0) ids.add(id);
 	return ids;
 }
+/**
+* Entry kinds the framework assembler itself manages (`table` from models,
+* `valueSet` from `enums` and attached-entity value-set derivation). A
+* pack-attached entity claiming one of these would silently clobber or be
+* clobbered by the managed slot, so it is rejected outright.
+*/
+const MANAGED_ENTRY_KINDS = /* @__PURE__ */ new Set([tableEntityKind.kind, valueSetEntityKind.kind]);
+function assertNoManagedEntityKinds(namespaceId, entitiesForNs) {
+	if (entitiesForNs === void 0) return;
+	for (const kind of Object.keys(entitiesForNs)) if (MANAGED_ENTRY_KINDS.has(kind)) throw new Error(`buildSqlContractFromDefinition: attached entity in namespace "${namespaceId}" declares entry kind "${kind}", which is managed by the framework (table/valueSet) and cannot be attached.`);
+}
+/**
+* Walks the flat `entityTypes` namespace tree contributed by the target pack
+* and every extension pack, indexing descriptors by their `discriminator` —
+* the same string a pack entity's entries-map key (`entries.<kind>`) uses.
+* Mirrors `contract-psl`'s `buildEntityTypesByDiscriminator`, recomposed here
+* from the packs `ContractDefinition` already carries (`target` +
+* `extensionPacks`) since the TS assembler has no single pre-merged
+* `AuthoringContributions` input to read the way the PSL interpreter does.
+*/
+function collectEntityTypeDescriptorsByDiscriminator(definition) {
+	const result = /* @__PURE__ */ new Map();
+	const walk = (namespace) => {
+		for (const value of Object.values(namespace)) if (isAuthoringEntityTypeDescriptor(value)) result.set(value.discriminator, value);
+		else walk(value);
+	};
+	const components = [definition.target, ...Object.values(definition.extensionPacks ?? {})];
+	for (const component of components) {
+		const entityTypes = component.authoring?.entityTypes;
+		if (entityTypes !== void 0) walk(entityTypes);
+	}
+	return result;
+}
+/**
+* Derives value-sets for every pack entity declared in one namespace,
+* reusing the same `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook
+* `contract-psl`'s `lowerExtensionBlocksForNamespace` folds into
+* `entries.valueSet` on the PSL path — so a TS-attached entity (e.g. a
+* native enum) gets its value-set the same way. Entity kinds with no
+* registered descriptor, or whose descriptor output doesn't derive a
+* value-set, contribute nothing.
+*/
+function deriveEntityValueSets(entitiesForNs, entityTypesByDiscriminator) {
+	if (entitiesForNs === void 0) return void 0;
+	let result;
+	for (const [kind, entitiesByName] of Object.entries(entitiesForNs)) {
+		const descriptor = entityTypesByDiscriminator.get(kind);
+		if (descriptor === void 0) continue;
+		for (const [name, entity] of Object.entries(entitiesByName)) {
+			const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);
+			if (derivedValueSet === void 0) continue;
+			result ??= {};
+			result[name] = derivedValueSet;
+		}
+	}
+	return result;
+}
+/**
+* Merges a namespace's `enumType()`-derived value-sets with its pack-entity-
+* derived value-sets. Both land in the same `entries.valueSet[name]` slot —
+* which drives value-set → codec typing and the domain-enum CHECK — so a
+* same-named entry in both would let one silently overwrite the other and
+* corrupt whichever column resolves against it. The same collision class the
+* `mergeColumnAndAttachedEntities` guard rejects; the PSL path already hard-errors
+* on the equivalent (`interpretPslDocumentToSqlContract`). Reject it here too.
+*/
+function mergeNamespaceValueSets(namespaceId, enumValueSets, packValueSets) {
+	if (enumValueSets !== void 0 && packValueSets !== void 0) {
+		for (const name of Object.keys(packValueSets)) if (Object.hasOwn(enumValueSets, name)) throw new Error(`buildSqlContractFromDefinition: value-set "${name}" in namespace "${namespaceId}" is derived from both an enum and a pack entity — names must be unique per namespace.`);
+	}
+	return {
+		...enumValueSets,
+		...packValueSets
+	};
+}
 function ensureUnboundNamespaceSlot(namespaces, createNamespace) {
 	if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) return namespaces;
-	const unboundInput = {
+	const unbound = createNamespace({
 		id: UNBOUND_NAMESPACE_ID,
 		entries: { table: {} }
-	};
-	const unbound = createNamespace ? createNamespace(unboundInput) : buildSqlNamespace(unboundInput);
-	return blindCast({
+	});
+	return {
 		[UNBOUND_NAMESPACE_ID]: unbound,
 		...namespaces
-	});
+	};
 }
 function buildSqlContractFromDefinition(definition, codecLookup) {
 	const target = definition.target.targetId;
 	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const qualifyColumnType = resolveColumnTypeQualifier(definition.target);
 	const targetFamily = "sql";
 	const resolveNamespaceId = (m) => m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId;
 	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
@@ -154,6 +348,7 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 	const modelNameToNamespaceId = /* @__PURE__ */ new Map();
 	const executionDefaults = [];
 	const modelsByNamespace = {};
+	const collectedColumnEntities = {};
 	const rootEntries = [];
 	for (const semanticModel of definition.models) {
 		const tableName = semanticModel.tableName;
@@ -168,6 +363,7 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 		const fieldToColumn = {};
 		const domainFields = {};
 		const domainFieldRefs = {};
+		const checksForTable = [];
 		for (const field of semanticModel.fields) {
 			const executionDefaultPhases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
 			if (executionDefaultPhases) {
@@ -187,9 +383,28 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 				namespaceId: defaultNamespaceId,
 				entityName: enumHandle.enumName
 			} : void 0;
-			const column = buildStorageColumn(field, storageValueSetRef, codecLookup);
+			let resolvedField = field;
+			if (!isValueObjectField(field)) {
+				let descriptor = field.descriptor;
+				const entityRef = descriptor.entityRef;
+				if (entityRef !== void 0) {
+					collectEntityFromColumn(collectedColumnEntities, namespaceId, entityRef);
+					descriptor = resolveEntityRefDescriptor(descriptor, namespaceId);
+				}
+				descriptor = qualifyColumnDescriptor(descriptor, namespaceId, qualifyColumnType);
+				if (descriptor !== field.descriptor) resolvedField = {
+					...field,
+					descriptor
+				};
+			}
+			const column = buildStorageColumn(resolvedField, storageValueSetRef, codecLookup);
 			columns[field.columnName] = column;
 			fieldToColumn[field.fieldName] = field.columnName;
+			if (column.valueSet !== void 0 && storageValueSetRef !== void 0) checksForTable.push({
+				name: `${tableName}_${field.columnName}_check`,
+				column: field.columnName,
+				valueSet: column.valueSet
+			});
 			domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);
 			if (isValueObjectField(field)) domainFieldRefs[field.fieldName] = {
 				kind: "valueObject",
@@ -210,7 +425,7 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
 			});
 		}
-		const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
+		const authoringForeignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
 			if (fk.references.spaceId !== void 0) {
 				const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
 				return {
@@ -258,32 +473,28 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 			};
 		});
 		if (!semanticModel.sharesBaseTable) {
-			const checksForTable = Object.entries(columns).flatMap(([columnName, col]) => {
-				const valueSet = col.valueSet;
-				return valueSet === void 0 ? [] : [{
-					name: `${tableName}_${columnName}_check`,
-					column: columnName,
-					valueSet
-				}];
-			});
+			const uniques = (semanticModel.uniques ?? []).map((u) => ({
+				columns: u.columns,
+				...ifDefined("name", u.name)
+			}));
+			const declaredIndexes = (semanticModel.indexes ?? []).map((i) => ({
+				columns: i.columns,
+				...ifDefined("name", i.name),
+				...ifDefined("type", i.type),
+				...ifDefined("options", i.options)
+			}));
+			const primaryKey = semanticModel.id ? {
+				columns: semanticModel.id.columns,
+				...ifDefined("name", semanticModel.id.name)
+			} : void 0;
+			const { foreignKeys, indexes } = materializeForeignKeysAndIndexes(tableName, authoringForeignKeys, declaredIndexes, uniques, primaryKey);
 			const tableInput = {
 				columns,
 				...ifDefined("control", semanticModel.control),
-				uniques: (semanticModel.uniques ?? []).map((u) => ({
-					columns: u.columns,
-					...ifDefined("name", u.name)
-				})),
-				indexes: (semanticModel.indexes ?? []).map((i) => ({
-					columns: i.columns,
-					...ifDefined("name", i.name),
-					...ifDefined("type", i.type),
-					...ifDefined("options", i.options)
-				})),
+				uniques,
+				indexes,
 				foreignKeys,
-				...semanticModel.id ? { primaryKey: {
-					columns: semanticModel.id.columns,
-					...ifDefined("name", semanticModel.id.name)
-				} } : {},
+				...primaryKey ? { primaryKey } : {},
 				...checksForTable.length > 0 ? { checks: checksForTable } : {}
 			};
 			let nsTables = tablesByNamespace[namespaceId];
@@ -393,17 +604,23 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 		};
 	}
 	const { createNamespace } = definition;
-	const namespaces = blindCast(Object.fromEntries([...namespaceCoordinateIds].sort().map((id) => {
-		const valueSetEntries = storageValueSetsByNs[id];
+	const entityTypesByDiscriminator = collectEntityTypeDescriptorsByDiscriminator(definition);
+	const namespaces = Object.fromEntries([...namespaceCoordinateIds].sort().map((id) => {
+		const entitiesForNs = mergeColumnAndAttachedEntities(id, definition.attachedEntities?.[id], collectedColumnEntities[id]);
+		assertNoManagedEntityKinds(id, entitiesForNs);
+		const enumValueSetEntries = storageValueSetsByNs[id];
+		const packValueSetEntries = deriveEntityValueSets(entitiesForNs, entityTypesByDiscriminator);
+		const valueSetEntries = enumValueSetEntries !== void 0 || packValueSetEntries !== void 0 ? mergeNamespaceValueSets(id, enumValueSetEntries, packValueSetEntries) : void 0;
 		const nsInput = {
 			id,
 			entries: {
 				table: tablesByNamespace[id] ?? {},
+				...entitiesForNs,
 				...valueSetEntries !== void 0 && Object.keys(valueSetEntries).length > 0 ? { valueSet: valueSetEntries } : {}
 			}
 		};
-		return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
-	})));
+		return [id, createNamespace(nsInput)];
+	}));
 	const storageWithoutHash = {
 		...Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {},
 		namespaces: defaultNamespaceId === UNBOUND_NAMESPACE_ID ? ensureUnboundNamespaceSlot(namespaces, createNamespace) : namespaces
@@ -490,4 +707,4 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 //#endregion
 export { buildSqlContractFromDefinition as t };
 
-//# sourceMappingURL=build-contract-CQ4u83jx.mjs.map
+//# sourceMappingURL=build-contract-CAX6inbk.mjs.map

package/dist/build-contract-CAX6inbk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-contract-CAX6inbk.mjs","names":[],"sources":["../src/build-contract.ts"],"sourcesContent":["import {\n  computeExecutionHash,\n  computeProfileHash,\n  computeStorageHash,\n} from '@prisma-next/contract/hashing';\nimport {\n  asNamespaceId,\n  type ColumnDefault,\n  type Contract,\n  type ContractEnum,\n  type ContractField,\n  type ContractModel,\n  type ContractRelation,\n  type ContractRelationThrough,\n  type ContractValueObject,\n  type CrossReference,\n  coreHash,\n  crossRef,\n  type ExecutionMutationDefault,\n  type JsonValue,\n  type StorageHashBase,\n  type ValueSetRef,\n} from '@prisma-next/contract/types';\nimport { type CapabilityMatrix, mergeCapabilityMatrices } from '@prisma-next/contract-authoring';\nimport type {\n  AuthoringContributions,\n  AuthoringEntityTypeDescriptor,\n  AuthoringEntityTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\nimport { isAuthoringEntityTypeDescriptor } from '@prisma-next/framework-components/authoring';\nimport type { CodecLookup, ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';\nimport { tableEntityKind, valueSetEntityKind } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  type ForeignKeyAuthoringInput,\n  materializeForeignKeysAndIndexes,\n} from '@prisma-next/sql-contract/foreign-key-materialization';\nimport { validateIndexTypes } from '@prisma-next/sql-contract/index-type-validation';\nimport {\n  createIndexTypeRegistry,\n  type IndexTypeMap,\n  type IndexTypeRegistration,\n} from '@prisma-next/sql-contract/index-types';\nimport {\n  applyFkDefaults,\n  type CheckConstraintInput,\n  type SqlNamespaceInput,\n  SqlStorage,\n  type SqlStorageInput,\n  type StorageColumn,\n  type StorageTableInput,\n  type StorageTypeInstance,\n  type StorageValueSetInput,\n  toStorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { validateStorageSemantics } from '@prisma-next/sql-contract/validators';\nimport { deriveValueSetFromEntity } from '@prisma-next/sql-contract/value-set-derivation-hook';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type {\n  ContractDefinition,\n  FieldNode,\n  ModelNode,\n  RelationNode,\n  ValueObjectFieldNode,\n} from './contract-definition';\n\ntype DomainFieldRef =\n  | { readonly kind: 'scalar'; readonly many?: boolean }\n  | { readonly kind: 'valueObject'; readonly name: string; readonly many?: boolean };\n\nfunction encodeViaCodec(value: unknown, codecId: string, codecLookup?: CodecLookup): JsonValue {\n  const codec = codecLookup?.get(codecId);\n  if (codec) {\n    return codec.encodeJson(value);\n  }\n  return blindCast<\n    JsonValue,\n    'no codec lookup at build time: literal/enum member value is already JSON-safe'\n  >(value);\n}\n\nfunction encodeColumnDefault(\n  defaultInput: ColumnDefault,\n  codecId: string,\n  codecLookup?: CodecLookup,\n  many = false,\n): ColumnDefault {\n  if (defaultInput.kind === 'function') {\n    return { kind: 'function', expression: defaultInput.expression };\n  }\n  if (many) {\n    if (!Array.isArray(defaultInput.value)) {\n      throw new Error(\n        `Literal default on a list column must be an array; received ${typeof defaultInput.value}. ` +\n          'A scalar default on a list field must be rejected at the authoring surface.',\n      );\n    }\n    return {\n      kind: 'literal',\n      value: defaultInput.value.map((element) => encodeViaCodec(element, codecId, codecLookup)),\n    };\n  }\n  return {\n    kind: 'literal',\n    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),\n  };\n}\n\nfunction assertStorageSemantics(\n  definition: ContractDefinition,\n  contract: Contract<SqlStorage>,\n): void {\n  const semanticErrors = validateStorageSemantics(contract.storage);\n  if (semanticErrors.length > 0) {\n    throw new Error(`Contract semantic validation failed: ${semanticErrors.join('; ')}`);\n  }\n\n  const indexTypeRegistry = createIndexTypeRegistry();\n  const packsToRegister: ReadonlyArray<{ readonly id?: string; readonly indexTypes?: unknown }> = [\n    definition.target,\n    ...Object.values(definition.extensionPacks ?? {}),\n  ];\n  for (const pack of packsToRegister) {\n    const registration = pack.indexTypes;\n    if (registration === undefined) continue;\n    if (\n      typeof registration !== 'object' ||\n      registration === null ||\n      !Array.isArray((registration as { entries?: unknown }).entries)\n    ) {\n      throw new Error(\n        `Pack \"${pack.id ?? '<unknown>'}\" declares \"indexTypes\" but its value is not an IndexTypeRegistration (expected an object with an \"entries\" array; got ${typeof registration}).`,\n      );\n    }\n    for (const entry of (registration as IndexTypeRegistration<IndexTypeMap>).entries) {\n      indexTypeRegistry.register(entry);\n    }\n  }\n  validateIndexTypes(contract, indexTypeRegistry);\n}\n\nfunction assertKnownTargetModel(\n  modelsByName: ReadonlyMap<string, ModelNode>,\n  modelsByCoordinate: ReadonlyMap<string, ModelNode>,\n  sourceModelName: string,\n  targetModelName: string,\n  targetNamespaceId: string | undefined,\n  context: string,\n): ModelNode {\n  const targetModel =\n    targetNamespaceId !== undefined && targetNamespaceId.length > 0\n      ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`)\n      : modelsByName.get(targetModelName);\n  if (!targetModel) {\n    const qualified =\n      targetNamespaceId !== undefined && targetNamespaceId.length > 0\n        ? `${targetNamespaceId}.${targetModelName}`\n        : targetModelName;\n    throw new Error(\n      `${context} on model \"${sourceModelName}\" references unknown model \"${qualified}\"`,\n    );\n  }\n  return targetModel;\n}\n\nfunction assertTargetTableMatches(\n  sourceModelName: string,\n  targetModel: ModelNode,\n  referencedTableName: string,\n  context: string,\n): void {\n  if (targetModel.tableName !== referencedTableName) {\n    throw new Error(\n      `${context} on model \"${sourceModelName}\" references table \"${referencedTableName}\" but model \"${targetModel.modelName}\" maps to \"${targetModel.tableName}\"`,\n    );\n  }\n}\n\nfunction isValueObjectField(\n  field: FieldNode | ValueObjectFieldNode,\n): field is ValueObjectFieldNode {\n  return 'valueObjectName' in field;\n}\n\n/**\n * Resolves a deferred entity-ref column descriptor (e.g. a `pg.enum(handle)`\n * column) against the field's now-known owning namespace: attaches the\n * storage `valueSet` ref the collected entity's derived value-set is stored\n * under. `nativeType` / `typeParams.typeName` stay bare here — schema\n * qualification (e.g. `auth.aal_level`) is a target concern applied in the\n * next step, `qualifyColumnDescriptor`. A descriptor with no `entityRef` (the\n * ordinary case) passes through unchanged.\n */\nfunction resolveEntityRefDescriptor(\n  descriptor: ColumnTypeDescriptor,\n  namespaceId: string,\n): ColumnTypeDescriptor {\n  const entityRef = descriptor.entityRef;\n  if (entityRef === undefined) return descriptor;\n\n  return {\n    ...descriptor,\n    valueSet: {\n      plane: 'storage',\n      entityKind: 'valueSet',\n      namespaceId,\n      entityName: entityRef.entityName,\n    },\n  };\n}\n\n/**\n * A target's contract-construction-time column-type qualifier, contributed\n * through `target.authoring.qualifyColumnType`. Given a column's bare type\n * info and its owning `namespaceId`, it returns the type info the target's\n * schema semantics require (e.g. Postgres schema-qualifies a native-enum\n * column's type name to `auth.aal_level`). The dispatch keys off the codec\n * id, so every codec — including ones needing no change — is passed through\n * and the caller stays codec-blind. Targets without the hook leave every\n * column bare.\n */\ntype ColumnTypeQualifier = (\n  input: {\n    readonly codecId: string;\n    readonly nativeType: string;\n    readonly typeParams?: Record<string, unknown>;\n  },\n  namespaceId: string,\n) => { readonly nativeType: string; readonly typeParams?: Record<string, unknown> };\n\n/**\n * Structural check for a target that contributes a `qualifyColumnType` hook\n * on its authoring contributions. Duck-typed (mirroring\n * `contract-psl`'s `hasColumnFromEntityHook`) so the SQL family stays blind\n * to the target's qualification logic and no framework/family interface has\n * to name the hook.\n */\nfunction hasColumnTypeQualifier(\n  authoring: AuthoringContributions,\n): authoring is AuthoringContributions & { readonly qualifyColumnType: ColumnTypeQualifier } {\n  return 'qualifyColumnType' in authoring && typeof authoring.qualifyColumnType === 'function';\n}\n\nfunction resolveColumnTypeQualifier(\n  target: ContractDefinition['target'],\n): ColumnTypeQualifier | undefined {\n  const authoring = target.authoring;\n  if (authoring === undefined) return undefined;\n  return hasColumnTypeQualifier(authoring) ? authoring.qualifyColumnType : undefined;\n}\n\n/**\n * Applies the target's `qualifyColumnType` hook to a scalar column descriptor\n * at construction, so the storage column and the domain field (which derives\n * its `type.typeParams` from the storage column) are both built already\n * qualified in a single pass. A descriptor whose codec the target leaves\n * unchanged passes through untouched.\n */\nfunction qualifyColumnDescriptor(\n  descriptor: ColumnTypeDescriptor,\n  namespaceId: string,\n  qualify: ColumnTypeQualifier | undefined,\n): ColumnTypeDescriptor {\n  if (qualify === undefined) return descriptor;\n  const qualified = qualify(\n    {\n      codecId: descriptor.codecId,\n      nativeType: descriptor.nativeType,\n      ...ifDefined('typeParams', descriptor.typeParams),\n    },\n    namespaceId,\n  );\n  if (\n    qualified.nativeType === descriptor.nativeType &&\n    qualified.typeParams === descriptor.typeParams\n  ) {\n    return descriptor;\n  }\n  return {\n    ...descriptor,\n    nativeType: qualified.nativeType,\n    ...ifDefined('typeParams', qualified.typeParams),\n  };\n}\n\ntype CollectedColumnEntities = Record<string, Record<string, Record<string, unknown>>>;\n\n/**\n * Records a deferred column's entity-ref into the namespace-scoped collection\n * accumulator (`namespaceId → entityKind → entityName`) — folded into the same\n * namespace assembly `deriveEntityValueSets`/`entries.<kind>` step as the\n * entities-channel attachments, so a column-collected entity gets its\n * value-set the same way an entities-channel one does.\n *\n * The same handle reused by many columns in one namespace is normal (a native\n * enum type backs any number of columns) and records the identical entity once.\n * Two *different* entity instances sharing a name+kind in one namespace is a\n * name collision — the emitted `entries.valueSet.<name>` could only reflect one\n * of them, silently mismatching the other column's type/cast. PSL hard-errors\n * on the equivalent (`PSL_DUPLICATE_DECLARATION`); the TS path rejects it too.\n */\nfunction collectEntityFromColumn(\n  collected: CollectedColumnEntities,\n  namespaceId: string,\n  entityRef: NonNullable<ColumnTypeDescriptor['entityRef']>,\n): void {\n  const forNs = collected[namespaceId] ?? {};\n  const forKind = forNs[entityRef.entityKind] ?? {};\n  const existing = forKind[entityRef.entityName];\n  if (existing !== undefined && existing !== entityRef.entity) {\n    throw new Error(\n      `buildSqlContractFromDefinition: two different \"${entityRef.entityKind}\" entities named \"${entityRef.entityName}\" in namespace \"${namespaceId}\" — pack-entity names must be unique per namespace.`,\n    );\n  }\n  forKind[entityRef.entityName] = entityRef.entity;\n  forNs[entityRef.entityKind] = forKind;\n  collected[namespaceId] = forNs;\n}\n\n/**\n * Merges a namespace's entities-channel attachments (lowered from the\n * `entities` handle list, carried on `ContractDefinition.attachedEntities`)\n * with the entities collected from that namespace's deferred entity-ref\n * columns. A column-collected entity that shadows a *different* attached\n * entity of the same kind+name (or vice-versa) is the same name-collision bug\n * `collectEntityFromColumn` guards against across columns, so it is rejected\n * the same way — by entity identity, so the same handle attached and used by\n * a column does not throw.\n */\nfunction mergeColumnAndAttachedEntities(\n  namespaceId: string,\n  attached: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined,\n  columnCollected: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined,\n): Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined {\n  if (attached === undefined) return columnCollected;\n  if (columnCollected === undefined) return attached;\n  const kinds = new Set([...Object.keys(attached), ...Object.keys(columnCollected)]);\n  const result: Record<string, Readonly<Record<string, unknown>>> = {};\n  for (const kind of kinds) {\n    const attachedForKind = attached[kind];\n    const columnForKind = columnCollected[kind];\n    for (const [name, entity] of Object.entries(columnForKind ?? {})) {\n      const existing = attachedForKind?.[name];\n      if (existing !== undefined && existing !== entity) {\n        throw new Error(\n          `buildSqlContractFromDefinition: two different \"${kind}\" entities named \"${name}\" in namespace \"${namespaceId}\" — a column-referenced entity conflicts with an attached one; pack-entity names must be unique per namespace.`,\n        );\n      }\n    }\n    result[kind] = { ...attachedForKind, ...columnForKind };\n  }\n  return result;\n}\n\nconst JSONB_CODEC_ID = 'pg/jsonb@1';\nconst JSONB_NATIVE_TYPE = 'jsonb';\n\nfunction resolveModelNamespaceId(\n  model: ModelNode,\n  modelNameToNamespaceId: ReadonlyMap<string, string>,\n  defaultNamespaceId: string,\n): string {\n  if (model.namespaceId !== undefined && model.namespaceId.length > 0) {\n    return model.namespaceId;\n  }\n  return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;\n}\n\nfunction buildThroughDescriptor(\n  through: NonNullable<RelationNode['through']>,\n  tableNamespaceByName: ReadonlyMap<string, string>,\n  targetModel: ModelNode,\n  modelName: string,\n  fieldName: string,\n  defaultNamespaceId: string,\n): ContractRelationThrough {\n  if (!tableNamespaceByName.has(through.table)) {\n    throw new Error(\n      `buildSqlContractFromDefinition: junction table \"${through.table}\" for relation \"${modelName}.${fieldName}\" is not a declared model.`,\n    );\n  }\n  // Junction table names are unique per namespace, not globally. Prefer the\n  // junction's own declared namespace (carried on the through node); fall back to\n  // the target's default namespace. Resolving by bare table name would pick the\n  // wrong namespace when the same junction table name exists in two namespaces.\n  const namespaceId = through.namespaceId ?? defaultNamespaceId;\n\n  return {\n    table: through.table,\n    namespaceId,\n    parentColumns: through.parentColumns,\n    childColumns: through.childColumns,\n    targetColumns: targetColumnsForJunction(targetModel, fieldName),\n  };\n}\n\nfunction targetColumnsForJunction(targetModel: ModelNode, fieldName: string): readonly string[] {\n  const primaryKeyColumns = targetModel.id?.columns;\n  if (primaryKeyColumns && primaryKeyColumns.length > 0) {\n    return primaryKeyColumns;\n  }\n  const firstUnique = targetModel.uniques?.find((u) => u.columns.length > 0);\n  if (firstUnique) {\n    return firstUnique.columns;\n  }\n  throw new Error(\n    `M:N target model \"${targetModel.modelName}\" (relation field \"${fieldName}\") has no primary id or unique key to derive junction targetColumns.`,\n  );\n}\n\nfunction buildStorageColumn(\n  field: FieldNode | ValueObjectFieldNode,\n  storageValueSetRef: ValueSetRef | undefined,\n  codecLookup?: CodecLookup,\n): StorageColumn {\n  if (isValueObjectField(field)) {\n    const encodedDefault =\n      field.default !== undefined\n        ? encodeColumnDefault(field.default, JSONB_CODEC_ID, codecLookup)\n        : undefined;\n\n    return {\n      nativeType: JSONB_NATIVE_TYPE,\n      codecId: JSONB_CODEC_ID,\n      nullable: field.nullable,\n      ...ifDefined('default', encodedDefault),\n    };\n  }\n\n  const codecId = field.descriptor.codecId;\n  const encodedDefault =\n    field.default !== undefined\n      ? encodeColumnDefault(field.default, codecId, codecLookup, field.many === true)\n      : undefined;\n\n  // `storageValueSetRef` (derived from an `enumTypeHandle`) takes precedence\n  // when present — the established domain-enum path. `field.descriptor.valueSet`\n  // is the fallback: set by an entity-ref type constructor (e.g. `pg.enum(Ref)`)\n  // that resolved the field's type against a value-set-deriving entity with no\n  // domain enum involved. A field carries at most one of the two in practice.\n  const valueSet = storageValueSetRef ?? field.descriptor.valueSet;\n\n  return {\n    nativeType: field.descriptor.nativeType,\n    codecId,\n    nullable: field.nullable,\n    ...(field.many ? { many: true as const } : {}),\n    ...ifDefined('typeParams', field.descriptor.typeParams),\n    ...ifDefined('default', encodedDefault),\n    ...ifDefined('typeRef', field.descriptor.typeRef),\n    ...ifDefined('valueSet', valueSet),\n  };\n}\n\nfunction buildDomainField(\n  field: FieldNode | ValueObjectFieldNode,\n  column: StorageColumn,\n  domainValueSetRef: ValueSetRef | undefined,\n): ContractField {\n  if (isValueObjectField(field)) {\n    return {\n      type: { kind: 'valueObject', name: field.valueObjectName },\n      nullable: field.nullable,\n      ...(field.many ? { many: true } : {}),\n    };\n  }\n\n  return {\n    type: {\n      kind: 'scalar',\n      codecId: column.codecId,\n      ...ifDefined('typeParams', column.typeParams),\n    },\n    nullable: column.nullable,\n    ...(field.many ? { many: true } : {}),\n    ...ifDefined('valueSet', domainValueSetRef),\n  };\n}\n\nfunction collectStorageNamespaceCoordinateIds(definition: ContractDefinition): Set<string> {\n  const ids = new Set<string>();\n  ids.add(definition.target.defaultNamespaceId);\n  for (const id of definition.namespaces ?? []) {\n    if (id.length > 0) {\n      ids.add(id);\n    }\n  }\n  for (const model of definition.models) {\n    if (model.namespaceId !== undefined && model.namespaceId.length > 0) {\n      ids.add(model.namespaceId);\n    }\n  }\n  for (const id of Object.keys(definition.attachedEntities ?? {})) {\n    if (id.length > 0) {\n      ids.add(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Entry kinds the framework assembler itself manages (`table` from models,\n * `valueSet` from `enums` and attached-entity value-set derivation). A\n * pack-attached entity claiming one of these would silently clobber or be\n * clobbered by the managed slot, so it is rejected outright.\n */\nconst MANAGED_ENTRY_KINDS = new Set([tableEntityKind.kind, valueSetEntityKind.kind]);\n\nfunction assertNoManagedEntityKinds(\n  namespaceId: string,\n  entitiesForNs: Readonly<Record<string, unknown>> | undefined,\n): void {\n  if (entitiesForNs === undefined) return;\n  for (const kind of Object.keys(entitiesForNs)) {\n    if (MANAGED_ENTRY_KINDS.has(kind)) {\n      throw new Error(\n        `buildSqlContractFromDefinition: attached entity in namespace \"${namespaceId}\" declares entry kind \"${kind}\", which is managed by the framework (table/valueSet) and cannot be attached.`,\n      );\n    }\n  }\n}\n\n/**\n * Walks the flat `entityTypes` namespace tree contributed by the target pack\n * and every extension pack, indexing descriptors by their `discriminator` —\n * the same string a pack entity's entries-map key (`entries.<kind>`) uses.\n * Mirrors `contract-psl`'s `buildEntityTypesByDiscriminator`, recomposed here\n * from the packs `ContractDefinition` already carries (`target` +\n * `extensionPacks`) since the TS assembler has no single pre-merged\n * `AuthoringContributions` input to read the way the PSL interpreter does.\n */\nfunction collectEntityTypeDescriptorsByDiscriminator(\n  definition: ContractDefinition,\n): ReadonlyMap<string, AuthoringEntityTypeDescriptor> {\n  const result = new Map<string, AuthoringEntityTypeDescriptor>();\n  const walk = (namespace: AuthoringEntityTypeNamespace): void => {\n    for (const value of Object.values(namespace)) {\n      if (isAuthoringEntityTypeDescriptor(value)) {\n        result.set(value.discriminator, value);\n      } else {\n        walk(value);\n      }\n    }\n  };\n  const components = [definition.target, ...Object.values(definition.extensionPacks ?? {})];\n  for (const component of components) {\n    const entityTypes = component.authoring?.entityTypes;\n    if (entityTypes !== undefined) {\n      walk(entityTypes);\n    }\n  }\n  return result;\n}\n\n/**\n * Derives value-sets for every pack entity declared in one namespace,\n * reusing the same `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook\n * `contract-psl`'s `lowerExtensionBlocksForNamespace` folds into\n * `entries.valueSet` on the PSL path — so a TS-attached entity (e.g. a\n * native enum) gets its value-set the same way. Entity kinds with no\n * registered descriptor, or whose descriptor output doesn't derive a\n * value-set, contribute nothing.\n */\nfunction deriveEntityValueSets(\n  entitiesForNs: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined,\n  entityTypesByDiscriminator: ReadonlyMap<string, AuthoringEntityTypeDescriptor>,\n): Record<string, StorageValueSetInput> | undefined {\n  if (entitiesForNs === undefined) return undefined;\n  let result: Record<string, StorageValueSetInput> | undefined;\n  for (const [kind, entitiesByName] of Object.entries(entitiesForNs)) {\n    const descriptor = entityTypesByDiscriminator.get(kind);\n    if (descriptor === undefined) continue;\n    for (const [name, entity] of Object.entries(entitiesByName)) {\n      const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);\n      if (derivedValueSet === undefined) continue;\n      result ??= {};\n      result[name] = derivedValueSet;\n    }\n  }\n  return result;\n}\n\n/**\n * Merges a namespace's `enumType()`-derived value-sets with its pack-entity-\n * derived value-sets. Both land in the same `entries.valueSet[name]` slot —\n * which drives value-set → codec typing and the domain-enum CHECK — so a\n * same-named entry in both would let one silently overwrite the other and\n * corrupt whichever column resolves against it. The same collision class the\n * `mergeColumnAndAttachedEntities` guard rejects; the PSL path already hard-errors\n * on the equivalent (`interpretPslDocumentToSqlContract`). Reject it here too.\n */\nfunction mergeNamespaceValueSets(\n  namespaceId: string,\n  enumValueSets: Record<string, StorageValueSetInput> | undefined,\n  packValueSets: Record<string, StorageValueSetInput> | undefined,\n): Record<string, StorageValueSetInput> {\n  if (enumValueSets !== undefined && packValueSets !== undefined) {\n    for (const name of Object.keys(packValueSets)) {\n      if (Object.hasOwn(enumValueSets, name)) {\n        throw new Error(\n          `buildSqlContractFromDefinition: value-set \"${name}\" in namespace \"${namespaceId}\" is derived from both an enum and a pack entity — names must be unique per namespace.`,\n        );\n      }\n    }\n  }\n  return { ...enumValueSets, ...packValueSets };\n}\n\nfunction ensureUnboundNamespaceSlot(\n  namespaces: SqlStorageInput['namespaces'],\n  createNamespace: ContractDefinition['createNamespace'],\n): SqlStorageInput['namespaces'] {\n  if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) {\n    return namespaces;\n  }\n  const unboundInput: SqlNamespaceInput = {\n    id: UNBOUND_NAMESPACE_ID,\n    entries: { table: {} },\n  };\n  const unbound = createNamespace(unboundInput);\n  return {\n    [UNBOUND_NAMESPACE_ID]: unbound,\n    ...namespaces,\n  };\n}\n\nexport function buildSqlContractFromDefinition(\n  definition: ContractDefinition,\n  codecLookup?: CodecLookup,\n): Contract<SqlStorage> {\n  const target = definition.target.targetId;\n  const defaultNamespaceId = definition.target.defaultNamespaceId;\n  const qualifyColumnType = resolveColumnTypeQualifier(definition.target);\n  const targetFamily = 'sql';\n  const resolveNamespaceId = (m: ModelNode): string =>\n    m.namespaceId !== undefined && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId;\n  const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));\n  const tableNamespaceByName = new Map(\n    definition.models.map((m) => [\n      m.tableName,\n      m.namespaceId !== undefined && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId,\n    ]),\n  );\n  const modelsByCoordinate = new Map(\n    definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]),\n  );\n\n  const tablesByNamespace: Record<string, Record<string, StorageTableInput>> = {};\n  const modelNameToNamespaceId = new Map<string, string>();\n  const executionDefaults: ExecutionMutationDefault[] = [];\n  const modelsByNamespace: Record<string, Record<string, ContractModel>> = {};\n  const collectedColumnEntities: CollectedColumnEntities = {};\n  const rootEntries: Array<{\n    readonly tableName: string;\n    readonly namespaceId: string;\n    readonly ref: CrossReference;\n  }> = [];\n\n  for (const semanticModel of definition.models) {\n    const tableName = semanticModel.tableName;\n    const namespaceId =\n      semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0\n        ? semanticModel.namespaceId\n        : defaultNamespaceId;\n    modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);\n    // STI variants share the base table; the base model already owns this\n    // table name and its root, so the variant contributes neither.\n    if (!semanticModel.sharesBaseTable) {\n      rootEntries.push({\n        tableName,\n        namespaceId,\n        ref: crossRef(semanticModel.modelName, namespaceId),\n      });\n    }\n\n    // --- Build storage table ---\n\n    const columns: Record<string, StorageColumn> = {};\n    const fieldToColumn: Record<string, string> = {};\n    const domainFields: Record<string, ContractField> = {};\n    const domainFieldRefs: Record<string, DomainFieldRef> = {};\n    const checksForTable: CheckConstraintInput[] = [];\n\n    for (const field of semanticModel.fields) {\n      const executionDefaultPhases =\n        field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate\n          ? field.executionDefaults\n          : undefined;\n      if (executionDefaultPhases) {\n        if (field.default !== undefined) {\n          throw new Error(\n            `Field \"${semanticModel.modelName}.${field.fieldName}\" cannot define both default and executionDefaults.`,\n          );\n        }\n        if (field.nullable) {\n          throw new Error(\n            `Field \"${semanticModel.modelName}.${field.fieldName}\" cannot be nullable when executionDefaults are present.`,\n          );\n        }\n      }\n\n      const enumHandle = !isValueObjectField(field) ? field.enumTypeHandle : undefined;\n      // Authored enums are always registered under the contract's defaultNamespaceId\n      // (see the enum registration loop below), so refs must point there regardless\n      // of which namespace the consuming model lives in.\n      const storageValueSetRef: ValueSetRef | undefined =\n        enumHandle !== undefined\n          ? {\n              plane: 'storage',\n              entityKind: 'valueSet',\n              namespaceId: defaultNamespaceId,\n              entityName: enumHandle.enumName,\n            }\n          : undefined;\n      const domainValueSetRef: ValueSetRef | undefined =\n        enumHandle !== undefined\n          ? {\n              plane: 'domain',\n              entityKind: 'enum',\n              namespaceId: defaultNamespaceId,\n              entityName: enumHandle.enumName,\n            }\n          : undefined;\n\n      // A field authored through a deferred entity-ref column helper (e.g.\n      // `pg.enum(handle)`) carries `descriptor.entityRef`: the referenced\n      // entity is collected into `collectedColumnEntities` (folded into the\n      // same `entries.<kind>` + `entries.valueSet` assembly an entities-channel\n      // attachment goes through) and the descriptor is resolved\n      // against this field's now-known `namespaceId` — the builder call that\n      // produced it ran before the enclosing model associated one. The\n      // descriptor is then handed to the target's `qualifyColumnType` hook,\n      // which schema-qualifies a native-enum column's type name for its\n      // namespace. Keying off the codec id (inside the hook) catches both the\n      // TS `pg.enum(handle)` path (via `entityRef`) and the PSL `pg.enum(Ref)`\n      // path (resolved inline in the interpreter, no `entityRef`). Because the\n      // storage column is built from this qualified descriptor and the domain\n      // field derives its `type.typeParams` from that column, both come out\n      // qualified in this single pass.\n      let resolvedField: FieldNode | ValueObjectFieldNode = field;\n      if (!isValueObjectField(field)) {\n        let descriptor = field.descriptor;\n        const entityRef = descriptor.entityRef;\n        if (entityRef !== undefined) {\n          collectEntityFromColumn(collectedColumnEntities, namespaceId, entityRef);\n          descriptor = resolveEntityRefDescriptor(descriptor, namespaceId);\n        }\n        descriptor = qualifyColumnDescriptor(descriptor, namespaceId, qualifyColumnType);\n        if (descriptor !== field.descriptor) {\n          resolvedField = { ...field, descriptor };\n        }\n      }\n\n      const column = buildStorageColumn(resolvedField, storageValueSetRef, codecLookup);\n      columns[field.columnName] = column;\n      fieldToColumn[field.fieldName] = field.columnName;\n\n      // A domain enum (`storageValueSetRef`, from an `enumType()` handle) is\n      // stored as a plain scalar column (`text`, `int4`, …) with no native\n      // type of its own to enforce membership, so it needs an explicit\n      // CHECK — scalar or array, since a `text[]` array has no element-level\n      // enforcement either. A value set resolved by an entity-ref type\n      // constructor (`field.descriptor.valueSet`, e.g. `pg.enum(Ref)`) binds\n      // the column to a codec/native-type pairing that IS the storage-level\n      // enforcement (a Postgres native enum type, or another target's\n      // equivalent) — including array columns, since the target enforces\n      // membership on every element of a native-typed array — so no CHECK\n      // for those.\n      if (column.valueSet !== undefined && storageValueSetRef !== undefined) {\n        checksForTable.push({\n          name: `${tableName}_${field.columnName}_check`,\n          column: field.columnName,\n          valueSet: column.valueSet,\n        });\n      }\n\n      domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);\n\n      if (isValueObjectField(field)) {\n        domainFieldRefs[field.fieldName] = {\n          kind: 'valueObject',\n          name: field.valueObjectName,\n          ...(field.many ? { many: true } : {}),\n        };\n      } else if (field.many) {\n        domainFieldRefs[field.fieldName] = { kind: 'scalar', many: true };\n      }\n\n      if (executionDefaultPhases) {\n        executionDefaults.push({\n          ref: { namespace: namespaceId, table: tableName, column: field.columnName },\n          ...ifDefined('onCreate', executionDefaultPhases.onCreate),\n          ...ifDefined('onUpdate', executionDefaultPhases.onUpdate),\n        });\n      }\n    }\n\n    const authoringForeignKeys: readonly ForeignKeyAuthoringInput[] = (\n      semanticModel.foreignKeys ?? []\n    ).map((fk) => {\n      if (fk.references.spaceId !== undefined) {\n        // Cross-space FK: the target lives in a different contract space.\n        // Skip local model lookup and carry the spaceId coordinate through.\n        const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;\n        return {\n          source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },\n          target: {\n            namespaceId: asNamespaceId(targetNamespaceId),\n            tableName: fk.references.table,\n            columns: fk.references.columns,\n            spaceId: fk.references.spaceId,\n          },\n          ...applyFkDefaults(\n            {\n              ...ifDefined('constraint', fk.constraint),\n              ...ifDefined('index', fk.index),\n            },\n            definition.foreignKeyDefaults,\n          ),\n          ...ifDefined('name', fk.name),\n          ...ifDefined('onDelete', fk.onDelete),\n          ...ifDefined('onUpdate', fk.onUpdate),\n        };\n      }\n\n      const targetModel = assertKnownTargetModel(\n        modelsByName,\n        modelsByCoordinate,\n        semanticModel.modelName,\n        fk.references.model,\n        fk.references.namespaceId,\n        'Foreign key',\n      );\n      assertTargetTableMatches(\n        semanticModel.modelName,\n        targetModel,\n        fk.references.table,\n        'Foreign key',\n      );\n      const targetNamespaceId =\n        fk.references.namespaceId ??\n        (targetModel.namespaceId !== undefined && targetModel.namespaceId.length > 0\n          ? targetModel.namespaceId\n          : defaultNamespaceId);\n      return {\n        source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },\n        target: {\n          namespaceId: asNamespaceId(targetNamespaceId),\n          tableName: fk.references.table,\n          columns: fk.references.columns,\n        },\n        ...applyFkDefaults(\n          {\n            ...ifDefined('constraint', fk.constraint),\n            ...ifDefined('index', fk.index),\n          },\n          definition.foreignKeyDefaults,\n        ),\n        ...ifDefined('name', fk.name),\n        ...ifDefined('onDelete', fk.onDelete),\n        ...ifDefined('onUpdate', fk.onUpdate),\n      };\n    });\n\n    // STI variants share the base table: their columns are already\n    // materialised onto the base `ModelNode`, so the variant builds a domain\n    // model (below) but no storage table of its own.\n    if (!semanticModel.sharesBaseTable) {\n      const uniques = (semanticModel.uniques ?? []).map((u) => ({\n        columns: u.columns,\n        ...ifDefined('name', u.name),\n      }));\n      const declaredIndexes = (semanticModel.indexes ?? []).map((i) => ({\n        columns: i.columns,\n        ...ifDefined('name', i.name),\n        ...ifDefined('type', i.type),\n        ...ifDefined('options', i.options),\n      }));\n      const primaryKey = semanticModel.id\n        ? { columns: semanticModel.id.columns, ...ifDefined('name', semanticModel.id.name) }\n        : undefined;\n      // FK1: lower each FK's `constraint`/`index` authoring intent into\n      // discrete persisted entities here — the one place a table's full\n      // constraint context (its own declared indexes/uniques/primary key)\n      // is available. A `constraint: false` FK contributes no\n      // `foreignKeys[]` entry; an `index: true` FK not already backed by a\n      // declared index/unique/primary-key contributes a named `indexes[]`\n      // entry. This authoring pipeline is shared by both the TS DSL and the\n      // PSL interpreter (which calls `buildSqlContractFromDefinition`\n      // directly), so both authoring surfaces materialize identically.\n      const { foreignKeys, indexes } = materializeForeignKeysAndIndexes(\n        tableName,\n        authoringForeignKeys,\n        declaredIndexes,\n        uniques,\n        primaryKey,\n      );\n\n      const tableInput: StorageTableInput = {\n        columns,\n        ...ifDefined('control', semanticModel.control),\n        uniques,\n        indexes,\n        foreignKeys,\n        ...(primaryKey ? { primaryKey } : {}),\n        ...(checksForTable.length > 0 ? { checks: checksForTable } : {}),\n      };\n\n      let nsTables = tablesByNamespace[namespaceId];\n      if (nsTables === undefined) {\n        nsTables = {};\n        tablesByNamespace[namespaceId] = nsTables;\n      }\n      if (nsTables[tableName] !== undefined) {\n        throw new Error(\n          `buildSqlContractFromDefinition: duplicate table \"${tableName}\" in namespace \"${namespaceId}\".`,\n        );\n      }\n      nsTables[tableName] = tableInput;\n    }\n\n    // --- Build contract model ---\n\n    const storageFields: Record<string, { readonly column: string }> = {};\n    for (const [fieldName, columnName] of Object.entries(fieldToColumn)) {\n      storageFields[fieldName] = { column: columnName };\n    }\n\n    const columnToField = new Map(\n      Object.entries(fieldToColumn).map(([field, col]) => [col, field]),\n    );\n    const modelRelations: Record<string, ContractRelation> = {};\n    for (const relation of semanticModel.relations ?? []) {\n      // Cross-space relations have `spaceId` set — the target model lives in\n      // a different contract space, so skip local model lookup and validation.\n      if (relation.spaceId !== undefined) {\n        const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;\n        modelRelations[relation.fieldName] = {\n          to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),\n          // Cross-space belongsTo relations are always N:1 (the FK-owning side).\n          cardinality: 'N:1',\n          on: {\n            localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),\n            // For cross-space targets the lowering carries field names directly\n            // (no fieldToColumn map available for the remote model).\n            targetFields: relation.on.childColumns,\n          },\n        };\n        continue;\n      }\n\n      const targetModel = assertKnownTargetModel(\n        modelsByName,\n        modelsByCoordinate,\n        semanticModel.modelName,\n        relation.toModel,\n        relation.toNamespaceId,\n        'Relation',\n      );\n      assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, 'Relation');\n\n      const targetColumnToField = new Map(\n        targetModel.fields.map((f) => [f.columnName, f.fieldName]),\n      );\n\n      const to = crossRef(\n        relation.toModel,\n        relation.toNamespaceId !== undefined && relation.toNamespaceId.length > 0\n          ? relation.toNamespaceId\n          : resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),\n      );\n      const on = {\n        localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),\n        targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col),\n      };\n\n      if (relation.cardinality === 'N:M') {\n        if (!relation.through) {\n          throw new Error(\n            `Relation \"${semanticModel.modelName}.${relation.fieldName}\" with cardinality \"N:M\" requires through metadata`,\n          );\n        }\n        modelRelations[relation.fieldName] = {\n          to,\n          cardinality: 'N:M',\n          on,\n          through: buildThroughDescriptor(\n            relation.through,\n            tableNamespaceByName,\n            targetModel,\n            semanticModel.modelName,\n            relation.fieldName,\n            defaultNamespaceId,\n          ),\n        };\n      } else {\n        modelRelations[relation.fieldName] = { to, cardinality: relation.cardinality, on };\n      }\n    }\n\n    let namespaceModels = modelsByNamespace[namespaceId];\n    if (namespaceModels === undefined) {\n      namespaceModels = {};\n      modelsByNamespace[namespaceId] = namespaceModels;\n    }\n    namespaceModels[semanticModel.modelName] = {\n      storage: {\n        table: tableName,\n        namespaceId,\n        fields: storageFields,\n      },\n      fields: domainFields,\n      relations: modelRelations,\n    };\n  }\n\n  // --- Assemble contract ---\n\n  // Aggregate roots are keyed by bare storage table name. When two models in\n  // different namespaces map to the same bare table name, the bare key would\n  // collide (last write wins, silently dropping a root), so those entries fall\n  // back to a namespace-qualified key. Single-namespace contracts never\n  // collide and keep their bare keys unchanged.\n  const rootTableNameCounts = new Map<string, number>();\n  for (const entry of rootEntries) {\n    rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);\n  }\n  const roots: Record<string, CrossReference> = {};\n  for (const entry of rootEntries) {\n    const key =\n      (rootTableNameCounts.get(entry.tableName) ?? 0) > 1\n        ? `${entry.namespaceId}.${entry.tableName}`\n        : entry.tableName;\n    roots[key] = entry.ref;\n  }\n\n  // Normalise raw codec-triple inputs to the `kind: 'codec-instance'`\n  // discriminator shape before hashing so the storageHash matches the\n  // persisted JSON envelope produced from the SqlStorage class instance\n  // (which always carries the discriminator).\n  const rawStorageTypes = definition.storageTypes ?? {};\n  const documentTypes: Record<string, StorageTypeInstance> = Object.fromEntries(\n    Object.entries(rawStorageTypes).map(([name, entry]) => {\n      if ((entry as { kind?: unknown }).kind === 'codec-instance') return [name, entry];\n      return [\n        name,\n        toStorageTypeInstance({\n          codecId: entry.codecId,\n          nativeType: entry.nativeType,\n          typeParams: (entry as { typeParams?: Record<string, unknown> }).typeParams ?? {},\n        }),\n      ];\n    }),\n  );\n  const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);\n\n  // Build per-namespace registries for `enumType()` handles.\n  // All authored enums target the contract's default namespace.\n  const domainEnumsByNs: Record<string, Record<string, ContractEnum>> = {};\n  const storageValueSetsByNs: Record<string, Record<string, StorageValueSetInput>> = {};\n  for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {\n    if (enumName !== handle.enumName) {\n      throw new Error(\n        `enum declaration key \"${enumName}\" must match enumType name \"${handle.enumName}\". Aliases are not supported.`,\n      );\n    }\n    const nsId = defaultNamespaceId;\n    let domainSlot = domainEnumsByNs[nsId];\n    if (domainSlot === undefined) {\n      domainSlot = {};\n      domainEnumsByNs[nsId] = domainSlot;\n    }\n    domainSlot[enumName] = {\n      codecId: handle.codecId,\n      members: handle.enumMembers.map((m) => ({\n        name: m.name,\n        value: encodeViaCodec(m.value, handle.codecId, codecLookup),\n      })),\n    };\n\n    let storageSlot = storageValueSetsByNs[nsId];\n    if (storageSlot === undefined) {\n      storageSlot = {};\n      storageValueSetsByNs[nsId] = storageSlot;\n    }\n    storageSlot[enumName] = {\n      kind: 'valueSet',\n      values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup)),\n    };\n  }\n\n  const { createNamespace } = definition;\n  const entityTypesByDiscriminator = collectEntityTypeDescriptorsByDiscriminator(definition);\n  const namespaces: SqlStorageInput['namespaces'] = Object.fromEntries(\n    [...namespaceCoordinateIds].sort().map((id) => {\n      const entitiesForNs = mergeColumnAndAttachedEntities(\n        id,\n        definition.attachedEntities?.[id],\n        collectedColumnEntities[id],\n      );\n      assertNoManagedEntityKinds(id, entitiesForNs);\n\n      const enumValueSetEntries = storageValueSetsByNs[id];\n      const packValueSetEntries = deriveEntityValueSets(entitiesForNs, entityTypesByDiscriminator);\n      const valueSetEntries =\n        enumValueSetEntries !== undefined || packValueSetEntries !== undefined\n          ? mergeNamespaceValueSets(id, enumValueSetEntries, packValueSetEntries)\n          : undefined;\n\n      const nsInput: SqlNamespaceInput = {\n        id,\n        entries: {\n          table: tablesByNamespace[id] ?? {},\n          ...entitiesForNs,\n          ...(valueSetEntries !== undefined && Object.keys(valueSetEntries).length > 0\n            ? { valueSet: valueSetEntries }\n            : {}),\n        },\n      };\n      return [id, createNamespace(nsInput)];\n    }),\n  );\n  const storageWithoutHash = {\n    ...(Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {}),\n    namespaces:\n      defaultNamespaceId === UNBOUND_NAMESPACE_ID\n        ? ensureUnboundNamespaceSlot(namespaces, createNamespace)\n        : namespaces,\n  };\n  const storageHash: StorageHashBase<string> = definition.storageHash\n    ? coreHash(definition.storageHash)\n    : computeStorageHash({\n        target,\n        targetFamily,\n        storage: storageWithoutHash as Record<string, unknown>,\n        ...sqlContractCanonicalizationHooks,\n      });\n  const storage = new SqlStorage({ ...storageWithoutHash, storageHash });\n\n  const executionSection =\n    executionDefaults.length > 0\n      ? {\n          mutations: {\n            defaults: executionDefaults.sort((a, b) => {\n              const tableCompare = a.ref.table.localeCompare(b.ref.table);\n              if (tableCompare !== 0) {\n                return tableCompare;\n              }\n              return a.ref.column.localeCompare(b.ref.column);\n            }),\n          },\n        }\n      : undefined;\n\n  const extensionNamespaces = definition.extensionPacks\n    ? Object.values(definition.extensionPacks).map((pack) => pack.id)\n    : undefined;\n\n  const extensionPacks: Record<string, unknown> = { ...(definition.extensionPacks || {}) };\n  if (extensionNamespaces) {\n    for (const namespace of extensionNamespaces) {\n      if (!Object.hasOwn(extensionPacks, namespace)) {\n        extensionPacks[namespace] = {};\n      }\n    }\n  }\n\n  const extensionPackCapabilitySources = definition.extensionPacks\n    ? Object.values(definition.extensionPacks).map(\n        (pack) => pack.capabilities as CapabilityMatrix | undefined,\n      )\n    : [];\n  const capabilities = mergeCapabilityMatrices(\n    definition.target.capabilities as CapabilityMatrix | undefined,\n    ...extensionPackCapabilitySources,\n  );\n  // Internal `profileHash` computation is unchanged from `origin/main`: it\n  // continues to fingerprint the author-declared capability subset. With\n  // `capabilities` removed from the `defineContract` input that subset is\n  // now always empty, so the hash naturally stabilises at `hash({})`.\n  const profileHash = computeProfileHash({\n    target,\n    targetFamily,\n    capabilities: {},\n  });\n\n  const executionWithHash = executionSection\n    ? {\n        ...executionSection,\n        executionHash: computeExecutionHash({ target, targetFamily, execution: executionSection }),\n      }\n    : undefined;\n\n  const valueObjects: Record<string, ContractValueObject> | undefined =\n    definition.valueObjects && definition.valueObjects.length > 0\n      ? Object.fromEntries(\n          definition.valueObjects.map((vo) => [\n            vo.name,\n            {\n              fields: Object.fromEntries(\n                vo.fields.map((f) => [\n                  f.fieldName,\n                  isValueObjectField(f)\n                    ? {\n                        type: { kind: 'valueObject' as const, name: f.valueObjectName },\n                        nullable: f.nullable,\n                        ...(f.many ? { many: true } : {}),\n                      }\n                    : {\n                        type: {\n                          kind: 'scalar' as const,\n                          codecId: f.descriptor.codecId,\n                          ...ifDefined('typeParams', f.descriptor.typeParams),\n                        },\n                        nullable: f.nullable,\n                      },\n                ]),\n              ),\n            },\n          ]),\n        )\n      : undefined;\n\n  const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));\n  if (domainNamespaceIds.size === 0) {\n    domainNamespaceIds.add(defaultNamespaceId);\n  }\n  if (valueObjects !== undefined) {\n    domainNamespaceIds.add(defaultNamespaceId);\n  }\n  for (const nsId of Object.keys(domainEnumsByNs)) {\n    domainNamespaceIds.add(nsId);\n  }\n  const domainNamespaces = Object.fromEntries(\n    [...domainNamespaceIds].sort().map((namespaceId) => {\n      const modelsInNs = modelsByNamespace[namespaceId] ?? {};\n      const enumsInNs = domainEnumsByNs[namespaceId];\n      const namespaceSlice = {\n        models: modelsInNs,\n        ...(namespaceId === defaultNamespaceId && valueObjects !== undefined\n          ? { valueObjects }\n          : {}),\n        ...(enumsInNs !== undefined && Object.keys(enumsInNs).length > 0\n          ? { enum: enumsInNs }\n          : {}),\n      };\n      return [namespaceId, namespaceSlice];\n    }),\n  );\n\n  const contract: Contract<SqlStorage> = {\n    target,\n    targetFamily,\n    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),\n    domain: { namespaces: domainNamespaces },\n    roots,\n    storage,\n    ...(executionWithHash ? { execution: executionWithHash } : {}),\n    extensionPacks,\n    capabilities,\n    profileHash,\n    meta: {},\n  };\n\n  assertStorageSemantics(definition, contract);\n\n  return contract;\n}\n"],"mappings":"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"}

package/dist/config-types.d.mts

@@ -1,4 +1,5 @@
 import { Contract, ControlPolicy } from "@prisma-next/contract/types";
+import { SqlNamespaceBase, SqlNamespaceInput } from "@prisma-next/sql-contract/types";
 import { ContractConfig, ContractConfig as ContractConfig$1 } from "@prisma-next/config/config-types";
 import { TargetPackRef } from "@prisma-next/framework-components/components";
 
@@ -9,6 +10,7 @@ interface TypeScriptContractSpecifierOptions {
 declare function emptyContract(options: {
   readonly output?: string;
   readonly target: TargetPackRef<'sql', string>;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly defaultControlPolicy?: ControlPolicy;
 }): ContractConfig$1;
 declare function typescriptContract(contract: Contract, output?: string, options?: TypeScriptContractSpecifierOptions): ContractConfig$1;

package/dist/config-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config-types.d.mts","names":[],"sources":["../src/config-types.ts"],"mappings":";;;;;UAsBiB,kCAAA;EAAA,SACN,oBAAA,GAAuB,aAAa;AAAA;AAAA,iBAG/B,aAAA,CAAc,OAAA;EAAA,SACnB,MAAA;EAAA,SACA,MAAA,EAAQ,aAAA;EAAA,SACR,oBAAA,GAAuB,aAAA;AAAA,IAC9B,gBAAA;AAAA,iBAYY,kBAAA,CACd,QAAA,EAAU,QAAA,EACV,MAAA,WACA,OAAA,GAAU,kCAAA,GACT,gBAAA;AAAA,iBAYa,0BAAA,CACd,YAAA,UACA,MAAA,WACA,OAAA,GAAU,kCAAA,GACT,gBAAc"}
+{"version":3,"file":"config-types.d.mts","names":[],"sources":["../src/config-types.ts"],"mappings":";;;;;;UAuBiB,kCAAA;EAAA,SACN,oBAAA,GAAuB,aAAa;AAAA;AAAA,iBAG/B,aAAA,CAAc,OAAA;EAAA,SACnB,MAAA;EAAA,SACA,MAAA,EAAQ,aAAA;EAAA,SACR,eAAA,GAAkB,KAAA,EAAO,iBAAA,KAAsB,gBAAA;EAAA,SAC/C,oBAAA,GAAuB,aAAA;AAAA,IAC9B,gBAAA;AAAA,iBAiBY,kBAAA,CACd,QAAA,EAAU,QAAA,EACV,MAAA,WACA,OAAA,GAAU,kCAAA,GACT,gBAAA;AAAA,iBAaa,0BAAA,CACd,YAAA,UACA,MAAA,WACA,OAAA,GAAU,kCAAA,GACT,gBAAc"}

package/dist/config-types.mjs

@@ -1,4 +1,4 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-CQ4u83jx.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-CAX6inbk.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { pathToFileURL } from "node:url";
 import { applySpecifierDefaultControlPolicy } from "@prisma-next/contract/apply-specifier-default-control-policy";
@@ -18,24 +18,32 @@ function defaultOutputFromContractPath(contractPath) {
 }
 function emptyContract(options) {
 	return {
-		source: { load: async () => {
-			return ok(applySpecifierDefaultControlPolicy(buildSqlContractFromDefinition({
-				target: options.target,
-				models: []
-			}), options.defaultControlPolicy));
-		} },
+		source: {
+			sourceFormat: "typescript",
+			load: async () => {
+				return ok(applySpecifierDefaultControlPolicy(buildSqlContractFromDefinition({
+					target: options.target,
+					createNamespace: options.createNamespace,
+					models: []
+				}), options.defaultControlPolicy));
+			}
+		},
 		...ifDefined("output", options.output)
 	};
 }
 function typescriptContract(contract, output, options) {
 	return {
-		source: { load: async () => ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy)) },
+		source: {
+			sourceFormat: "typescript",
+			load: async () => ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy))
+		},
 		...ifDefined("output", output)
 	};
 }
 function typescriptContractFromPath(contractPath, output, options) {
 	return {
 		source: {
+			sourceFormat: "typescript",
 			inputs: [contractPath],
 			load: async (context) => {
 				const [absolutePath] = context.resolvedInputs;