@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/{contract-builder-D4a5dT7j.mjs → contract-builder-50lF0kz1.mjs}

@@ -1,49 +1,105 @@
-import { t as providesEntityHandleLowering } from "./entity-handle-lowering-hook-DwLIKNiS.mjs";
-import { u as toStorageTypeInstance } from "./types-CUsJrvEl.mjs";
-import { n as buildSqlContractFromDefinition, r as contractError } from "./derived-checks-DFMRmiAu-DGfB8aS4.mjs";
-import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { isColumnDefault } from "@prisma/orm-framework/contract/types";
+import { d as sqlColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { t as providesEntityHandleLowering } from "./entity-handle-lowering-hook-BJZSlVVF.mjs";
+import { a as isSqlExpression, c as requireSqlExpression, r as SqlExpression, s as readSqlExpression } from "./sql-expression-CKgKznXS.mjs";
+import { t as CODEC_INSTANCE_KIND } from "./types-CTdSkl0s.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-BwA7ttZM.mjs";
+import { a as refuseTypesKey, n as buildSqlContractFromDefinition, r as contractError, s as toOneNullabilityContradictionMessage } from "./derived-checks-D5HVRvqN-BJx1gwPA.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { assembleDataTypeSupport, assertNoCrossRegistryCollisions, assertTypeAliasesValid, describeAdmittedForms, instantiateAuthoringFieldPreset, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringTypeAliasDescriptor, isAuthoringTypeConstructorDescriptor, readWrittenValueAs, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
+import { dataTypeId, numeralText } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { bindEnumType, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member } from "@prisma/orm-framework/contract-authoring";
-//#region ../../../2-sql/2-authoring/contract-ts/dist/contract-builder.mjs
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { isColumnDefault } from "@prisma/orm-framework/contract/types";
+import { assembleGeneratorFunctions, createGeneratorHelpers } from "@prisma/orm-framework/components/components";
+import { assertSafeAuthoringHelperKey, bindEnumType, composePackAuthoringNamespace, createEntityHelpersFromNamespace, createFieldHelpersFromNamespace, enumType, isEnumTypeHandle, member, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { UNBOUND_PSL_NAMESPACE_NAME } from "@prisma/orm-framework/components/psl-ast";
+//#region ../../../2-sql-family/2-authoring/contract-ts/dist/contract-builder.mjs
+/** The written value a TypeScript argument stands for: a number, string or boolean as written in PSL, and a `sql` value as a `sql` literal of its text. */
+function writtenValueOf(value) {
+	if (typeof value === "number") return {
+		kind: "number",
+		text: numeralText(value)
+	};
+	if (typeof value === "string") return {
+		kind: "string",
+		text: value
+	};
+	if (typeof value === "boolean") return {
+		kind: "boolean",
+		value
+	};
+	const expression = readSqlExpression(value);
+	return expression === void 0 ? void 0 : {
+		kind: "tag",
+		tag: "sql",
+		text: expression.text
+	};
+}
+function readValueArgument(label, value, dataType, dataTypes) {
+	const refuse = (message) => {
+		throw contractError("CONTRACT.ARGUMENT_INVALID", `${label}: ${message}`, { meta: { dataType } });
+	};
+	const written = writtenValueOf(value);
+	if (written === void 0) return refuse(`Expected ${describeAdmittedForms(dataTypes, dataType)}`);
+	const read = readWrittenValueAs(dataTypes, dataType, written);
+	return read.ok ? read.value.value : refuse(read.failure.message);
+}
+/**
+* The arguments of a type constructor or field preset call as the constructor receives them: each `value` argument read as a value of its data type, through the same read and cast as a PSL argument, so both give the same parameters. ADR 129, ADR 254.
+*/
+function readValueArguments(helperPath, descriptors, args, dataTypes) {
+	return args.map((value, index) => {
+		const descriptor = descriptors?.[index];
+		if (descriptor?.kind !== "value" || value === void 0) return value;
+		return readValueArgument(descriptor.name === void 0 ? `Argument #${index + 1} of ${helperPath}` : `Argument "${descriptor.name}" of ${helperPath}`, value, dataTypeId(descriptor.dataType), dataTypes);
+	});
+}
 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 = []) {
+function createTypeHelpersFromNamespace(namespace, lookups, path = []) {
 	const helpers = {};
 	for (const [key, value] of Object.entries(namespace)) {
-		assertSafeHelperKey(key, path);
+		assertSafeAuthoringHelperKey(key, path);
 		const currentPath = [...path, key];
 		if (isAuthoringTypeConstructorDescriptor(value)) {
+			const helperPath = currentPath.join(".");
+			helpers[key] = (...written) => {
+				validateAuthoringHelperArguments(helperPath, value.args, written);
+				const args = readValueArguments(helperPath, value.args, written, lookups.dataTypes);
+				const output = instantiateAuthoringTypeConstructor(value, args);
+				validateAuthoringTypeParams(helperPath, value.output, output.typeParams, lookups.codecLookup.descriptorFor(output.codecId)?.paramsSchema);
+				return {
+					kind: CODEC_INSTANCE_KIND,
+					codecId: output.codecId,
+					typeParams: output.typeParams ?? {}
+				};
+			};
+			continue;
+		}
+		if (isAuthoringTypeAliasDescriptor(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 ?? {}
-				});
+				validateAuthoringHelperArguments(helperPath, [], args);
+				const { type, onCreate, onUpdate } = instantiateAuthoringTypeAlias(value);
+				const generatorCalls = {
+					...ifDefined("onCreate", onCreate),
+					...ifDefined("onUpdate", onUpdate)
+				};
+				return {
+					kind: CODEC_INSTANCE_KIND,
+					codecId: type.codecId,
+					typeParams: type.typeParams ?? {},
+					...Object.keys(generatorCalls).length === 0 ? {} : { generatorCalls }
+				};
 			};
 			continue;
 		}
-		helpers[key] = createTypeHelpersFromNamespace(value, currentPath);
+		helpers[key] = createTypeHelpersFromNamespace(value, lookups, currentPath);
 	}
 	return helpers;
 }
@@ -65,35 +121,60 @@ function createFieldPresetHelper(options) {
 			args = rawArgs.slice(0, -1);
 		}
 		validateAuthoringHelperArguments(options.helperPath, options.descriptor.args, args);
+		const values = readValueArguments(options.helperPath, options.descriptor.args, args, options.dataTypes);
+		const output = options.descriptor.output;
+		validateAuthoringTypeParams(options.helperPath, output, instantiateAuthoringFieldPreset(options.descriptor, values).descriptor.typeParams, options.codecLookup.descriptorFor(output.codecId)?.paramsSchema);
 		return options.build({
-			args,
+			args: values,
 			...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;
+function withGeneratorCall(state, phase, call) {
+	if (state.generatorCalls?.[phase] !== void 0 || state.executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
+		reason: "generator-phase-set-twice",
+		phase
+	} });
+	return {
+		...state,
+		generatorCalls: {
+			...state.generatorCalls,
+			[phase]: call
 		}
-		helpers[key] = createFieldHelpersFromNamespace(value, createLeafHelper, currentPath);
-	}
-	return helpers;
+	};
+}
+function withColumnDefault(state, columnDefault) {
+	if (state.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", ".default() is called on a field that already has a default. Set the default once, and do not combine .default() with a field preset or alias constant that sets one.", { meta: { reason: "default-set-twice" } });
+	return {
+		...state,
+		default: columnDefault
+	};
 }
 function toColumnDefault(value) {
+	const expression = readSqlExpression(value);
+	if (expression !== void 0) return sqlExpressionDefault(expression);
 	if (isColumnDefault(value)) return value;
 	return {
 		kind: "literal",
 		value
 	};
 }
+function sqlExpressionDefault(value) {
+	const reserved = reservedSqlDefaultText(value.text);
+	if (reserved !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Write .default(${reserved}()) instead of sql\`${reserved}()\`; ${reserved}() is a Prisma default function, not raw SQL.`, { meta: {
+		reason: "reserved-function",
+		expression: value.text
+	} });
+	const unsafe = checkSqlDefaultText(value.text);
+	if (unsafe !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", unsafe, { meta: {
+		reason: "unsafe-sql",
+		expression: value.text
+	} });
+	return {
+		kind: "function",
+		expression: value.text
+	};
+}
 var ScalarFieldBuilder = class ScalarFieldBuilder {
 	state;
 	constructor(state) {
@@ -120,40 +201,31 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 			columnName: name
 		}));
 	}
-	many() {
+	many(options) {
 		return new ScalarFieldBuilder(blindCast({
 			...this.state,
-			many: true
-		}));
-	}
-	/**
-	* Declines enforcement of generated CHECK constraints on this column.
-	* With no arguments, waives every kind the column's shape derives;
-	* with arguments, waives exactly the named kinds. Declared types are
-	* unchanged — runtime values may diverge from them once enforcement
-	* is waived.
-	*/
-	noCheck(...kinds) {
-		if (this.state.noCheck !== void 0) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", "noCheck() was already called on this field; declare every waived kind in a single call.", { meta: { reason: "duplicate-noCheck-call" } });
-		return blindCast(new ScalarFieldBuilder({
-			...this.state,
-			noCheck: kinds
+			many: { elementNullable: options?.elementsNullable === true }
 		}));
 	}
 	default(value) {
-		return new ScalarFieldBuilder({
-			...this.state,
-			default: toColumnDefault(value)
-		});
+		return blindCast(new ScalarFieldBuilder(withColumnDefault(this.state, toColumnDefault(value))));
+	}
+	/** Generates the field's value in the client when a row is created without one, with a call from `gen`, such as `gen.uuid()`. */
+	onCreate(call) {
+		return blindCast(new ScalarFieldBuilder(withGeneratorCall(this.state, "onCreate", call)));
 	}
+	/** Generates the field's value in the client every time a row is updated, with a call from `gen`, such as `gen.now()`. */
+	onUpdate(call) {
+		return blindCast(new ScalarFieldBuilder(withGeneratorCall(this.state, "onUpdate", call)));
+	}
+	/**
+	* @deprecated Write `.default(now())` or `.default(autoincrement())`, or `` .default(sql`...`) `` for any other SQL. Removed in 8.0.0.
+	*/
 	defaultSql(expression) {
-		return new ScalarFieldBuilder({
-			...this.state,
-			default: {
-				kind: "function",
-				expression
-			}
-		});
+		return blindCast(new ScalarFieldBuilder(withColumnDefault(this.state, {
+			kind: "function",
+			expression
+		})));
 	}
 	id(options) {
 		return new ScalarFieldBuilder(blindCast({
@@ -190,54 +262,59 @@ var EnumScalarFieldBuilder = class EnumScalarFieldBuilder extends ScalarFieldBui
 		this.#handle = handle;
 	}
 	default(value) {
-		return blindCast(new EnumScalarFieldBuilder({
-			...this.build(),
-			default: {
-				kind: "literal",
-				value
-			}
-		}, this.#handle));
+		return blindCast(new EnumScalarFieldBuilder(withColumnDefault(this.build(), {
+			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({
+function isTypeAliasColumnType(descriptor) {
+	return "generatorCalls" in descriptor;
+}
+const columnField = (descriptor) => {
+	if (!isTypeAliasColumnType(descriptor)) return new ScalarFieldBuilder({
 		kind: "scalar",
 		descriptor,
-		nullable: false
+		nullable: false,
+		many: false
 	});
-}
+	const { generatorCalls, ...columnType } = descriptor;
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor: blindCast(columnType),
+		nullable: false,
+		many: false,
+		...ifDefined("generatorCalls", generatorCalls)
+	});
+};
 function generatedField(spec) {
 	return new ScalarFieldBuilder({
 		kind: "scalar",
-		descriptor: {
+		descriptor: blindCast({
 			...spec.type,
 			...spec.typeParams ? { typeParams: spec.typeParams } : {}
-		},
+		}),
 		nullable: false,
+		many: 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
-	});
-}
+const namedTypeField = (handle) => new EnumScalarFieldBuilder(blindCast({
+	kind: "scalar",
+	enumHandle: handle,
+	nullable: false,
+	many: false
+}), handle);
 function buildFieldPreset(descriptor, args, namedConstraintOptions) {
 	const preset = instantiateAuthoringFieldPreset(descriptor, args);
 	return new ScalarFieldBuilder({
 		kind: "scalar",
 		descriptor: preset.descriptor,
 		nullable: preset.nullable,
+		many: false,
 		...ifDefined("default", preset.default),
 		...ifDefined("executionDefaults", preset.executionDefaults),
 		...preset.id ? { id: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {} } : {},
@@ -468,7 +545,7 @@ var ContractModelBuilder = class ContractModelBuilder {
 		}, this.attributesFactory, this.sqlFactory, this.spaceId, this.tableName);
 	}
 	attributes(specOrFactory) {
-		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory, this.spaceId, this.tableName);
+		return blindCast(new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory, this.spaceId, this.tableName));
 	}
 	sql(specOrFactory) {
 		const nextTableName = typeof specOrFactory !== "function" ? specOrFactory.table : this.tableName;
@@ -564,6 +641,7 @@ function belongsTo(toModel, options) {
 		toModel: normalizeRelationModelSource(toModel),
 		from: options.from,
 		to: options.to,
+		...ifDefined("optional", options.optional),
 		...crossSpaceCoordinate !== void 0 ? crossSpaceCoordinate : {}
 	});
 }
@@ -636,42 +714,18 @@ function applyNaming(name, strategy) {
 	}
 	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;
+	return composePackAuthoringNamespace(components, "type");
 }
 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;
+	return composePackAuthoringNamespace(components, "field");
 }
 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;
+	return composePackAuthoringNamespace(components, "entityTypes");
 }
 /**
 * Reserved top-level keys on the composed helpers surface — the
-* built-in `model` / `rel` helpers, the `field` / `type` namespace
+* built-in `model` / `rel` helpers, the `field` / `type` / `gen` 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
@@ -682,7 +736,8 @@ const RESERVED_HELPER_KEYS = [
 	"field",
 	"model",
 	"rel",
-	"type"
+	"type",
+	"gen"
 ];
 function assertNoBuiltInEntityCollisions(namespace) {
 	const collisions = Object.keys(namespace).filter((name) => RESERVED_HELPER_KEYS.includes(name));
@@ -691,10 +746,12 @@ function assertNoBuiltInEntityCollisions(namespace) {
 		reservedKeys: RESERVED_HELPER_KEYS
 	} });
 }
-function createComposedFieldHelpers(fieldNamespace) {
+function createComposedFieldHelpers(fieldNamespace, lookups) {
 	const helperNamespace = createFieldHelpersFromNamespace(fieldNamespace, ({ helperPath, descriptor }) => createFieldPresetHelper({
 		helperPath,
 		descriptor,
+		codecLookup: lookups.codecLookup,
+		dataTypes: lookups.dataTypes,
 		build: ({ args, namedConstraintOptions }) => buildFieldPreset(descriptor, args, namedConstraintOptions)
 	}));
 	const coreFieldHelpers = {
@@ -721,16 +778,28 @@ function createComposedAuthoringHelpers(options) {
 	const entityNamespace = composeEntityNamespace(components);
 	assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityNamespace);
 	assertNoBuiltInEntityCollisions(entityNamespace);
-	return {
+	const { support } = assembleDataTypeSupport(components, (codecId) => options.codecLookup.descriptorFor(codecId)?.dataType);
+	const helperLookups = {
+		codecLookup: options.codecLookup,
+		dataTypes: support
+	};
+	return blindCast({
 		...createEntityHelpersFromNamespace(entityNamespace, { ctx: {
 			family: options.family.familyId,
-			target: options.target.targetId
+			target: options.target.targetId,
+			codecLookup: options.codecLookup,
+			dataTypes: support
 		} }),
-		field: createComposedFieldHelpers(fieldNamespace),
+		field: createComposedFieldHelpers(fieldNamespace, helperLookups),
 		model,
 		rel,
-		type: createTypeHelpersFromNamespace(typeNamespace)
-	};
+		type: createTypeHelpersFromNamespace(typeNamespace, helperLookups),
+		gen: createGeneratorHelpers([
+			options.family,
+			options.target,
+			...extensionValues
+		])
+	});
 }
 function hasNamedModelToken(models, modelName) {
 	return models[modelName]?.stageOne.modelName === modelName;
@@ -769,25 +838,12 @@ function flushWarnings(warnings) {
 		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.
+	process.emitWarning(`${warnings.length} contract references use string fallbacks where typed alternatives are available. Use named model tokens 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();
@@ -825,36 +881,14 @@ function emitTypedCrossModelFallbackWarnings(collection) {
 	}
 	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
-		};
-	}
+/** A column stores no `typeParams` when it has none, as PSL writes it (ADR 246). */
+function withoutEmptyTypeParams(descriptor) {
+	const { typeParams, ...rest } = descriptor;
+	return typeParams === void 0 || Object.keys(typeParams).length > 0 ? descriptor : rest;
+}
+function resolveFieldDescriptor(modelName, fieldName, fieldState) {
+	if ("descriptor" in fieldState && fieldState.descriptor) return withoutEmptyTypeParams(fieldState.descriptor);
+	if ("enumHandle" in fieldState && isEnumTypeHandle(fieldState.enumHandle)) return { codecId: fieldState.enumHandle.codecId };
 	throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" does not resolve to a storage descriptor`, { meta: {
 		modelName,
 		fieldName,
@@ -1005,6 +1039,19 @@ function resolveRelationAnchorFields(spec) {
 		reason: "missing-anchor-id"
 	} });
 }
+function belongsToNullable(relationName, declaredNullable, spec, fieldNames) {
+	const { nullable, contradiction } = resolveToOneRelationNullable({
+		declaredNullable,
+		localFieldNullability: fieldNames.map((fieldName) => spec.fieldBuilders[fieldName]?.build().nullable === true),
+		ownsReference: true
+	});
+	if (contradiction !== void 0) throw contractError("CONTRACT.RELATION_INVALID", toOneNullabilityContradictionMessage(`Relation "${spec.modelName}.${relationName}"`, contradiction), { meta: {
+		modelName: spec.modelName,
+		relationName,
+		reason: "to-one-nullability-mismatch"
+	} });
+	return nullable;
+}
 function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensions) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
 	const fromFields = normalizeRelationFieldNames(relation.from);
@@ -1019,19 +1066,19 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, e
 	});
 	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,
+			toTable: relation.tableName,
 			cardinality: "N:1",
+			nullable: belongsToNullable(relationName, relation.optional, currentSpec, fromFields),
 			spaceId: relation.spaceId,
 			...relation.namespaceId !== void 0 ? { namespaceId: relation.namespaceId } : {},
 			on: {
 				parentTable: currentSpec.tableName,
 				parentColumns,
-				childTable: targetTable,
+				childTable: relation.tableName,
 				childColumns: toFields
 			}
 		};
@@ -1047,6 +1094,7 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, e
 		toModel: targetModelName,
 		toTable: targetSpec.tableName,
 		cardinality: "N:1",
+		nullable: belongsToNullable(relationName, relation.optional, currentSpec, fromFields),
 		on: {
 			parentTable: currentSpec.tableName,
 			parentColumns: mapFieldNamesToColumnNames(currentSpec.modelName, fromFields, currentSpec.fieldToColumn),
@@ -1077,7 +1125,10 @@ function lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs
 		fieldName: relationName,
 		toModel: targetModelName,
 		toTable: targetSpec.tableName,
-		cardinality: relation.kind === "hasMany" ? "1:N" : "1:1",
+		...relation.kind === "hasMany" ? { cardinality: "1:N" } : {
+			cardinality: "1:1",
+			nullable: true
+		},
 		on: {
 			parentTable: currentSpec.tableName,
 			parentColumns: mapFieldNamesToColumnNames(currentSpec.modelName, parentFields, currentSpec.fieldToColumn),
@@ -1150,11 +1201,16 @@ function lowerLocalForeignKeyNode(spec, targetSpec, foreignKey) {
 	};
 }
 function lowerCrossSpaceForeignKeyNode(spec, foreignKey) {
+	if (foreignKey.targetTableName === void 0) throw contractError("CONTRACT.FOREIGN_KEY_INVALID", `Foreign key on "${spec.modelName}" references model "${foreignKey.targetModel}" in contract space "${foreignKey.targetSpaceId}" but the target table name is unknown: the handle's .sql() stage is a factory function, so its table cannot be read statically. Declare the target model's .sql() stage with a static object carrying \`table\`.`, { meta: {
+		sourceModel: spec.modelName,
+		targetModel: foreignKey.targetModel,
+		spaceId: foreignKey.targetSpaceId
+	} });
 	return {
 		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
 		references: {
 			model: foreignKey.targetModel,
-			table: foreignKey.targetTableName ?? foreignKey.targetModel.toLowerCase(),
+			table: foreignKey.targetTableName,
 			columns: foreignKey.targetFields,
 			...foreignKey.targetNamespaceId !== void 0 ? { namespaceId: foreignKey.targetNamespaceId } : {},
 			spaceId: foreignKey.targetSpaceId
@@ -1206,23 +1262,133 @@ function resolveForeignKeyNodes(spec, allSpecs, extensions) {
 	});
 	return [...relationForeignKeys, ...sqlForeignKeys];
 }
-function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, extensions) {
+/**
+* Resolves a deferred index expression's field refs the way the field-tuple form
+* resolves its columns, and pairs each with the codec the column stores through
+* so a renderer can refuse a column it cannot express.
+*/
+function resolveDeferredColumns(spec, fieldNames, fieldCodecIds) {
+	const columnNames = mapFieldNamesToColumnNames(spec.modelName, fieldNames, spec.fieldToColumn);
+	return fieldNames.map((fieldName, position) => {
+		const name = columnNames[position];
+		const codecId = fieldCodecIds[fieldName];
+		if (name === void 0 || codecId === void 0) throw new InternalError(`Deferred index expression on "${spec.modelName}" resolved no column for field "${fieldName}"`);
+		return {
+			name,
+			codecId
+		};
+	});
+}
+/**
+* The text of an index expression. A string has no `render`, and `'render' in` a string throws a
+* `TypeError`, so the `sql` value is recognized first and anything else is refused last.
+*/
+function indexExpressionText(spec, expression, fieldCodecIds, owner) {
+	const sqlExpression = readSqlExpression(expression);
+	if (sqlExpression !== void 0) return sqlExpression.text;
+	if (typeof expression === "object" && expression !== null && "render" in expression) return renderedSqlText(expression.render(resolveDeferredColumns(spec, expression.fields.map((ref) => ref.fieldName), fieldCodecIds)), `${owner} expression`);
+	return requireSqlExpression(expression, `${owner} expression`).text;
+}
+function renderedSqlText(rendered, what) {
+	try {
+		return new SqlExpression(rendered).text;
+	} catch (cause) {
+		if (!isStructuredError(cause) || cause.code !== "CONTRACT.SQL_EXPRESSION_INVALID") throw cause;
+		throw contractError("CONTRACT.SQL_EXPRESSION_INVALID", `${what}: ${cause.message}`, {
+			meta: {
+				what,
+				...cause.meta
+			},
+			cause
+		});
+	}
+}
+function constraintOwner(kind, modelName, constraint) {
+	const name = constraint.name ?? constraint.map;
+	return name === void 0 ? `${kind} on "${modelName}"` : `${kind} "${name}"`;
+}
+/** The fields an index covers, in order: its own, or those of its deferred expression. */
+function coveredFieldNames(index) {
+	if (index.fields !== void 0) return index.fields;
+	const { expression } = index;
+	if (expression === void 0 || isSqlExpression(expression) || typeof expression !== "object") return [];
+	return expression.fields.map((ref) => ref.fieldName);
+}
+/**
+* The generators a field's `.onCreate(...)` and `.onUpdate(...)` calls resolve to for its column, merged over the phases a field preset or `field.generated(...)` sets.
+*/
+function resolveGeneratorCalls(input) {
+	const { modelName, fieldName, fieldState, descriptor, generatorFunctions } = input;
+	const calls = fieldState.generatorCalls;
+	if (calls === void 0) return fieldState.executionDefaults;
+	const typeParams = descriptor.typeParams;
+	const column = {
+		codecId: descriptor.codecId,
+		typeParams,
+		length: input.columnLength(descriptor.codecId, typeParams)
+	};
+	const phases = { ...fieldState.executionDefaults };
+	for (const phase of ["onCreate", "onUpdate"]) {
+		const call = calls[phase];
+		if (call === void 0) continue;
+		if (fieldState.many !== false) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${fieldName}" is a list and cannot use .${phase}(${call.name}()). Lists have no per-element generated values; remove .${phase}(...).`, { meta: {
+			modelName,
+			fieldName,
+			codecId: column.codecId,
+			function: call.name,
+			reason: "generator-on-list"
+		} });
+		const resolution = generatorFunctions.resolve(call, column);
+		if (resolution.ok) {
+			phases[phase] = resolution.generator;
+			continue;
+		}
+		const meta = {
+			modelName,
+			fieldName,
+			codecId: column.codecId,
+			function: call.name
+		};
+		if (resolution.reason === "unknown-function") throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${fieldName}": no pack in the contract declares the generator function "${call.name}".`, { meta: {
+			...meta,
+			reason: "generator-unknown"
+		} });
+		const applying = generatorFunctions.functionsFor(column.codecId).map(({ name }) => `${name}()`);
+		throw contractError("CONTRACT.DEFAULT_INVALID", resolution.reason === "refused" ? `Field "${modelName}.${fieldName}": ${resolution.message}` : `Field "${modelName}.${fieldName}": ${call.name}() does not apply to codec "${column.codecId}". ${applying.length === 0 ? "No generator function applies to this codec." : `Functions that apply: ${applying.join(", ")}.`}`, { meta: {
+			...meta,
+			reason: "generator-not-applicable"
+		} });
+	}
+	return phases;
+}
+function resolveModelNode(spec, allSpecs, generatorFunctions, columnLength, extensions) {
 	const fields = [];
+	/** Filled by the field loop below, read by a deferred index expression. */
+	const fieldCodecIds = {};
 	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
 		const fieldState = fieldBuilder.build();
-		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup);
+		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState);
 		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;
+		fieldCodecIds[fieldName] = descriptor.codecId;
+		const enumHandle = "enumHandle" in fieldState && isEnumTypeHandle(fieldState.enumHandle) ? fieldState.enumHandle : void 0;
+		const executionDefaults = resolveGeneratorCalls({
+			modelName: spec.modelName,
+			fieldName,
+			fieldState,
+			descriptor,
+			generatorFunctions,
+			columnLength
+		});
 		fields.push({
 			fieldName,
 			columnName,
 			descriptor,
 			nullable: fieldState.nullable,
-			...fieldState.many === true ? { many: true } : {},
-			...fieldState.noCheck !== void 0 ? { noCheck: fieldState.noCheck } : {},
+			many: fieldState.many !== false,
+			...fieldState.many !== false ? { elementNullable: fieldState.many.elementNullable } : {},
 			...fieldState.default ? { default: fieldState.default } : {},
-			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {},
+			...ifDefined("executionDefaults", executionDefaults),
 			...enumHandle !== void 0 ? { enumTypeHandle: enumHandle } : {}
 		});
 	}
@@ -1232,12 +1398,14 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...unique.name ? { name: unique.name } : {}
 	}));
 	const indexes = (spec.sqlSpec?.indexes ?? []).map((index) => {
+		const options = typeof index.options === "function" ? index.options(resolveDeferredColumns(spec, coveredFieldNames(index), fieldCodecIds)) : index.options;
 		const method = blindCast({
 			type: index.type,
-			options: index.options
+			options
 		});
+		const owner = constraintOwner("Index", spec.modelName, index);
 		const carried = {
-			where: index.where,
+			where: index.where === void 0 ? void 0 : requireSqlExpression(index.where, `${owner} where`).text,
 			unique: index.unique,
 			name: index.name,
 			map: index.map,
@@ -1245,14 +1413,14 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		};
 		return index.expression !== void 0 ? {
 			...carried,
-			expression: index.expression
+			expression: indexExpressionText(spec, index.expression, fieldCodecIds, owner)
 		} : {
 			...carried,
 			columns: mapFieldNamesToColumnNames(spec.modelName, index.fields ?? [], spec.fieldToColumn)
 		};
 	});
 	const checks = (spec.sqlSpec?.checks ?? []).map((authoredCheck) => ({
-		expression: authoredCheck.expression,
+		expression: requireSqlExpression(authoredCheck.expression, `${constraintOwner("Check", spec.modelName, authoredCheck)} expression`).text,
 		name: authoredCheck.name,
 		map: authoredCheck.map
 	}));
@@ -1275,10 +1443,16 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...ifDefined("control", spec.sqlSpec?.control)
 	};
 }
+function columnLengthOf(definition) {
+	const { codecLookup, dataTypeLookup } = definition;
+	return (codecId, typeParams) => {
+		const dataTypeId = codecLookup.descriptorFor(codecId)?.dataType;
+		return sqlColumnLength(dataTypeId === void 0 ? void 0 : dataTypeLookup.get(dataTypeId), typeParams);
+	};
+}
 function collectRuntimeModelSpecs(definition) {
-	const storageTypes = { ...definition.types ?? {} };
+	const databaseTypes = { ...definition.databaseTypes };
 	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)) {
@@ -1333,15 +1507,14 @@ function collectRuntimeModelSpecs(definition) {
 		});
 	}
 	return {
-		storageTypes,
+		databaseTypes,
 		models,
 		modelSpecs
 	};
 }
-function lowerModels(collection, extensions) {
+function lowerModels(collection, generatorFunctions, columnLength, extensions) {
 	emitTypedCrossModelFallbackWarnings(collection);
-	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensions));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, generatorFunctions, columnLength, extensions));
 }
 /**
 * Kind-agnostic walk over the author-declared `entities` handle list:
@@ -1461,16 +1634,30 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 	return pack;
 }
 function buildContractDefinition(definition) {
+	refuseTypesKey(definition, "buildContractDefinition");
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerModels(collection, definition.extensions);
+	const packs = [
+		definition.family,
+		definition.target,
+		...Object.values(definition.extensions ?? {})
+	];
+	const generatorFunctions = assembleGeneratorFunctions(packs);
+	const columnLength = columnLengthOf(definition);
+	assertTypeAliasesValid(composePackAuthoringNamespace(packs, "type"), {
+		generatorFunctions,
+		paramsSchemaOf: (codecId) => definition.codecLookup.descriptorFor(codecId)?.paramsSchema,
+		fieldLength: ({ codecId, typeParams }) => columnLength(codecId, typeParams)
+	});
+	const models = lowerModels(collection, generatorFunctions, columnLength, definition.extensions);
 	const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
 	return {
 		target: definition.target,
 		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
 		...definition.extensions ? { extensions: definition.extensions } : {},
+		...ifDefined("capabilities", definition.adapter?.capabilities),
 		...definition.storageHash ? { storageHash: definition.storageHash } : {},
 		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
-		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
+		...Object.keys(collection.databaseTypes).length > 0 ? { databaseTypes: collection.databaseTypes } : {},
 		...definition.namespaces ? { namespaces: definition.namespaces } : {},
 		warnings: void 0,
 		createNamespace: definition.createNamespace,
@@ -1491,6 +1678,9 @@ function validateTargetPackRef(family, target) {
 		contractFamilyId: family.familyId
 	} });
 }
+function targetNameOf(target) {
+	return target.displayName ?? target.targetId;
+}
 /**
 * Per-target reserved namespace names enforced by `defineContract` for
 * SQL family contracts. Two categories:
@@ -1499,16 +1689,16 @@ function validateTargetPackRef(family, target) {
 *    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.
+* 2. **The PSL keyword `unbound`** — the name PSL writes for the
+*    late-binding opt-in (`namespace unbound { … }`), so the TS surface
+*    rejects it from `defineContract({ namespaces })` lists on every
+*    target that accepts namespaces. A target whose `supportsNamespaces` is false 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: {
+	if (target.supportsNamespaces === false && namespaces.length > 0) throw contractError("CONTRACT.NAMESPACE_UNSUPPORTED", `defineContract: ${targetNameOf(target)} contracts cannot declare namespaces. Received namespaces: [${namespaces.map((name) => `"${name}"`).join(", ")}].`, { meta: {
 		namespaces,
 		targetId: target.targetId
 	} });
@@ -1526,9 +1716,10 @@ function validateNamespaceDeclarations(target, namespaces) {
 			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: {
+		if (namespace === UNBOUND_PSL_NAMESPACE_NAME) throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: namespace name "${namespace}" is reserved by ${targetNameOf(target)} for the late-binding opt-in (use \`namespace ${namespace} { … }\` in PSL instead of declaring it as a regular schema).`, { meta: {
 			namespace,
-			reason: "reserved-by-postgres"
+			reason: "reserved-psl-keyword",
+			targetId: target.targetId
 		} });
 		if (seen.has(namespace)) throw contractError("CONTRACT.NAME_DUPLICATE", `defineContract: namespaces list contains duplicate entry "${namespace}".`, { meta: {
 			kind: "namespace",
@@ -1545,25 +1736,21 @@ function validateNamespaceDeclarations(target, namespaces) {
 *
 * - `__unbound__` / `__unspecified__` — reserved IR sentinels on
 *   every SQL target.
-* - `unbound` on Postgres — reserved for the PSL
-*   `namespace unbound { … }` opt-in.
+* - The PSL keyword `unbound` — reserved for the PSL late-binding
+*   opt-in, which the TS builder has no surface for.
 *
-* 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.
+* Additionally enforces that each per-model `namespace` references an
+* entry in the contract's declared `namespaces` list.
 *
-* The SQLite per-model `namespace` field is rejected outright (SQLite
-* has no schema concept).
+* A target whose `supportsNamespaces` is false rejects the per-model
+* `namespace` field outright.
 */
 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: {
+		if (target.supportsNamespaces === false) throw contractError("CONTRACT.NAMESPACE_UNSUPPORTED", `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is ${targetNameOf(target)}, which does not support namespaces (remove the per-model \`namespace\` field).`, { meta: {
 			modelKey,
 			namespace: perModelNamespace,
 			targetId: target.targetId
@@ -1573,10 +1760,11 @@ function validatePerModelNamespaces(target, namespaces, models) {
 			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: {
+		if (perModelNamespace === UNBOUND_PSL_NAMESPACE_NAME) throw contractError("CONTRACT.NAMESPACE_INVALID", `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is reserved by ${targetNameOf(target)} for the late-binding opt-in (use \`namespace ${perModelNamespace} { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`, { meta: {
 			modelKey,
 			namespace: perModelNamespace,
-			reason: "reserved-by-postgres"
+			reason: "reserved-psl-keyword",
+			targetId: target.targetId
 		} });
 		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,
@@ -1609,10 +1797,11 @@ function buildContractFromDsl(definition) {
 	validateExtensionPackRefs(definition.target, definition.extensions);
 	validateNamespaceDeclarations(definition.target, definition.namespaces);
 	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
-	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
+	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup, definition.dataTypeLookup));
 }
 /** Implementation. */
 function buildBoundContract(family, target, definition, factory) {
+	refuseTypesKey(definition, "defineContract");
 	const full = {
 		...definition,
 		family,
@@ -1622,8 +1811,10 @@ function buildBoundContract(family, target, definition, factory) {
 		const built = factory(createComposedAuthoringHelpers({
 			family,
 			target,
-			extensions: definition.extensions
+			extensions: definition.extensions,
+			codecLookup: definition.codecLookup
 		}));
+		refuseTypesKey(built, "defineContract");
 		const mergedEnums = {
 			...definition.enums ?? {},
 			...built.enums
@@ -1631,7 +1822,7 @@ function buildBoundContract(family, target, definition, factory) {
 		const mergedEntities = [...definition.entities ?? [], ...built.entities ?? []];
 		return buildContractFromDsl({
 			...full,
-			...ifDefined("types", built.types),
+			...ifDefined("databaseTypes", built.databaseTypes),
 			...ifDefined("models", built.models),
 			...ifDefined("enums", Object.keys(mergedEnums).length > 0 ? mergedEnums : void 0),
 			...ifDefined("entities", mergedEntities.length > 0 ? mergedEntities : void 0)
@@ -1644,7 +1835,21 @@ function defineContract(definition, factory) {
 	if (factory !== void 0) return buildBoundContract(definition.family, definition.target, definition, factory);
 	return buildBoundContract(definition.family, definition.target, definition);
 }
+/** The database's current time, the same default PSL writes as `@default(now())`. */
+function now() {
+	return {
+		kind: "function",
+		expression: "now()"
+	};
+}
+/** A database-assigned sequence value, the same default PSL writes as `@default(autoincrement())`. */
+function autoincrement() {
+	return {
+		kind: "function",
+		expression: "autoincrement()"
+	};
+}
 //#endregion
-export { defineContract as a, field as c, rel as d, check as i, member as l, buildBoundContract as n, enumType as o, buildContractDefinition as r, extensionModel as s, bindEnumType as t, model as u };
+export { check as a, enumType as c, member as d, model as f, buildContractDefinition as i, extensionModel as l, rel as m, bindEnumType as n, createComposedAuthoringHelpers as o, now as p, buildBoundContract as r, defineContract as s, autoincrement as t, field as u };
 
-//# sourceMappingURL=contract-builder-D4a5dT7j.mjs.map
+//# sourceMappingURL=contract-builder-50lF0kz1.mjs.map