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

package/dist/derived-checks-DFMRmiAu-DGfB8aS4.mjs

@@ -1,1057 +0,0 @@
-import { i as computeCheckContentHash, r as composeCheckWirePrefix, s as derivedCheckPrefixes } from "./naming-DKr4TJd7-Cszhq9RV.mjs";
-import { n as lowerAuthoredIndex } from "./index-naming-DREt6js7-CRH27yUv.mjs";
-import { t as lowerAuthoredCheck } from "./authored-check-naming-Hf9990DV.mjs";
-import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-dmXkOR4a.mjs";
-import { c as StorageTable, i as Index, t as CheckConstraint } from "./storage-table-ZzbR-xzQ-BRoTQE_2.mjs";
-import { n as checkConstraintInputFromSerialized } from "./serialized-index-nBTwanKy-_ddEK4tk.mjs";
-import { m as valueSetEntityKind, p as tableEntityKind } from "./entity-kinds-D7vwoN_T-CCBwFJy0.mjs";
-import { r as materializeForeignKeysAndIndexes } from "./foreign-key-materialization-Cu7-7LHl.mjs";
-import { t as validateIndexTypes } from "./index-type-validation-COH4d78M.mjs";
-import { t as createIndexTypeRegistry } from "./index-types-DJQ_xwaE.mjs";
-import { a as SqlStorage, o as applyFkDefaults, s as isMaterializedSqlNamespace, u as toStorageTypeInstance } from "./types-CUsJrvEl.mjs";
-import { u as validateStorageSemantics } from "./validators-CrWD6bSP.mjs";
-import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { flushAuthoringWarnings, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
-import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { asNamespaceId, coreHash, crossRef, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
-import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
-import { mergeCapabilityMatrices } from "@prisma/orm-framework/contract-authoring";
-import { applySpecifierDefaultControlPolicy } from "@prisma/orm-framework/contract/apply-specifier-default-control-policy";
-import { invariant } from "@prisma/orm-framework/utils/assertions";
-//#region ../../../2-sql/2-authoring/contract-ts/dist/derived-checks-DFMRmiAu.mjs
-function contractError(code, message, options) {
-	return structuredError(code, message, options);
-}
-function encodeViaCodec(value, codecId, codecLookup) {
-	const codec = codecLookup?.get(codecId);
-	if (codec) return codec.encodeJson(value);
-	return blindCast(value);
-}
-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 InternalError(`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)
-	};
-}
-function assertStorageSemantics(definition, contract) {
-	const semanticErrors = validateStorageSemantics(contract.storage);
-	if (semanticErrors.length > 0) throw contractError("CONTRACT.VALIDATION_FAILED", `Contract semantic validation failed: ${semanticErrors.join("; ")}`, { meta: { errors: semanticErrors } });
-	const indexTypeRegistry = createIndexTypeRegistry();
-	const packsToRegister = [definition.target, ...Object.values(definition.extensions ?? {})];
-	for (const pack of packsToRegister) {
-		const registration = pack.indexTypes;
-		if (registration === void 0) continue;
-		if (typeof registration !== "object" || registration === null || !Array.isArray(registration.entries)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack "${pack.id ?? "<unknown>"}" declares "indexTypes" but its value is not an IndexTypeRegistration (expected an object with an "entries" array; got ${typeof registration}).`, { meta: {
-			packId: pack.id,
-			contribution: "indexTypes",
-			reason: "invalid-shape"
-		} });
-		for (const entry of registration.entries) indexTypeRegistry.register(entry);
-	}
-	validateIndexTypes(contract, indexTypeRegistry);
-}
-function assertKnownTargetModel(modelsByName, modelsByCoordinate, sourceModelName, targetModelName, targetNamespaceId, context) {
-	const targetModel = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`) : modelsByName.get(targetModelName);
-	if (!targetModel) {
-		const qualified = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? `${targetNamespaceId}.${targetModelName}` : targetModelName;
-		throw contractError("CONTRACT.MODEL_UNKNOWN", `${context} on model "${sourceModelName}" references unknown model "${qualified}"`, { meta: {
-			sourceModel: sourceModelName,
-			targetModel: qualified,
-			context
-		} });
-	}
-	return targetModel;
-}
-function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
-	if (targetModel.tableName !== referencedTableName) throw contractError("CONTRACT.TABLE_MISMATCH", `${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`, { meta: {
-		sourceModel: sourceModelName,
-		referencedTable: referencedTableName,
-		mappedTable: targetModel.tableName,
-		context
-	} });
-}
-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";
-}
-/**
-* Structural check for a target that contributes a `renderCheckExpressions`
-* hook, duck-typed for the same reason {@link hasColumnTypeQualifier} is: the
-* SQL family stays blind to the target's predicate syntax.
-*/
-function hasCheckExpressionRenderer(authoring) {
-	return "renderCheckExpressions" in authoring && typeof authoring.renderCheckExpressions === "function";
-}
-function resolveCheckExpressionRenderer(target) {
-	const authoring = target.authoring;
-	if (authoring === void 0) return void 0;
-	return hasCheckExpressionRenderer(authoring) ? authoring.renderCheckExpressions : void 0;
-}
-/**
-* The member values a membership check must enforce, encoded exactly as the
-* column stores them. Only string members can be written as a predicate, so a
-* numeric enum fails here rather than emitting a wrong text-shaped check.
-*/
-function checkMemberValues(handle, codecLookup) {
-	const encoded = handle.values.map((value) => encodeViaCodec(value, handle.codecId, codecLookup));
-	const values = [];
-	for (const value of encoded) {
-		if (typeof value !== "string") throw contractError("CONTRACT.ENUM_INVALID", `enumType("${handle.enumName}"): has a non-string value; numeric-enum CHECK constraints are not yet supported.`, { meta: {
-			enumName: handle.enumName,
-			reason: "non-string-member-value"
-		} });
-		values.push(value);
-	}
-	return values;
-}
-/**
-* Resolves a field's authored `noCheck` kinds against its column shape:
-* the bare form (`[]`) becomes every kind the shape derives, and a named
-* kind that can never apply to the shape is an authoring error
-* (`CONTRACT.CHECK_OPTOUT_INVALID`). Returns the concrete kinds in
-* canonical ascending order — the only form the contract persists.
-*/
-function resolveNoCheckKinds(input) {
-	const derivable = [];
-	if (input.many) derivable.push("elementNotNull");
-	if (input.isDomainEnum) derivable.push("membership");
-	const subject = `Field "${input.modelName}.${input.fieldName}"`;
-	const meta = {
-		modelName: input.modelName,
-		fieldName: input.fieldName
-	};
-	if (input.kinds.length === 0) {
-		if (derivable.length === 0) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck() waives nothing — this column's shape derives no generated checks.`, { meta: {
-			...meta,
-			reason: "no-derivable-checks"
-		} });
-		return derivable;
-	}
-	const seen = /* @__PURE__ */ new Set();
-	for (const kind of input.kinds) {
-		if (seen.has(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") names the same kind twice.`, { meta: {
-			...meta,
-			kind,
-			reason: "duplicate-kind"
-		} });
-		seen.add(kind);
-		if (!derivable.includes(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") does not apply — ${kind === "membership" ? "membership checks are derived only from enumType() value sets" : "element-non-null checks are derived only for list columns"}.`, { meta: {
-			...meta,
-			kind,
-			reason: "inapplicable-kind"
-		} });
-	}
-	return [...input.kinds].sort();
-}
-/**
-* Names the target's rendered checks and lowers them into contract entities.
-*
-* Naming is composed family-side ({@link composeCheckWirePrefix}) rather than
-* by the target, and suffixed with the predicate's content hash. Composing
-* family-side is what makes the truncation safe — two prefixes that truncate
-* alike still differ in their hashes, and the family can see that the
-* (table, column, kind) triple they were built from is unique per table,
-* rather than having to assume something about SQL text it declares itself
-* unable to read.
-*/
-function lowerRenderedChecks(tableName, candidates) {
-	return candidates.map((candidate) => new CheckConstraint({
-		naming: {
-			kind: "wire",
-			prefix: composeCheckWirePrefix(tableName, candidate.columnName, candidate.kind),
-			hash: computeCheckContentHash(candidate.expression)
-		},
-		expression: candidate.expression
-	}));
-}
-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 contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${entityRef.entityKind}" entities named "${entityRef.entityName}" in namespace "${namespaceId}" — pack-entity names must be unique per namespace.`, { meta: {
-		kind: entityRef.entityKind,
-		name: entityRef.entityName,
-		namespaceId
-	} });
-	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 contractError("CONTRACT.NAME_DUPLICATE", `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.`, { meta: {
-				kind,
-				name,
-				namespaceId
-			} });
-		}
-		result[kind] = {
-			...attachedForKind,
-			...columnForKind
-		};
-	}
-	return result;
-}
-const JSONB_CODEC_ID = "pg/jsonb@1";
-const JSONB_NATIVE_TYPE = "jsonb";
-function resolveModelNamespaceId(model, modelNameToNamespaceId, defaultNamespaceId) {
-	if (model.namespaceId !== void 0 && model.namespaceId.length > 0) return model.namespaceId;
-	return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;
-}
-function buildThroughDescriptor(through, tableNamespaceByName, targetModel, modelName, fieldName, defaultNamespaceId) {
-	if (!tableNamespaceByName.has(through.table)) throw contractError("CONTRACT.MODEL_UNKNOWN", `buildSqlContractFromDefinition: junction table "${through.table}" for relation "${modelName}.${fieldName}" is not a declared model.`, { meta: {
-		sourceModel: modelName,
-		relationName: fieldName,
-		junctionTable: through.table
-	} });
-	const namespaceId = through.namespaceId ?? defaultNamespaceId;
-	return {
-		table: through.table,
-		namespaceId,
-		parentColumns: through.parentColumns,
-		childColumns: through.childColumns,
-		targetColumns: targetColumnsForJunction(targetModel, fieldName)
-	};
-}
-function targetColumnsForJunction(targetModel, fieldName) {
-	const primaryKeyColumns = targetModel.id?.columns;
-	if (primaryKeyColumns && primaryKeyColumns.length > 0) return primaryKeyColumns;
-	const firstUnique = targetModel.uniques?.find((u) => u.columns.length > 0);
-	if (firstUnique) return firstUnique.columns;
-	throw contractError("CONTRACT.IDENTITY_INVALID", `M:N target model "${targetModel.modelName}" (relation field "${fieldName}") has no primary id or unique key to derive junction targetColumns.`, { meta: {
-		modelName: targetModel.modelName,
-		reason: "no-key-for-junction-target-columns"
-	} });
-}
-function buildStorageColumn(field, storageValueSetRef, codecLookup) {
-	if (isValueObjectField(field)) {
-		const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, JSONB_CODEC_ID, codecLookup) : void 0;
-		return {
-			nativeType: JSONB_NATIVE_TYPE,
-			codecId: JSONB_CODEC_ID,
-			nullable: field.nullable,
-			...ifDefined("default", encodedDefault)
-		};
-	}
-	const codecId = field.descriptor.codecId;
-	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 } : {},
-		...field.noCheck !== void 0 ? { noCheck: [...field.noCheck].sort() } : {},
-		...ifDefined("typeParams", field.descriptor.typeParams),
-		...ifDefined("default", encodedDefault),
-		...ifDefined("typeRef", field.descriptor.typeRef),
-		...ifDefined("valueSet", valueSet)
-	};
-}
-function buildDomainField(field, column, domainValueSetRef) {
-	if (isValueObjectField(field)) return {
-		type: {
-			kind: "valueObject",
-			name: field.valueObjectName
-		},
-		nullable: field.nullable,
-		...field.many ? { many: true } : {}
-	};
-	return {
-		type: {
-			kind: "scalar",
-			codecId: column.codecId,
-			...ifDefined("typeParams", column.typeParams)
-		},
-		nullable: column.nullable,
-		...field.many ? { many: true } : {},
-		...ifDefined("valueSet", domainValueSetRef)
-	};
-}
-function collectStorageNamespaceCoordinateIds(definition) {
-	const ids = /* @__PURE__ */ new Set();
-	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 contractError("CONTRACT.ENTITY_KIND_INVALID", `buildSqlContractFromDefinition: attached entity in namespace "${namespaceId}" declares entry kind "${kind}", which is managed by the framework (table/valueSet) and cannot be attached.`, { meta: {
-		entityKind: kind,
-		namespaceId
-	} });
-}
-/**
-* 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` +
-* `extensions`) 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.extensions ?? {})];
-	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 contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: value-set "${name}" in namespace "${namespaceId}" is derived from both an enum and a pack entity — names must be unique per namespace.`, { meta: {
-			kind: "valueSet",
-			name,
-			namespaceId
-		} });
-	}
-	return {
-		...enumValueSets,
-		...packValueSets
-	};
-}
-function ensureUnboundNamespaceSlot(namespaces, createNamespace) {
-	if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) return namespaces;
-	const unbound = createNamespace({
-		id: UNBOUND_NAMESPACE_ID,
-		entries: { table: {} }
-	});
-	return {
-		[UNBOUND_NAMESPACE_ID]: unbound,
-		...namespaces
-	};
-}
-const DERIVABLE_CHECK_KINDS = ["membership", "elementNotNull"];
-/**
-* Which of `columnNames` could have produced `prefix` for some
-* {@link CheckKind} — the reverse of {@link derivedCheckPrefixes}, used only
-* to name the collision in `CONTRACT.CHECK_NAME_RESERVED`'s message. Callers
-* already know `prefix` is a member of `derivedCheckPrefixes(tableName,
-* columnNames)`, so the result is never empty.
-*/
-function columnsProducingCheckPrefix(tableName, columnNames, prefix) {
-	return columnNames.filter((columnName) => DERIVABLE_CHECK_KINDS.some((kind) => composeCheckWirePrefix(tableName, columnName, kind) === prefix));
-}
-function buildSqlContractFromDefinition(definition, codecLookup) {
-	const target = definition.target.targetId;
-	const defaultNamespaceId = definition.target.defaultNamespaceId;
-	const qualifyColumnType = resolveColumnTypeQualifier(definition.target);
-	const renderCheckExpressions = resolveCheckExpressionRenderer(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]));
-	const tableNamespaceByName = new Map(definition.models.map((m) => [m.tableName, m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId]));
-	const modelsByCoordinate = new Map(definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]));
-	const tablesByNamespace = {};
-	const authoringWarnings = [...definition.warnings ?? []];
-	const modelNameToNamespaceId = /* @__PURE__ */ new Map();
-	const executionDefaults = [];
-	const modelsByNamespace = {};
-	const collectedColumnEntities = {};
-	const rootEntries = [];
-	for (const semanticModel of definition.models) {
-		const tableName = semanticModel.tableName;
-		const namespaceId = semanticModel.namespaceId !== void 0 && semanticModel.namespaceId.length > 0 ? semanticModel.namespaceId : defaultNamespaceId;
-		modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
-		if (!semanticModel.sharesBaseTable) rootEntries.push({
-			tableName,
-			namespaceId,
-			ref: crossRef(semanticModel.modelName, namespaceId)
-		});
-		const columns = {};
-		const fieldToColumn = {};
-		const domainFields = {};
-		const domainFieldRefs = {};
-		const checksForTable = [];
-		const derivesChecks = effectiveControlPolicy(semanticModel.control, definition.defaultControlPolicy) === "managed";
-		for (const field of semanticModel.fields) {
-			const executionDefaultPhases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
-			if (executionDefaultPhases) {
-				if (field.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefaults.`, { meta: {
-					modelName: semanticModel.modelName,
-					fieldName: field.fieldName,
-					reason: "default-and-executionDefaults"
-				} });
-				if (field.nullable) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" cannot be nullable when executionDefaults are present.`, { meta: {
-					modelName: semanticModel.modelName,
-					fieldName: field.fieldName,
-					reason: "nullable-with-executionDefaults"
-				} });
-			}
-			const enumHandle = !isValueObjectField(field) ? field.enumTypeHandle : void 0;
-			const storageValueSetRef = enumHandle !== void 0 ? {
-				plane: "storage",
-				entityKind: "valueSet",
-				namespaceId: defaultNamespaceId,
-				entityName: enumHandle.enumName
-			} : void 0;
-			const domainValueSetRef = enumHandle !== void 0 ? {
-				plane: "domain",
-				entityKind: "enum",
-				namespaceId: defaultNamespaceId,
-				entityName: enumHandle.enumName
-			} : void 0;
-			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
-				};
-			}
-			if (!isValueObjectField(resolvedField) && resolvedField.noCheck !== void 0) {
-				const { noCheck: authoredNoCheck, ...withoutNoCheck } = resolvedField;
-				resolvedField = derivesChecks ? {
-					...withoutNoCheck,
-					noCheck: resolveNoCheckKinds({
-						modelName: semanticModel.modelName,
-						fieldName: field.fieldName,
-						kinds: authoredNoCheck,
-						many: resolvedField.many === true,
-						isDomainEnum: enumHandle !== void 0
-					})
-				} : withoutNoCheck;
-			}
-			const column = buildStorageColumn(resolvedField, storageValueSetRef, codecLookup);
-			columns[field.columnName] = column;
-			fieldToColumn[field.fieldName] = field.columnName;
-			if (renderCheckExpressions !== void 0 && derivesChecks) {
-				const waivedKinds = !isValueObjectField(resolvedField) ? resolvedField.noCheck : void 0;
-				checksForTable.push(...lowerRenderedChecks(tableName, renderCheckExpressions({
-					tableName,
-					columnName: field.columnName,
-					many: column.many === true,
-					memberValues: enumHandle !== void 0 ? checkMemberValues(enumHandle, codecLookup) : void 0
-				}).filter((candidate) => !(waivedKinds?.includes(candidate.kind) ?? false))));
-			}
-			domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);
-			if (isValueObjectField(field)) domainFieldRefs[field.fieldName] = {
-				kind: "valueObject",
-				name: field.valueObjectName,
-				...field.many ? { many: true } : {}
-			};
-			else if (field.many) domainFieldRefs[field.fieldName] = {
-				kind: "scalar",
-				many: true
-			};
-			if (executionDefaultPhases) executionDefaults.push({
-				ref: {
-					namespace: namespaceId,
-					table: tableName,
-					column: field.columnName
-				},
-				...ifDefined("onCreate", executionDefaultPhases.onCreate),
-				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
-			});
-		}
-		const authoringForeignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
-			if (fk.references.spaceId !== void 0) {
-				const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
-				return {
-					source: {
-						namespaceId: asNamespaceId(namespaceId),
-						tableName,
-						columns: fk.columns
-					},
-					target: {
-						namespaceId: asNamespaceId(targetNamespaceId),
-						tableName: fk.references.table,
-						columns: fk.references.columns,
-						spaceId: fk.references.spaceId
-					},
-					...applyFkDefaults({
-						...ifDefined("constraint", fk.constraint),
-						...ifDefined("index", fk.index)
-					}, definition.foreignKeyDefaults),
-					...ifDefined("name", fk.name),
-					...ifDefined("onDelete", fk.onDelete),
-					...ifDefined("onUpdate", fk.onUpdate)
-				};
-			}
-			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, fk.references.model, fk.references.namespaceId, "Foreign key");
-			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
-			const targetNamespaceId = fk.references.namespaceId ?? (targetModel.namespaceId !== void 0 && targetModel.namespaceId.length > 0 ? targetModel.namespaceId : defaultNamespaceId);
-			return {
-				source: {
-					namespaceId: asNamespaceId(namespaceId),
-					tableName,
-					columns: fk.columns
-				},
-				target: {
-					namespaceId: asNamespaceId(targetNamespaceId),
-					tableName: fk.references.table,
-					columns: fk.references.columns
-				},
-				...applyFkDefaults({
-					...ifDefined("constraint", fk.constraint),
-					...ifDefined("index", fk.index)
-				}, definition.foreignKeyDefaults),
-				...ifDefined("name", fk.name),
-				...ifDefined("onDelete", fk.onDelete),
-				...ifDefined("onUpdate", fk.onUpdate)
-			};
-		});
-		if (semanticModel.sharesBaseTable && semanticModel.checks && semanticModel.checks.length > 0) throw contractError("CONTRACT.CHECK_ON_STI_VARIANT", `Model "${semanticModel.modelName}" declares a check constraint but shares its base model's storage table (single-table inheritance) and has no table of its own to declare it on. Declare the check on the base model instead.`, { meta: {
-			tableName,
-			modelName: semanticModel.modelName
-		} });
-		if (!semanticModel.sharesBaseTable) {
-			const uniques = (semanticModel.uniques ?? []).map((u) => ({
-				columns: u.columns,
-				...ifDefined("name", u.name)
-			}));
-			const declaredIndexes = (semanticModel.indexes ?? []).map((i) => lowerAuthoredIndex(tableName, blindCast({
-				...ifDefined("columns", i.columns),
-				...ifDefined("expression", i.expression),
-				where: i.where,
-				unique: i.unique,
-				map: i.map,
-				name: i.name,
-				type: i.type,
-				options: i.options
-			}), authoringWarnings));
-			if (semanticModel.checks !== void 0 && semanticModel.checks.length > 0) {
-				const tableColumnNames = Object.keys(columns);
-				const reservedCheckPrefixes = derivedCheckPrefixes(tableName, tableColumnNames);
-				for (const authoredCheck of semanticModel.checks) {
-					const lowered = lowerAuthoredCheck(tableName, authoredCheck, authoringWarnings);
-					if (lowered.naming.kind === "wire" && reservedCheckPrefixes.has(lowered.naming.prefix)) {
-						const collidingColumns = columnsProducingCheckPrefix(tableName, tableColumnNames, lowered.naming.prefix);
-						const columnList = collidingColumns.map((name) => `"${name}"`).join(", ");
-						throw contractError("CONTRACT.CHECK_NAME_RESERVED", `Check "${lowered.naming.prefix}" on table "${tableName}": this name's prefix matches the shape a derived enforcement check would use for column${collidingColumns.length === 1 ? "" : "s"} ${columnList} of this table, so it can't be told apart from one. Choose a different name.`, { meta: {
-							tableName,
-							prefix: lowered.naming.prefix,
-							collidingColumns
-						} });
-					}
-					checksForTable.push(new CheckConstraint(lowered));
-				}
-			}
-			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,
-				indexes: indexes.map((i) => new Index(i)),
-				foreignKeys,
-				...primaryKey ? { primaryKey } : {},
-				...checksForTable.length > 0 ? { checks: checksForTable } : {}
-			};
-			let nsTables = tablesByNamespace[namespaceId];
-			if (nsTables === void 0) {
-				nsTables = {};
-				tablesByNamespace[namespaceId] = nsTables;
-			}
-			if (nsTables[tableName] !== void 0) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`, { meta: {
-				kind: "table",
-				name: tableName,
-				namespaceId
-			} });
-			nsTables[tableName] = tableInput;
-		}
-		const storageFields = {};
-		for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
-		const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
-		const modelRelations = {};
-		for (const relation of semanticModel.relations ?? []) {
-			if (relation.spaceId !== void 0) {
-				const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
-				modelRelations[relation.fieldName] = {
-					to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
-					cardinality: "N:1",
-					on: {
-						localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-						targetFields: relation.on.childColumns
-					}
-				};
-				continue;
-			}
-			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, relation.toModel, relation.toNamespaceId, "Relation");
-			assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, "Relation");
-			const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
-			const to = crossRef(relation.toModel, relation.toNamespaceId !== void 0 && relation.toNamespaceId.length > 0 ? relation.toNamespaceId : resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId));
-			const on = {
-				localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-				targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
-			};
-			if (relation.cardinality === "N:M") {
-				if (!relation.through) throw contractError("CONTRACT.RELATION_INVALID", `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`, { meta: {
-					modelName: semanticModel.modelName,
-					relationName: relation.fieldName,
-					reason: "many-to-many-missing-through"
-				} });
-				modelRelations[relation.fieldName] = {
-					to,
-					cardinality: "N:M",
-					on,
-					through: buildThroughDescriptor(relation.through, tableNamespaceByName, targetModel, semanticModel.modelName, relation.fieldName, defaultNamespaceId)
-				};
-			} else modelRelations[relation.fieldName] = {
-				to,
-				cardinality: relation.cardinality,
-				on
-			};
-		}
-		let namespaceModels = modelsByNamespace[namespaceId];
-		if (namespaceModels === void 0) {
-			namespaceModels = {};
-			modelsByNamespace[namespaceId] = namespaceModels;
-		}
-		namespaceModels[semanticModel.modelName] = {
-			storage: {
-				table: tableName,
-				namespaceId,
-				fields: storageFields
-			},
-			fields: domainFields,
-			relations: modelRelations
-		};
-	}
-	const rootTableNameCounts = /* @__PURE__ */ new Map();
-	for (const entry of rootEntries) rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);
-	const roots = {};
-	for (const entry of rootEntries) {
-		const key = (rootTableNameCounts.get(entry.tableName) ?? 0) > 1 ? `${entry.namespaceId}.${entry.tableName}` : entry.tableName;
-		roots[key] = entry.ref;
-	}
-	const rawStorageTypes = definition.storageTypes ?? {};
-	const documentTypes = Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => {
-		if (entry.kind === "codec-instance") return [name, entry];
-		return [name, toStorageTypeInstance({
-			codecId: entry.codecId,
-			nativeType: entry.nativeType,
-			typeParams: entry.typeParams ?? {}
-		})];
-	}));
-	const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
-	const domainEnumsByNs = {};
-	const storageValueSetsByNs = {};
-	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
-		if (enumName !== handle.enumName) throw contractError("CONTRACT.ENUM_INVALID", `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`, { meta: {
-			enumName: handle.enumName,
-			declarationKey: enumName,
-			reason: "key-name-mismatch"
-		} });
-		const nsId = defaultNamespaceId;
-		let domainSlot = domainEnumsByNs[nsId];
-		if (domainSlot === void 0) {
-			domainSlot = {};
-			domainEnumsByNs[nsId] = domainSlot;
-		}
-		domainSlot[enumName] = {
-			codecId: handle.codecId,
-			members: handle.enumMembers.map((m) => ({
-				name: m.name,
-				value: encodeViaCodec(m.value, handle.codecId, codecLookup)
-			}))
-		};
-		let storageSlot = storageValueSetsByNs[nsId];
-		if (storageSlot === void 0) {
-			storageSlot = {};
-			storageValueSetsByNs[nsId] = storageSlot;
-		}
-		storageSlot[enumName] = {
-			kind: "valueSet",
-			values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup))
-		};
-	}
-	const { createNamespace } = definition;
-	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(nsInput)];
-	}));
-	const storageWithoutHash = {
-		...Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {},
-		namespaces: defaultNamespaceId === UNBOUND_NAMESPACE_ID ? ensureUnboundNamespaceSlot(namespaces, createNamespace) : namespaces
-	};
-	const storageHash = definition.storageHash ? coreHash(definition.storageHash) : computeStorageHash({
-		target,
-		targetFamily,
-		storage: storageWithoutHash,
-		...sqlContractCanonicalizationHooks
-	});
-	const storage = new SqlStorage({
-		...storageWithoutHash,
-		storageHash
-	});
-	const executionSection = executionDefaults.length > 0 ? { mutations: { defaults: executionDefaults.sort((a, b) => {
-		const tableCompare = a.ref.table.localeCompare(b.ref.table);
-		if (tableCompare !== 0) return tableCompare;
-		return a.ref.column.localeCompare(b.ref.column);
-	}) } } : void 0;
-	const extensionNamespaces = definition.extensions ? Object.values(definition.extensions).map((pack) => pack.id) : void 0;
-	const extensions = { ...definition.extensions || {} };
-	if (extensionNamespaces) {
-		for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensions, namespace)) extensions[namespace] = {};
-	}
-	const extensionPackCapabilitySources = definition.extensions ? Object.values(definition.extensions).map((pack) => pack.capabilities) : [];
-	const capabilities = mergeCapabilityMatrices(definition.target.capabilities, ...extensionPackCapabilitySources);
-	const profileHash = computeProfileHash({
-		target,
-		targetFamily,
-		capabilities: {}
-	});
-	const executionWithHash = executionSection ? {
-		...executionSection,
-		executionHash: computeExecutionHash({
-			target,
-			targetFamily,
-			execution: executionSection
-		})
-	} : void 0;
-	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, isValueObjectField(f) ? {
-		type: {
-			kind: "valueObject",
-			name: f.valueObjectName
-		},
-		nullable: f.nullable,
-		...f.many ? { many: true } : {}
-	} : {
-		type: {
-			kind: "scalar",
-			codecId: f.descriptor.codecId,
-			...ifDefined("typeParams", f.descriptor.typeParams)
-		},
-		nullable: f.nullable
-	}])) }])) : void 0;
-	const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
-	if (domainNamespaceIds.size === 0) domainNamespaceIds.add(defaultNamespaceId);
-	if (valueObjects !== void 0) domainNamespaceIds.add(defaultNamespaceId);
-	for (const nsId of Object.keys(domainEnumsByNs)) domainNamespaceIds.add(nsId);
-	const domainNamespaces = Object.fromEntries([...domainNamespaceIds].sort().map((namespaceId) => {
-		const modelsInNs = modelsByNamespace[namespaceId] ?? {};
-		const enumsInNs = domainEnumsByNs[namespaceId];
-		return [namespaceId, {
-			models: modelsInNs,
-			...namespaceId === defaultNamespaceId && valueObjects !== void 0 ? { valueObjects } : {},
-			...enumsInNs !== void 0 && Object.keys(enumsInNs).length > 0 ? { enum: enumsInNs } : {}
-		}];
-	}));
-	const contract = {
-		target,
-		targetFamily,
-		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
-		domain: { namespaces: domainNamespaces },
-		roots,
-		storage,
-		...executionWithHash ? { execution: executionWithHash } : {},
-		extensions,
-		capabilities,
-		profileHash,
-		meta: {}
-	};
-	assertStorageSemantics(definition, contract);
-	flushAuthoringWarnings(authoringWarnings);
-	return contract;
-}
-/**
-* The one step every SQL contract specifier funnels its loaded contract
-* through: stamp the specifier's default control policy, then strip derived
-* checks from every table the stamped policy leaves non-managed. Composing the
-* two here is what keeps the managed-only consequence from being skipped on
-* any specifier route.
-*/
-function applySqlSpecifierControlPolicy(contract, defaultControlPolicy, createNamespace) {
-	return stripDerivedChecksFromNonManagedTables(applySpecifierDefaultControlPolicy(contract, defaultControlPolicy), createNamespace);
-}
-/**
-* Removes generated enforcement checks from every table whose effective
-* control policy is not `managed`.
-*
-* A check is derived iff its wire prefix is one derivation would produce for
-* some column of its table — {@link derivedCheckPrefixes} enumerates that
-* set. Wire-naming alone no longer identifies derivation: an authored
-* `name:` check (`@@check` / `check()`) is wire-named too, so a bare
-* `check.prefix === undefined` test would delete an author's own constraint
-* from every non-`managed` table. The prefix-shape rule tests against the
-* table's own columns instead of the naming mode, so an authored check with
-* an unrelated prefix survives.
-*
-* The rule is weaker than recomputing the content hash `contract infer`
-* uses: that needs `postgresRenderCheckExpressions` to know what a kind
-* renders, and this funnel has no target descriptor to reach it through. It
-* can only ask whether some column could have produced a prefix of this
-* shape, not whether this exact column produced this exact check. The gap
-* that opens — an authored name that collides with a derived-prefix shape —
-* is closed at authoring time instead: such a name is rejected
-* (`CONTRACT.CHECK_NAME_RESERVED`) before it ever reaches storage.
-*
-* Why derivation stops at the namespace boundary: the contract *describes* an
-* external schema, it does not *prescribe* enforcement for it. Deriving a check
-* for a table Prisma Next never creates declares a constraint the live database
-* has no reason to carry, and `external` fails verify on a declared shape the
-* database lacks — an unfixable failure, since no plan may emit DDL there
-* either.
-*
-* This is the post-build half of the rule. Authoring skips derivation for a
-* table whose policy is known in the source; this pass catches the policy a
-* contract *specifier* applies after the contract is already built, which is
-* the only signal a pack like the Supabase extension gives. Specifiers reach
-* it through `applySqlSpecifierControlPolicy` above.
-*
-* Returns the contract unchanged (same reference) when nothing is stripped.
-* When something is, the storage hash is recomputed — the stripped contract
-* describes different storage.
-*/
-function stripDerivedChecksFromNonManagedTables(contract, createNamespace) {
-	const storage = contract.storage;
-	if (!isSqlStorageShaped(storage)) return contract;
-	let anyStripped = false;
-	const namespaces = {};
-	for (const [namespaceId, namespace] of Object.entries(storage.namespaces)) {
-		if (!isMaterializedSqlNamespace(namespace)) return contract;
-		const tables = namespace.entries["table"];
-		if (tables === void 0) {
-			namespaces[namespaceId] = namespace;
-			continue;
-		}
-		let namespaceStripped = false;
-		const nextTables = {};
-		for (const [tableName, table] of Object.entries(tables)) {
-			const stripped = StorageTable.is(table) ? withoutDerivedChecks(tableName, table, contract.defaultControlPolicy) : table;
-			if (stripped !== table) namespaceStripped = true;
-			nextTables[tableName] = stripped;
-		}
-		if (!namespaceStripped) {
-			namespaces[namespaceId] = namespace;
-			continue;
-		}
-		anyStripped = true;
-		namespaces[namespaceId] = createNamespace({
-			id: namespace.id,
-			entries: {
-				...namespace.entries,
-				table: nextTables
-			}
-		});
-	}
-	if (!anyStripped) return contract;
-	const storageWithoutHash = {
-		namespaces,
-		...ifDefined("types", storage.types)
-	};
-	return {
-		...contract,
-		storage: new SqlStorage({
-			...storageWithoutHash,
-			storageHash: computeStorageHash({
-				target: contract.target,
-				targetFamily: contract.targetFamily,
-				storage: storageWithoutHash,
-				...sqlContractCanonicalizationHooks
-			})
-		})
-	};
-}
-/**
-* Structural stand-in for `instanceof SqlStorage`: like the checks it wraps, a
-* storage instance can arrive from a realm whose IR classes are a separate
-* copy (the dist e2e shape), where an `instanceof` test would miss.
-*/
-function isSqlStorageShaped(x) {
-	if (typeof x !== "object" || x === null || !("namespaces" in x)) return false;
-	return typeof x.namespaces === "object" && x.namespaces !== null;
-}
-/** The table itself when it keeps every check, a rebuilt one when it does not. */
-function withoutDerivedChecks(tableName, table, contractDefault) {
-	const checks = table.checks;
-	if (checks === void 0 || checks.length === 0) return table;
-	if (effectiveControlPolicy(table.control, contractDefault) === "managed") return table;
-	const columnNames = Object.keys(table.columns);
-	invariant(columnNames.length > 0, `withoutDerivedChecks: table "${tableName}" carries checks but its column map is empty. The caller must pass the table's real, complete column set — an empty or partial map makes every check misclassify as non-derived and survive the strip.`);
-	const derivedPrefixes = derivedCheckPrefixes(tableName, columnNames);
-	const kept = checks.filter((check) => check.prefix === void 0 || !derivedPrefixes.has(check.prefix));
-	if (kept.length === checks.length) return table;
-	return new StorageTable({
-		columns: table.columns,
-		uniques: table.uniques,
-		indexes: table.indexes,
-		foreignKeys: table.foreignKeys,
-		...ifDefined("primaryKey", table.primaryKey),
-		...ifDefined("control", table.control),
-		...kept.length > 0 ? { checks: kept.map((check) => checkConstraintInputFromSerialized({
-			name: check.name,
-			...ifDefined("prefix", check.prefix),
-			expression: check.expression
-		})) } : {}
-	});
-}
-//#endregion
-export { buildSqlContractFromDefinition as n, contractError as r, applySqlSpecifierControlPolicy as t };
-
-//# sourceMappingURL=derived-checks-DFMRmiAu-DGfB8aS4.mjs.map