@prisma-next/contract 0.12.0 → 0.13.0-dev.10

package/dist/types.mjs

@@ -1,46 +1,56 @@
-import { n as DomainNamespaceResolutionError } from "./contract-validation-error-ClZaKqMW.mjs";
-import { t as asNamespaceId } from "./namespace-id-CVpkSFUK.mjs";
+import { n as DomainNamespaceResolutionError } from "./contract-validation-error-BFA66rwU.mjs";
+import { n as soleDomainNamespaceId, t as UNBOUND_DOMAIN_NAMESPACE_ID } from "./default-namespace-rpdJeUMq.mjs";
+import { t as resolveDomainModel } from "./resolve-domain-model-BovPAsW2.mjs";
+import { t as asNamespaceId } from "./namespace-id-CUxYd4KL.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { type } from "arktype";
+//#region src/control-policy.ts
+/**
+* Resolves the effective control policy for a storage-plane node.
+*
+* Precedence: node-level value → contract default → `'managed'`.
+*
+* Both parameters are optional raw values so this function stays node-type-agnostic
+* and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
+*/
+function effectiveControlPolicy(nodeControl, defaultControlPolicy) {
+	return nodeControl ?? defaultControlPolicy ?? "managed";
+}
+//#endregion
 //#region src/cross-reference.ts
-const CrossReferenceSchema = blindCast(type({
+const CrossReferenceSchema = /* @__PURE__ */ blindCast(/* @__PURE__ */ type({
 	"+": "reject",
 	namespace: "string",
-	model: "string"
+	model: "string",
+	"space?": "string"
 }));
 const DEFAULT_CROSS_REF_NAMESPACE = "__unbound__";
-function crossRef(model, namespace = DEFAULT_CROSS_REF_NAMESPACE) {
+function crossRef(model, namespace = DEFAULT_CROSS_REF_NAMESPACE, space) {
 	return {
 		namespace: asNamespaceId(namespace),
-		model
+		model,
+		...space !== void 0 ? { space } : {}
 	};
 }
 //#endregion
-//#region src/domain-envelope.ts
-const UNBOUND_DOMAIN_NAMESPACE_ID = "__unbound__";
-function resolveSingleDomainNamespaceId(domain, namespaceId) {
-	if (namespaceId !== void 0) {
-		if (!Object.hasOwn(domain.namespaces, namespaceId)) throw new DomainNamespaceResolutionError(`domain namespace "${namespaceId}" is not present on the contract`);
-		return namespaceId;
-	}
-	const namespaceIds = Object.keys(domain.namespaces);
-	if (namespaceIds.length === 0) throw new DomainNamespaceResolutionError("domain has no namespaces");
-	if (namespaceIds.length > 1) throw new DomainNamespaceResolutionError(`expected exactly one domain namespace, found ${namespaceIds.length} (${namespaceIds.join(", ")})`);
-	const [soleNamespaceId] = namespaceIds;
-	if (soleNamespaceId === void 0) throw new DomainNamespaceResolutionError("domain has no namespaces");
-	return soleNamespaceId;
-}
-function contractModels(contract, namespaceId) {
-	const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-	const domainNamespace = contract.domain.namespaces[resolved];
-	if (domainNamespace === void 0) throw new DomainNamespaceResolutionError(`domain namespace "${resolved}" is not present on the contract`);
+//#region src/domain-namespace-access.ts
+/**
+* Models map for the contract's single domain namespace. Throws when the
+* contract does not declare exactly one namespace — bare-name access is
+* ambiguous across namespaces and must be qualified explicitly (TML-2550).
+*/
+function domainModelsAtDefaultNamespace(domain) {
+	const namespaceId = soleDomainNamespaceId(domain);
+	const domainNamespace = domain.namespaces[namespaceId];
+	if (domainNamespace === void 0) throw new DomainNamespaceResolutionError(`domain namespace "${namespaceId}" is not present on the contract`);
 	return domainNamespace.models;
 }
-function contractValueObjects(contract, namespaceId) {
-	const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-	const domainNamespace = contract.domain.namespaces[resolved];
-	if (domainNamespace === void 0) throw new DomainNamespaceResolutionError(`domain namespace "${resolved}" is not present on the contract`);
-	return domainNamespace.valueObjects;
+/**
+* Value objects for the contract's single domain namespace, when present.
+* Throws when the contract does not declare exactly one namespace.
+*/
+function domainValueObjectsAtDefaultNamespace(domain) {
+	return domain.namespaces[soleDomainNamespaceId(domain)]?.valueObjects;
 }
 //#endregion
 //#region src/types.ts
@@ -86,6 +96,6 @@ function isExecutionMutationDefaultValue(value) {
 	return true;
 }
 //#endregion
-export { CrossReferenceSchema, DomainNamespaceResolutionError, UNBOUND_DOMAIN_NAMESPACE_ID, asNamespaceId, contractModels, contractValueObjects, coreHash, crossRef, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash, resolveSingleDomainNamespaceId };
+export { CrossReferenceSchema, DomainNamespaceResolutionError, UNBOUND_DOMAIN_NAMESPACE_ID, asNamespaceId, coreHash, crossRef, domainModelsAtDefaultNamespace, domainValueObjectsAtDefaultNamespace, effectiveControlPolicy, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash, resolveDomainModel, soleDomainNamespaceId };
 
 //# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../src/cross-reference.ts","../src/domain-envelope.ts","../src/types.ts"],"sourcesContent":["import { blindCast } from '@prisma-next/utils/casts';\nimport { type Type, type } from 'arktype';\nimport { asNamespaceId, type NamespaceId } from './namespace-id';\n\nexport interface CrossReference {\n  readonly namespace: NamespaceId;\n  readonly model: string;\n}\n\nexport const CrossReferenceSchema = blindCast<\n  Type<CrossReference>,\n  'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'\n>(\n  type({\n    '+': 'reject',\n    namespace: 'string',\n    model: 'string',\n  }),\n);\n\nconst DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';\n\nexport function crossRef(\n  model: string,\n  namespace: string = DEFAULT_CROSS_REF_NAMESPACE,\n): CrossReference {\n  return { namespace: asNamespaceId(namespace), model };\n}\n","import { DomainNamespaceResolutionError } from './contract-validation-error';\nimport type { ContractModelBase, ContractValueObject } from './domain-types';\n\nexport const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;\n\n/**\n * One namespace's application-domain entities — models and optional value\n * objects keyed by entity name within that namespace coordinate.\n */\nexport interface ApplicationDomainNamespace<\n  TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>,\n> {\n  readonly models: TModels;\n  readonly valueObjects?: Record<string, ContractValueObject>;\n}\n\n/**\n * Application-domain envelope: entity content keyed by namespace id.\n * Mirrors the storage plane's `namespaces` segment (ADR 221).\n */\nexport interface ApplicationDomain<\n  TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>,\n> {\n  readonly namespaces: Readonly<Record<string, ApplicationDomainNamespace<TModels>>>;\n}\n\nexport type ContractWithDomain = {\n  readonly domain: ApplicationDomain;\n};\n\nexport function resolveSingleDomainNamespaceId(\n  domain: ApplicationDomain,\n  namespaceId?: string,\n): string {\n  if (namespaceId !== undefined) {\n    if (!Object.hasOwn(domain.namespaces, namespaceId)) {\n      throw new DomainNamespaceResolutionError(\n        `domain namespace \"${namespaceId}\" is not present on the contract`,\n      );\n    }\n    return namespaceId;\n  }\n\n  const namespaceIds = Object.keys(domain.namespaces);\n  if (namespaceIds.length === 0) {\n    throw new DomainNamespaceResolutionError('domain has no namespaces');\n  }\n  if (namespaceIds.length > 1) {\n    throw new DomainNamespaceResolutionError(\n      `expected exactly one domain namespace, found ${namespaceIds.length} (${namespaceIds.join(', ')})`,\n    );\n  }\n  const [soleNamespaceId] = namespaceIds;\n  if (soleNamespaceId === undefined) {\n    throw new DomainNamespaceResolutionError('domain has no namespaces');\n  }\n  return soleNamespaceId;\n}\n\n// Transitional single-namespace projection; pending runtime-qualification slice.\nexport function contractModels<TModels extends Record<string, ContractModelBase>>(\n  contract: { readonly domain: ApplicationDomain<TModels> },\n  namespaceId?: string,\n): TModels {\n  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);\n  const domainNamespace = contract.domain.namespaces[resolved];\n  if (domainNamespace === undefined) {\n    throw new DomainNamespaceResolutionError(\n      `domain namespace \"${resolved}\" is not present on the contract`,\n    );\n  }\n  return domainNamespace.models;\n}\n\nexport function contractValueObjects<TModels extends Record<string, ContractModelBase>>(\n  contract: { readonly domain: ApplicationDomain<TModels> },\n  namespaceId?: string,\n): Record<string, ContractValueObject> | undefined {\n  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);\n  const domainNamespace = contract.domain.namespaces[resolved];\n  if (domainNamespace === undefined) {\n    throw new DomainNamespaceResolutionError(\n      `domain namespace \"${resolved}\" is not present on the contract`,\n    );\n  }\n  return domainNamespace.valueObjects;\n}\n","/**\n * Unique symbol used as the key for branding types.\n */\nexport const $: unique symbol = Symbol('__prisma_next_brand__');\n\n/**\n * A helper type to brand a given type with a unique identifier.\n *\n * @template TKey Text used as the brand key.\n * @template TValue Optional value associated with the brand key. Defaults to `true`.\n */\nexport type Brand<TKey extends string | number | symbol, TValue = true> = {\n  [$]: {\n    [K in TKey]: TValue;\n  };\n};\n\n/**\n * Base type for storage contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type StorageHash = StorageHashBase<'sha256:abc123...'>`\n */\nexport type StorageHashBase<THash extends string> = THash & Brand<'StorageHash'>;\n\n/**\n * Base type for execution contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ExecutionHash = ExecutionHashBase<'sha256:def456...'>`\n */\nexport type ExecutionHashBase<THash extends string> = THash & Brand<'ExecutionHash'>;\n\nexport function executionHash<const T extends string>(value: T): ExecutionHashBase<T> {\n  return value as ExecutionHashBase<T>;\n}\n\nexport function coreHash<const T extends string>(value: T): StorageHashBase<T> {\n  return value as StorageHashBase<T>;\n}\n\n/**\n * Base type for profile contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ProfileHash = ProfileHashBase<'sha256:def456...'>`\n */\nexport type ProfileHashBase<THash extends string> = THash & Brand<'ProfileHash'>;\n\nexport function profileHash<const T extends string>(value: T): ProfileHashBase<T> {\n  return value as ProfileHashBase<T>;\n}\n\n/**\n * One entity-kind slot in a namespace — a map of entity name to entry.\n * Values are opaque at the foundation layer; family and target concretions\n * refine them to typed IR classes.\n */\nexport type StorageEntitySlot = Readonly<Record<string, unknown>>;\n\n/**\n * Plain-data namespace entry in a storage block. Every hydrated contract\n * carries at least `id` plus zero or more entity-kind slot maps (`tables`,\n * `collections`, …). Foundation declares only this shape — no IR machinery.\n */\nexport interface StorageNamespace {\n  readonly id: string;\n}\n\n/**\n * Base type for family-specific storage blocks.\n * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the\n * storage hash alongside family-specific data (tables, collections, etc.).\n *\n * The `namespaces` map is carried by every hydrated storage block. Serialized\n * envelope shape is target-owned; this types the in-memory contract after\n * `deserializeContract`.\n */\nexport interface StorageBase<THash extends string = string> {\n  readonly storageHash: StorageHashBase<THash>;\n  readonly namespaces: Readonly<Record<string, StorageNamespace>>;\n}\n\nexport interface FieldType {\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly items?: FieldType;\n  readonly properties?: Record<string, FieldType>;\n}\n\nexport type GeneratedValueSpec = {\n  readonly id: string;\n  readonly params?: Record<string, unknown>;\n};\n\nexport type JsonPrimitive = string | number | boolean | null;\n\nexport type JsonValue =\n  | JsonPrimitive\n  | { readonly [key: string]: JsonValue }\n  | readonly JsonValue[];\n\nexport type ColumnDefaultLiteralValue = JsonValue;\n\nexport type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | Date;\n\n/**\n * Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers\n * resolve template values from caller-supplied args (typed `unknown` at the\n * boundary) and need to validate before constructing a `ColumnDefault`.\n * Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`\n * instances. Rejects functions, class instances (other than `Date`),\n * `undefined`, `bigint`, `symbol`, and arrays/objects containing those.\n */\nexport function isColumnDefaultLiteralInputValue(\n  value: unknown,\n): value is ColumnDefaultLiteralInputValue {\n  if (value === null) return true;\n  const t = typeof value;\n  if (t === 'string' || t === 'number' || t === 'boolean') return true;\n  if (value instanceof Date) return true;\n  if (Array.isArray(value)) return value.every(isColumnDefaultLiteralInputValue);\n  if (t === 'object' && Object.getPrototypeOf(value) === Object.prototype) {\n    return Object.values(value as Record<string, unknown>).every(isColumnDefaultLiteralInputValue);\n  }\n  return false;\n}\n\nexport type ColumnDefault =\n  | {\n      readonly kind: 'literal';\n      readonly value: ColumnDefaultLiteralInputValue;\n    }\n  | { readonly kind: 'function'; readonly expression: string };\n\nexport function isColumnDefault(value: unknown): value is ColumnDefault {\n  if (typeof value !== 'object' || value === null) return false;\n  const kind = (value as { kind?: unknown }).kind;\n  if (kind === 'literal') {\n    return 'value' in value;\n  }\n  if (kind === 'function') {\n    return typeof (value as { expression?: unknown }).expression === 'string';\n  }\n  return false;\n}\n\nexport type ExecutionMutationDefaultValue = {\n  readonly kind: 'generator';\n  readonly id: GeneratedValueSpec['id'];\n  readonly params?: Record<string, unknown>;\n};\n\nexport function isExecutionMutationDefaultValue(\n  value: unknown,\n): value is ExecutionMutationDefaultValue {\n  if (typeof value !== 'object' || value === null) return false;\n  const candidate = value as {\n    kind?: unknown;\n    id?: unknown;\n    params?: unknown;\n  };\n  if (candidate.kind !== 'generator') return false;\n  if (typeof candidate.id !== 'string') return false;\n  if (\n    candidate.params !== undefined &&\n    (typeof candidate.params !== 'object' ||\n      candidate.params === null ||\n      Array.isArray(candidate.params))\n  ) {\n    return false;\n  }\n  return true;\n}\n\nexport type ExecutionMutationDefault = {\n  readonly ref: { readonly table: string; readonly column: string };\n  readonly onCreate?: ExecutionMutationDefaultValue;\n  readonly onUpdate?: ExecutionMutationDefaultValue;\n};\n\n/**\n * `ExecutionMutationDefault` minus its `ref` — the per-field phases value\n * authoring layers attach to a column before the column ref is known.\n */\nexport type ExecutionMutationDefaultPhases = Omit<ExecutionMutationDefault, 'ref'>;\n\nexport type ExecutionSection<THash extends string = string> = {\n  readonly executionHash: ExecutionHashBase<THash>;\n  readonly mutations: {\n    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;\n  };\n};\n\nexport interface Source {\n  readonly readOnly: boolean;\n  readonly projection: Record<string, FieldType>;\n  readonly origin?: Record<string, unknown>;\n  readonly capabilities?: Record<string, boolean>;\n}\n\n// Document family types\nexport interface DocIndex {\n  readonly name: string;\n  readonly keys: Record<string, 'asc' | 'desc'>;\n  readonly unique?: boolean;\n  readonly where?: Expr;\n}\n\nexport type Expr =\n  | { readonly kind: 'eq'; readonly path: ReadonlyArray<string>; readonly value: unknown }\n  | { readonly kind: 'exists'; readonly path: ReadonlyArray<string> };\n\nexport interface DocCollection {\n  readonly name: string;\n  readonly id?: {\n    readonly strategy: 'auto' | 'client' | 'uuid' | 'objectId';\n  };\n  readonly fields: Record<string, FieldType>;\n  readonly indexes?: ReadonlyArray<DocIndex>;\n  readonly readOnly?: boolean;\n}\n\nexport interface PlanMeta {\n  readonly target: string;\n  readonly targetFamily?: string;\n  readonly storageHash: string;\n  readonly profileHash?: string;\n  readonly lane: string;\n  readonly annotations?: {\n    readonly [key: string]: unknown;\n  };\n}\n\n/**\n * Contract marker record stored in the database.\n * Represents the current contract identity for a database.\n */\nexport interface ContractMarkerRecord {\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson: unknown | null;\n  readonly canonicalVersion: number | null;\n  readonly updatedAt: Date;\n  readonly appTag: string | null;\n  readonly meta: Record<string, unknown>;\n  readonly invariants: readonly string[];\n}\n"],"mappings":";;;;;AASA,MAAa,uBAAuB,UAIlC,KAAK;CACH,KAAK;CACL,WAAW;CACX,OAAO;AACT,CAAC,CACH;AAEA,MAAM,8BAA8B;AAEpC,SAAgB,SACd,OACA,YAAoB,6BACJ;CAChB,OAAO;EAAE,WAAW,cAAc,SAAS;EAAG;CAAM;AACtD;;;ACxBA,MAAa,8BAA8B;AA2B3C,SAAgB,+BACd,QACA,aACQ;CACR,IAAI,gBAAgB,KAAA,GAAW;EAC7B,IAAI,CAAC,OAAO,OAAO,OAAO,YAAY,WAAW,GAC/C,MAAM,IAAI,+BACR,qBAAqB,YAAY,iCACnC;EAEF,OAAO;CACT;CAEA,MAAM,eAAe,OAAO,KAAK,OAAO,UAAU;CAClD,IAAI,aAAa,WAAW,GAC1B,MAAM,IAAI,+BAA+B,0BAA0B;CAErE,IAAI,aAAa,SAAS,GACxB,MAAM,IAAI,+BACR,gDAAgD,aAAa,OAAO,IAAI,aAAa,KAAK,IAAI,EAAE,EAClG;CAEF,MAAM,CAAC,mBAAmB;CAC1B,IAAI,oBAAoB,KAAA,GACtB,MAAM,IAAI,+BAA+B,0BAA0B;CAErE,OAAO;AACT;AAGA,SAAgB,eACd,UACA,aACS;CACT,MAAM,WAAW,+BAA+B,SAAS,QAAQ,WAAW;CAC5E,MAAM,kBAAkB,SAAS,OAAO,WAAW;CACnD,IAAI,oBAAoB,KAAA,GACtB,MAAM,IAAI,+BACR,qBAAqB,SAAS,iCAChC;CAEF,OAAO,gBAAgB;AACzB;AAEA,SAAgB,qBACd,UACA,aACiD;CACjD,MAAM,WAAW,+BAA+B,SAAS,QAAQ,WAAW;CAC5E,MAAM,kBAAkB,SAAS,OAAO,WAAW;CACnD,IAAI,oBAAoB,KAAA,GACtB,MAAM,IAAI,+BACR,qBAAqB,SAAS,iCAChC;CAEF,OAAO,gBAAgB;AACzB;;;ACvDA,SAAgB,cAAsC,OAAgC;CACpF,OAAO;AACT;AAEA,SAAgB,SAAiC,OAA8B;CAC7E,OAAO;AACT;AASA,SAAgB,YAAoC,OAA8B;CAChF,OAAO;AACT;;;;;;;;;AA+DA,SAAgB,iCACd,OACyC;CACzC,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,IAAI,OAAO;CACjB,IAAI,MAAM,YAAY,MAAM,YAAY,MAAM,WAAW,OAAO;CAChE,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,MAAM,gCAAgC;CAC7E,IAAI,MAAM,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO,WAC5D,OAAO,OAAO,OAAO,KAAgC,EAAE,MAAM,gCAAgC;CAE/F,OAAO;AACT;AASA,SAAgB,gBAAgB,OAAwC;CACtE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,OAAQ,MAA6B;CAC3C,IAAI,SAAS,WACX,OAAO,WAAW;CAEpB,IAAI,SAAS,YACX,OAAO,OAAQ,MAAmC,eAAe;CAEnE,OAAO;AACT;AAQA,SAAgB,gCACd,OACwC;CACxC,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,YAAY;CAKlB,IAAI,UAAU,SAAS,aAAa,OAAO;CAC3C,IAAI,OAAO,UAAU,OAAO,UAAU,OAAO;CAC7C,IACE,UAAU,WAAW,KAAA,MACpB,OAAO,UAAU,WAAW,YAC3B,UAAU,WAAW,QACrB,MAAM,QAAQ,UAAU,MAAM,IAEhC,OAAO;CAET,OAAO;AACT"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/control-policy.ts","../src/cross-reference.ts","../src/domain-namespace-access.ts","../src/types.ts"],"sourcesContent":["/**\n * Governance posture for a storage-plane node or for the contract as a whole.\n *\n * - `managed`  — Prisma Next owns the full lifecycle (DDL, migrations, verification).\n * - `tolerated` — node was found in the database but is not schema-managed; Prisma Next\n *   leaves it untouched while tracking its existence.\n * - `external` — node is owned by an external system; Prisma Next never emits DDL for it.\n * - `observed` — read-only access; Prisma Next does not write to or migrate the node.\n */\nexport type ControlPolicy = 'managed' | 'tolerated' | 'external' | 'observed';\n\n/**\n * Resolves the effective control policy for a storage-plane node.\n *\n * Precedence: node-level value → contract default → `'managed'`.\n *\n * Both parameters are optional raw values so this function stays node-type-agnostic\n * and can be called by any consumer (verifier, planner, etc.) without importing IR classes.\n */\nexport function effectiveControlPolicy(\n  nodeControl: ControlPolicy | undefined,\n  defaultControlPolicy: ControlPolicy | undefined,\n): ControlPolicy {\n  return nodeControl ?? defaultControlPolicy ?? 'managed';\n}\n","import { blindCast } from '@prisma-next/utils/casts';\nimport { type Type, type } from 'arktype';\nimport { asNamespaceId, type NamespaceId } from './namespace-id';\n\nexport interface CrossReference {\n  readonly namespace: NamespaceId;\n  readonly model: string;\n  /**\n   * Contract-space identity for cross-space relations. When present, the\n   * referenced model lives in a different contract space. Absent for local\n   * (same-space) relations.\n   */\n  readonly space?: string;\n}\n\nexport const CrossReferenceSchema = /* @__PURE__ */ blindCast<\n  Type<CrossReference>,\n  'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'\n>(\n  /* @__PURE__ */ type({\n    '+': 'reject',\n    namespace: 'string',\n    model: 'string',\n    'space?': 'string',\n  }),\n);\n\nconst DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';\n\nexport function crossRef(\n  model: string,\n  namespace: string = DEFAULT_CROSS_REF_NAMESPACE,\n  space?: string,\n): CrossReference {\n  return {\n    namespace: asNamespaceId(namespace),\n    model,\n    ...(space !== undefined ? { space } : {}),\n  };\n}\n","import { DomainNamespaceResolutionError } from './contract-validation-error';\nimport { soleDomainNamespaceId } from './default-namespace';\nimport type { ApplicationDomain } from './domain-envelope';\nimport type { ContractModelBase, ContractValueObject } from './domain-types';\n\n/**\n * Models map for the contract's single domain namespace. Throws when the\n * contract does not declare exactly one namespace — bare-name access is\n * ambiguous across namespaces and must be qualified explicitly (TML-2550).\n */\nexport function domainModelsAtDefaultNamespace<TModels extends Record<string, ContractModelBase>>(\n  domain: ApplicationDomain<TModels>,\n): TModels {\n  const namespaceId = soleDomainNamespaceId(domain);\n  const domainNamespace = domain.namespaces[namespaceId];\n  if (domainNamespace === undefined) {\n    throw new DomainNamespaceResolutionError(\n      `domain namespace \"${namespaceId}\" is not present on the contract`,\n    );\n  }\n  return domainNamespace.models;\n}\n\n/**\n * Value objects for the contract's single domain namespace, when present.\n * Throws when the contract does not declare exactly one namespace.\n */\nexport function domainValueObjectsAtDefaultNamespace<\n  TModels extends Record<string, ContractModelBase>,\n>(domain: ApplicationDomain<TModels>): Record<string, ContractValueObject> | undefined {\n  return domain.namespaces[soleDomainNamespaceId(domain)]?.valueObjects;\n}\n","/**\n * Unique symbol used as the key for branding types.\n */\nexport const $: unique symbol = Symbol('__prisma_next_brand__');\n\n/**\n * A helper type to brand a given type with a unique identifier.\n *\n * @template TKey Text used as the brand key.\n * @template TValue Optional value associated with the brand key. Defaults to `true`.\n */\nexport type Brand<TKey extends string | number | symbol, TValue = true> = {\n  [$]: {\n    [K in TKey]: TValue;\n  };\n};\n\n/**\n * Base type for storage contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type StorageHash = StorageHashBase<'sha256:abc123...'>`\n */\nexport type StorageHashBase<THash extends string> = THash & Brand<'StorageHash'>;\n\n/**\n * Base type for execution contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ExecutionHash = ExecutionHashBase<'sha256:def456...'>`\n */\nexport type ExecutionHashBase<THash extends string> = THash & Brand<'ExecutionHash'>;\n\nexport function executionHash<const T extends string>(value: T): ExecutionHashBase<T> {\n  return value as ExecutionHashBase<T>;\n}\n\nexport function coreHash<const T extends string>(value: T): StorageHashBase<T> {\n  return value as StorageHashBase<T>;\n}\n\n/**\n * Base type for profile contract hashes.\n * Emitted contract.d.ts files use this with the hash value as a type parameter:\n * `type ProfileHash = ProfileHashBase<'sha256:def456...'>`\n */\nexport type ProfileHashBase<THash extends string> = THash & Brand<'ProfileHash'>;\n\nexport function profileHash<const T extends string>(value: T): ProfileHashBase<T> {\n  return value as ProfileHashBase<T>;\n}\n\n/**\n * One entity-kind slot in a namespace — a map of entity name to entry.\n * Values are opaque at the foundation layer; family and target concretions\n * refine them to typed IR classes.\n */\nexport type StorageEntitySlot = Readonly<Record<string, unknown>>;\n\n/**\n * Plain-data namespace entry in a storage block. Every hydrated contract\n * carries at least `id` plus entity-kind slot maps under `entries`\n * (`table`, `collection`, …). Foundation declares only this shape — no IR\n * machinery.\n */\nexport interface StorageNamespace {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, StorageEntitySlot>>;\n}\n\n/**\n * Base type for family-specific storage blocks.\n * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the\n * storage hash alongside family-specific data (tables, collections, etc.).\n *\n * The `namespaces` map is carried by every hydrated storage block. Serialized\n * envelope shape is target-owned; this types the in-memory contract after\n * `deserializeContract`.\n */\nexport interface StorageBase<THash extends string = string> {\n  readonly storageHash: StorageHashBase<THash>;\n  readonly namespaces: Readonly<Record<string, StorageNamespace>>;\n}\n\nexport interface FieldType {\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly items?: FieldType;\n  readonly properties?: Record<string, FieldType>;\n}\n\nexport type GeneratedValueSpec = {\n  readonly id: string;\n  readonly params?: Record<string, unknown>;\n};\n\nexport type JsonPrimitive = string | number | boolean | null;\n\nexport type JsonValue =\n  | JsonPrimitive\n  | { readonly [key: string]: JsonValue }\n  | readonly JsonValue[];\n\nexport type ColumnDefaultLiteralValue = JsonValue;\n\nexport type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | Date;\n\n/**\n * Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers\n * resolve template values from caller-supplied args (typed `unknown` at the\n * boundary) and need to validate before constructing a `ColumnDefault`.\n * Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`\n * instances. Rejects functions, class instances (other than `Date`),\n * `undefined`, `bigint`, `symbol`, and arrays/objects containing those.\n */\nexport function isColumnDefaultLiteralInputValue(\n  value: unknown,\n): value is ColumnDefaultLiteralInputValue {\n  if (value === null) return true;\n  const t = typeof value;\n  if (t === 'string' || t === 'number' || t === 'boolean') return true;\n  if (value instanceof Date) return true;\n  if (Array.isArray(value)) return value.every(isColumnDefaultLiteralInputValue);\n  if (t === 'object' && Object.getPrototypeOf(value) === Object.prototype) {\n    return Object.values(value as Record<string, unknown>).every(isColumnDefaultLiteralInputValue);\n  }\n  return false;\n}\n\nexport type ColumnDefault =\n  | {\n      readonly kind: 'literal';\n      readonly value: ColumnDefaultLiteralInputValue;\n    }\n  | { readonly kind: 'function'; readonly expression: string };\n\nexport function isColumnDefault(value: unknown): value is ColumnDefault {\n  if (typeof value !== 'object' || value === null) return false;\n  const kind = (value as { kind?: unknown }).kind;\n  if (kind === 'literal') {\n    return 'value' in value;\n  }\n  if (kind === 'function') {\n    return typeof (value as { expression?: unknown }).expression === 'string';\n  }\n  return false;\n}\n\nexport type ExecutionMutationDefaultValue = {\n  readonly kind: 'generator';\n  readonly id: GeneratedValueSpec['id'];\n  readonly params?: Record<string, unknown>;\n};\n\nexport function isExecutionMutationDefaultValue(\n  value: unknown,\n): value is ExecutionMutationDefaultValue {\n  if (typeof value !== 'object' || value === null) return false;\n  const candidate = value as {\n    kind?: unknown;\n    id?: unknown;\n    params?: unknown;\n  };\n  if (candidate.kind !== 'generator') return false;\n  if (typeof candidate.id !== 'string') return false;\n  if (\n    candidate.params !== undefined &&\n    (typeof candidate.params !== 'object' ||\n      candidate.params === null ||\n      Array.isArray(candidate.params))\n  ) {\n    return false;\n  }\n  return true;\n}\n\nexport type ExecutionMutationDefault = {\n  readonly ref: { readonly table: string; readonly column: string };\n  readonly onCreate?: ExecutionMutationDefaultValue;\n  readonly onUpdate?: ExecutionMutationDefaultValue;\n};\n\n/**\n * `ExecutionMutationDefault` minus its `ref` — the per-field phases value\n * authoring layers attach to a column before the column ref is known.\n */\nexport type ExecutionMutationDefaultPhases = Omit<ExecutionMutationDefault, 'ref'>;\n\nexport type ExecutionSection<THash extends string = string> = {\n  readonly executionHash: ExecutionHashBase<THash>;\n  readonly mutations: {\n    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;\n  };\n};\n\nexport interface Source {\n  readonly readOnly: boolean;\n  readonly projection: Record<string, FieldType>;\n  readonly origin?: Record<string, unknown>;\n  readonly capabilities?: Record<string, boolean>;\n}\n\n// Document family types\nexport interface DocIndex {\n  readonly name: string;\n  readonly keys: Record<string, 'asc' | 'desc'>;\n  readonly unique?: boolean;\n  readonly where?: Expr;\n}\n\nexport type Expr =\n  | { readonly kind: 'eq'; readonly path: ReadonlyArray<string>; readonly value: unknown }\n  | { readonly kind: 'exists'; readonly path: ReadonlyArray<string> };\n\nexport interface DocCollection {\n  readonly name: string;\n  readonly id?: {\n    readonly strategy: 'auto' | 'client' | 'uuid' | 'objectId';\n  };\n  readonly fields: Record<string, FieldType>;\n  readonly indexes?: ReadonlyArray<DocIndex>;\n  readonly readOnly?: boolean;\n}\n\nexport interface PlanMeta {\n  readonly target: string;\n  readonly targetFamily?: string;\n  readonly storageHash: string;\n  readonly profileHash?: string;\n  readonly lane: string;\n  readonly annotations?: {\n    readonly [key: string]: unknown;\n  };\n}\n\n/**\n * Contract marker record stored in the database.\n * Represents the current contract identity for a database.\n */\nexport interface ContractMarkerRecord {\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson: unknown | null;\n  readonly canonicalVersion: number | null;\n  readonly updatedAt: Date;\n  readonly appTag: string | null;\n  readonly meta: Record<string, unknown>;\n  readonly invariants: readonly string[];\n}\n\n/**\n * One applied migration edge from the per-space ledger journal.\n * Returned by `readLedger` in append (apply) order.\n */\nexport interface LedgerEntryRecord {\n  readonly space: string;\n  readonly migrationName: string;\n  readonly migrationHash: string;\n  readonly from: string | null;\n  readonly to: string;\n  readonly appliedAt: Date;\n  readonly operationCount: number;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,uBACd,aACA,sBACe;CACf,OAAO,eAAe,wBAAwB;AAChD;;;ACTA,MAAa,uBAAuC,0BAIlC,qBAAK;CACnB,KAAK;CACL,WAAW;CACX,OAAO;CACP,UAAU;AACZ,CAAC,CACH;AAEA,MAAM,8BAA8B;AAEpC,SAAgB,SACd,OACA,YAAoB,6BACpB,OACgB;CAChB,OAAO;EACL,WAAW,cAAc,SAAS;EAClC;EACA,GAAI,UAAU,KAAA,IAAY,EAAE,MAAM,IAAI,CAAC;CACzC;AACF;;;;;;;;AC7BA,SAAgB,+BACd,QACS;CACT,MAAM,cAAc,sBAAsB,MAAM;CAChD,MAAM,kBAAkB,OAAO,WAAW;CAC1C,IAAI,oBAAoB,KAAA,GACtB,MAAM,IAAI,+BACR,qBAAqB,YAAY,iCACnC;CAEF,OAAO,gBAAgB;AACzB;;;;;AAMA,SAAgB,qCAEd,QAAqF;CACrF,OAAO,OAAO,WAAW,sBAAsB,MAAM,EAAE,EAAE;AAC3D;;;ACAA,SAAgB,cAAsC,OAAgC;CACpF,OAAO;AACT;AAEA,SAAgB,SAAiC,OAA8B;CAC7E,OAAO;AACT;AASA,SAAgB,YAAoC,OAA8B;CAChF,OAAO;AACT;;;;;;;;;AAiEA,SAAgB,iCACd,OACyC;CACzC,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,IAAI,OAAO;CACjB,IAAI,MAAM,YAAY,MAAM,YAAY,MAAM,WAAW,OAAO;CAChE,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,MAAM,gCAAgC;CAC7E,IAAI,MAAM,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO,WAC5D,OAAO,OAAO,OAAO,KAAgC,CAAC,CAAC,MAAM,gCAAgC;CAE/F,OAAO;AACT;AASA,SAAgB,gBAAgB,OAAwC;CACtE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,OAAQ,MAA6B;CAC3C,IAAI,SAAS,WACX,OAAO,WAAW;CAEpB,IAAI,SAAS,YACX,OAAO,OAAQ,MAAmC,eAAe;CAEnE,OAAO;AACT;AAQA,SAAgB,gCACd,OACwC;CACxC,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,YAAY;CAKlB,IAAI,UAAU,SAAS,aAAa,OAAO;CAC3C,IAAI,OAAO,UAAU,OAAO,UAAU,OAAO;CAC7C,IACE,UAAU,WAAW,KAAA,MACpB,OAAO,UAAU,WAAW,YAC3B,UAAU,WAAW,QACrB,MAAM,QAAQ,UAAU,MAAM,IAEhC,OAAO;CAET,OAAO;AACT"}

package/dist/validate-domain.d.mts

@@ -1,4 +1,4 @@
-import { T as CrossReference, r as ContractWithDomain } from "./domain-envelope-4hyFtJ4_.mjs";
+import { it as CrossReference, r as ContractWithDomain } from "./domain-envelope-DKOnhO5d.mjs";
 
 //#region src/validate-domain.d.ts
 interface DomainModelShape {

package/dist/validate-domain.mjs

@@ -1,5 +1,5 @@
-import { t as ContractValidationError } from "./contract-validation-error-ClZaKqMW.mjs";
-import { t as asNamespaceId } from "./namespace-id-CVpkSFUK.mjs";
+import { t as ContractValidationError } from "./contract-validation-error-BFA66rwU.mjs";
+import { t as asNamespaceId } from "./namespace-id-CUxYd4KL.mjs";
 //#region src/validate-domain.ts
 function indexDomainModels(contract) {
 	const index = /* @__PURE__ */ new Map();
@@ -74,7 +74,10 @@ function validateVariantsAndBases(modelIndex, errors) {
 	}
 }
 function validateRelationTargets(modelIndex, errors) {
-	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) for (const [relName, relation] of Object.entries(model.relations ?? {})) if (!lookupModel(modelIndex, relation.to)) errors.push(`Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`);
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) for (const [relName, relation] of Object.entries(model.relations ?? {})) {
+		if (relation.to.space !== void 0) continue;
+		if (!lookupModel(modelIndex, relation.to)) errors.push(`Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`);
+	}
 }
 function validateDiscriminators(modelIndex, errors) {
 	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {

package/dist/validate-domain.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validate-domain.mjs","names":["f"],"sources":["../src/validate-domain.ts"],"sourcesContent":["import { ContractValidationError } from './contract-validation-error';\nimport type { CrossReference } from './cross-reference';\nimport type { ContractWithDomain } from './domain-envelope';\nimport { asNamespaceId, type NamespaceId } from './namespace-id';\n\nexport interface DomainModelShape {\n  readonly fields: Record<string, unknown>;\n  readonly relations?: Record<string, { readonly to: CrossReference }>;\n  readonly discriminator?: { readonly field: string };\n  readonly variants?: Record<string, unknown>;\n  readonly base?: CrossReference;\n  readonly owner?: string;\n}\n\nexport interface DomainContractShape extends ContractWithDomain {\n  readonly roots: Record<string, CrossReference>;\n}\n\ninterface IndexedModel {\n  readonly namespaceId: NamespaceId;\n  readonly name: string;\n  readonly model: DomainModelShape;\n}\n\ntype ModelIndex = Map<NamespaceId, Map<string, IndexedModel>>;\n\nfunction indexDomainModels(contract: DomainContractShape): ModelIndex {\n  const index: ModelIndex = new Map();\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    let modelsInNamespace = index.get(namespaceId);\n    if (modelsInNamespace === undefined) {\n      modelsInNamespace = new Map();\n      index.set(namespaceId, modelsInNamespace);\n    }\n    for (const [name, model] of Object.entries(namespace.models)) {\n      modelsInNamespace.set(name, { namespaceId, name, model });\n    }\n  }\n  return index;\n}\n\nfunction lookupModel(index: ModelIndex, ref: CrossReference): IndexedModel | undefined {\n  return index.get(ref.namespace)?.get(ref.model);\n}\n\nfunction* iterateIndexedModels(index: ModelIndex): IterableIterator<IndexedModel> {\n  for (const modelsInNamespace of index.values()) {\n    for (const entry of modelsInNamespace.values()) {\n      yield entry;\n    }\n  }\n}\n\nexport function validateContractDomain(contract: DomainContractShape): void {\n  const errors: string[] = [];\n  const modelIndex = indexDomainModels(contract);\n\n  validateRoots(contract, modelIndex, errors);\n  validateVariantsAndBases(modelIndex, errors);\n  validateRelationTargets(modelIndex, errors);\n  validateDiscriminators(modelIndex, errors);\n  validateOwnership(contract, modelIndex, errors);\n  validateValueObjectReferences(contract, errors);\n  validateFieldModifiers(modelIndex, contract, errors);\n\n  if (errors.length > 0) {\n    throw new ContractValidationError(\n      `Contract domain validation failed:\\n- ${errors.join('\\n- ')}`,\n      'domain',\n    );\n  }\n}\n\nfunction validateRoots(\n  contract: DomainContractShape,\n  modelIndex: ModelIndex,\n  errors: string[],\n): void {\n  const seenRootTargets = new Map<NamespaceId, Set<string>>();\n  for (const [rootKey, crossRef] of Object.entries(contract.roots)) {\n    let modelsInNamespace = seenRootTargets.get(crossRef.namespace);\n    if (modelsInNamespace === undefined) {\n      modelsInNamespace = new Set();\n      seenRootTargets.set(crossRef.namespace, modelsInNamespace);\n    }\n    if (modelsInNamespace.has(crossRef.model)) {\n      errors.push(\n        `Duplicate root value: \"${crossRef.namespace}:${crossRef.model}\" is mapped by multiple root keys`,\n      );\n    }\n    modelsInNamespace.add(crossRef.model);\n\n    if (!lookupModel(modelIndex, crossRef)) {\n      errors.push(\n        `Root \"${rootKey}\" references model \"${crossRef.namespace}:${crossRef.model}\" which does not exist in domain.namespaces`,\n      );\n    }\n  }\n}\n\nfunction validateVariantsAndBases(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (model.variants) {\n      for (const variantName of Object.keys(model.variants)) {\n        const variantRef: CrossReference = { namespace: namespaceId, model: variantName };\n        const variantEntry = lookupModel(modelIndex, variantRef);\n        if (!variantEntry) {\n          errors.push(\n            `Model \"${namespaceId}:${modelName}\" lists variant \"${variantName}\" which does not exist at that namespace coordinate`,\n          );\n          continue;\n        }\n        const variantBase = variantEntry.model.base;\n        if (variantBase?.namespace !== namespaceId || variantBase?.model !== modelName) {\n          errors.push(\n            `Variant \"${namespaceId}:${variantName}\" has base \"${variantBase?.namespace ?? '?'}:${variantBase?.model ?? '(none)'}\" but expected \"${namespaceId}:${modelName}\"`,\n          );\n        }\n      }\n    }\n\n    if (model.base) {\n      const baseEntry = lookupModel(modelIndex, model.base);\n      if (!baseEntry) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" has base \"${model.base.namespace}:${model.base.model}\" which does not exist in domain.namespaces`,\n        );\n        continue;\n      }\n      if (!baseEntry.model.variants || !Object.hasOwn(baseEntry.model.variants, modelName)) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" has base \"${model.base.namespace}:${model.base.model}\" which does not list it as a variant`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateRelationTargets(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    for (const [relName, relation] of Object.entries(model.relations ?? {})) {\n      if (!lookupModel(modelIndex, relation.to)) {\n        errors.push(\n          `Relation \"${relName}\" on model \"${namespaceId}:${modelName}\" targets \"${relation.to.namespace}:${relation.to.model}\" which does not exist in domain.namespaces`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateDiscriminators(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (model.discriminator) {\n      if (!model.variants || Object.keys(model.variants).length === 0) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has discriminator but no variants`);\n      }\n      if (!Object.hasOwn(model.fields, model.discriminator.field)) {\n        errors.push(\n          `Discriminator field \"${model.discriminator.field}\" is not a field on model \"${namespaceId}:${modelName}\"`,\n        );\n      }\n    }\n\n    if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) {\n      errors.push(`Model \"${namespaceId}:${modelName}\" has variants but no discriminator`);\n    }\n\n    if (model.base) {\n      if (model.discriminator) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has base and must not have discriminator`);\n      }\n      if (model.variants && Object.keys(model.variants).length > 0) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has base and must not have variants`);\n      }\n    }\n  }\n}\n\nfunction validateOwnership(\n  contract: DomainContractShape,\n  modelIndex: ModelIndex,\n  errors: string[],\n): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (!model.owner) continue;\n\n    if (model.owner === modelName) {\n      errors.push(`Model \"${namespaceId}:${modelName}\" cannot own itself`);\n    }\n\n    const ownerRef: CrossReference = { namespace: namespaceId, model: model.owner };\n    if (!lookupModel(modelIndex, ownerRef)) {\n      errors.push(\n        `Model \"${namespaceId}:${modelName}\" has owner \"${namespaceId}:${model.owner}\" which does not exist in domain.namespaces`,\n      );\n    }\n\n    for (const [rootKey, rootRef] of Object.entries(contract.roots)) {\n      if (rootRef.namespace === namespaceId && rootRef.model === modelName) {\n        errors.push(\n          `Owned model \"${namespaceId}:${modelName}\" must not appear in roots (found as root \"${rootKey}\")`,\n        );\n      }\n    }\n  }\n}\n\ninterface FieldTypeLike {\n  readonly kind?: string;\n  readonly name?: string;\n  readonly members?: readonly FieldTypeLike[];\n}\n\ninterface FieldLike {\n  readonly type?: FieldTypeLike;\n  readonly many?: boolean;\n  readonly dict?: boolean;\n}\n\nfunction validateValueObjectReferences(contract: DomainContractShape, errors: string[]): void {\n  const voNamesByNamespace = new Map<NamespaceId, Set<string>>();\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    voNamesByNamespace.set(namespaceId, new Set(Object.keys(namespace.valueObjects ?? {})));\n  }\n\n  function checkType(\n    type: FieldTypeLike | undefined,\n    location: string,\n    namespaceId: NamespaceId,\n  ): void {\n    if (!type) return;\n    const voNames = voNamesByNamespace.get(namespaceId) ?? new Set<string>();\n    if (type.kind === 'valueObject' && type.name && !voNames.has(type.name)) {\n      errors.push(\n        `${location} references value object \"${namespaceId}:${type.name}\" which does not exist in that namespace's valueObjects`,\n      );\n      return;\n    }\n    if (type.kind === 'union') {\n      for (const member of type.members ?? []) checkType(member, location, namespaceId);\n    }\n  }\n\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    for (const [modelName, model] of Object.entries(namespace.models)) {\n      for (const [fieldName, field] of Object.entries(model.fields)) {\n        const f = field as FieldLike | undefined;\n        checkType(f?.type, `Model \"${namespaceId}:${modelName}\" field \"${fieldName}\"`, namespaceId);\n      }\n    }\n    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {\n      for (const [fieldName, field] of Object.entries(vo.fields)) {\n        const f = field as FieldLike | undefined;\n        checkType(\n          f?.type,\n          `Value object \"${namespaceId}:${voName}\" field \"${fieldName}\"`,\n          namespaceId,\n        );\n      }\n    }\n  }\n}\n\nfunction validateFieldModifiers(\n  modelIndex: ModelIndex,\n  contract: DomainContractShape,\n  errors: string[],\n): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    for (const [fieldName, field] of Object.entries(model.fields)) {\n      const f = field as FieldLike | undefined;\n      if (f?.many && f?.dict) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" field \"${fieldName}\" cannot have both \"many\" and \"dict\" modifiers`,\n        );\n      }\n    }\n  }\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {\n      for (const [fieldName, field] of Object.entries(vo.fields)) {\n        const f = field as FieldLike | undefined;\n        if (f?.many && f?.dict) {\n          errors.push(\n            `Value object \"${namespaceId}:${voName}\" field \"${fieldName}\" cannot have both \"many\" and \"dict\" modifiers`,\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;AA0BA,SAAS,kBAAkB,UAA2C;CACpE,MAAM,wBAAoB,IAAI,IAAI;CAClC,KAAK,MAAM,CAAC,cAAc,cAAc,OAAO,QAAQ,SAAS,OAAO,UAAU,GAAG;EAClF,MAAM,cAAc,cAAc,YAAY;EAC9C,IAAI,oBAAoB,MAAM,IAAI,WAAW;EAC7C,IAAI,sBAAsB,KAAA,GAAW;GACnC,oCAAoB,IAAI,IAAI;GAC5B,MAAM,IAAI,aAAa,iBAAiB;EAC1C;EACA,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,UAAU,MAAM,GACzD,kBAAkB,IAAI,MAAM;GAAE;GAAa;GAAM;EAAM,CAAC;CAE5D;CACA,OAAO;AACT;AAEA,SAAS,YAAY,OAAmB,KAA+C;CACrF,OAAO,MAAM,IAAI,IAAI,SAAS,GAAG,IAAI,IAAI,KAAK;AAChD;AAEA,UAAU,qBAAqB,OAAmD;CAChF,KAAK,MAAM,qBAAqB,MAAM,OAAO,GAC3C,KAAK,MAAM,SAAS,kBAAkB,OAAO,GAC3C,MAAM;AAGZ;AAEA,SAAgB,uBAAuB,UAAqC;CAC1E,MAAM,SAAmB,CAAC;CAC1B,MAAM,aAAa,kBAAkB,QAAQ;CAE7C,cAAc,UAAU,YAAY,MAAM;CAC1C,yBAAyB,YAAY,MAAM;CAC3C,wBAAwB,YAAY,MAAM;CAC1C,uBAAuB,YAAY,MAAM;CACzC,kBAAkB,UAAU,YAAY,MAAM;CAC9C,8BAA8B,UAAU,MAAM;CAC9C,uBAAuB,YAAY,UAAU,MAAM;CAEnD,IAAI,OAAO,SAAS,GAClB,MAAM,IAAI,wBACR,yCAAyC,OAAO,KAAK,MAAM,KAC3D,QACF;AAEJ;AAEA,SAAS,cACP,UACA,YACA,QACM;CACN,MAAM,kCAAkB,IAAI,IAA8B;CAC1D,KAAK,MAAM,CAAC,SAAS,aAAa,OAAO,QAAQ,SAAS,KAAK,GAAG;EAChE,IAAI,oBAAoB,gBAAgB,IAAI,SAAS,SAAS;EAC9D,IAAI,sBAAsB,KAAA,GAAW;GACnC,oCAAoB,IAAI,IAAI;GAC5B,gBAAgB,IAAI,SAAS,WAAW,iBAAiB;EAC3D;EACA,IAAI,kBAAkB,IAAI,SAAS,KAAK,GACtC,OAAO,KACL,0BAA0B,SAAS,UAAU,GAAG,SAAS,MAAM,kCACjE;EAEF,kBAAkB,IAAI,SAAS,KAAK;EAEpC,IAAI,CAAC,YAAY,YAAY,QAAQ,GACnC,OAAO,KACL,SAAS,QAAQ,sBAAsB,SAAS,UAAU,GAAG,SAAS,MAAM,4CAC9E;CAEJ;AACF;AAEA,SAAS,yBAAyB,YAAwB,QAAwB;CAChF,KAAK,MAAM,EAAE,aAAa,MAAM,WAAW,WAAW,qBAAqB,UAAU,GAAG;EACtF,IAAI,MAAM,UACR,KAAK,MAAM,eAAe,OAAO,KAAK,MAAM,QAAQ,GAAG;GAErD,MAAM,eAAe,YAAY,YAAY;IADR,WAAW;IAAa,OAAO;GACd,CAAC;GACvD,IAAI,CAAC,cAAc;IACjB,OAAO,KACL,UAAU,YAAY,GAAG,UAAU,mBAAmB,YAAY,oDACpE;IACA;GACF;GACA,MAAM,cAAc,aAAa,MAAM;GACvC,IAAI,aAAa,cAAc,eAAe,aAAa,UAAU,WACnE,OAAO,KACL,YAAY,YAAY,GAAG,YAAY,cAAc,aAAa,aAAa,IAAI,GAAG,aAAa,SAAS,SAAS,kBAAkB,YAAY,GAAG,UAAU,EAClK;EAEJ;EAGF,IAAI,MAAM,MAAM;GACd,MAAM,YAAY,YAAY,YAAY,MAAM,IAAI;GACpD,IAAI,CAAC,WAAW;IACd,OAAO,KACL,UAAU,YAAY,GAAG,UAAU,cAAc,MAAM,KAAK,UAAU,GAAG,MAAM,KAAK,MAAM,4CAC5F;IACA;GACF;GACA,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,OAAO,OAAO,UAAU,MAAM,UAAU,SAAS,GACjF,OAAO,KACL,UAAU,YAAY,GAAG,UAAU,cAAc,MAAM,KAAK,UAAU,GAAG,MAAM,KAAK,MAAM,sCAC5F;EAEJ;CACF;AACF;AAEA,SAAS,wBAAwB,YAAwB,QAAwB;CAC/E,KAAK,MAAM,EAAE,aAAa,MAAM,WAAW,WAAW,qBAAqB,UAAU,GACnF,KAAK,MAAM,CAAC,SAAS,aAAa,OAAO,QAAQ,MAAM,aAAa,CAAC,CAAC,GACpE,IAAI,CAAC,YAAY,YAAY,SAAS,EAAE,GACtC,OAAO,KACL,aAAa,QAAQ,cAAc,YAAY,GAAG,UAAU,aAAa,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,4CACtH;AAIR;AAEA,SAAS,uBAAuB,YAAwB,QAAwB;CAC9E,KAAK,MAAM,EAAE,aAAa,MAAM,WAAW,WAAW,qBAAqB,UAAU,GAAG;EACtF,IAAI,MAAM,eAAe;GACvB,IAAI,CAAC,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,EAAE,WAAW,GAC5D,OAAO,KAAK,UAAU,YAAY,GAAG,UAAU,oCAAoC;GAErF,IAAI,CAAC,OAAO,OAAO,MAAM,QAAQ,MAAM,cAAc,KAAK,GACxD,OAAO,KACL,wBAAwB,MAAM,cAAc,MAAM,6BAA6B,YAAY,GAAG,UAAU,EAC1G;EAEJ;EAEA,IAAI,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,EAAE,SAAS,KAAK,CAAC,MAAM,eACrE,OAAO,KAAK,UAAU,YAAY,GAAG,UAAU,oCAAoC;EAGrF,IAAI,MAAM,MAAM;GACd,IAAI,MAAM,eACR,OAAO,KAAK,UAAU,YAAY,GAAG,UAAU,2CAA2C;GAE5F,IAAI,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,EAAE,SAAS,GACzD,OAAO,KAAK,UAAU,YAAY,GAAG,UAAU,sCAAsC;EAEzF;CACF;AACF;AAEA,SAAS,kBACP,UACA,YACA,QACM;CACN,KAAK,MAAM,EAAE,aAAa,MAAM,WAAW,WAAW,qBAAqB,UAAU,GAAG;EACtF,IAAI,CAAC,MAAM,OAAO;EAElB,IAAI,MAAM,UAAU,WAClB,OAAO,KAAK,UAAU,YAAY,GAAG,UAAU,oBAAoB;EAIrE,IAAI,CAAC,YAAY,YAAY;GADM,WAAW;GAAa,OAAO,MAAM;EACpC,CAAC,GACnC,OAAO,KACL,UAAU,YAAY,GAAG,UAAU,eAAe,YAAY,GAAG,MAAM,MAAM,4CAC/E;EAGF,KAAK,MAAM,CAAC,SAAS,YAAY,OAAO,QAAQ,SAAS,KAAK,GAC5D,IAAI,QAAQ,cAAc,eAAe,QAAQ,UAAU,WACzD,OAAO,KACL,gBAAgB,YAAY,GAAG,UAAU,6CAA6C,QAAQ,GAChG;CAGN;AACF;AAcA,SAAS,8BAA8B,UAA+B,QAAwB;CAC5F,MAAM,qCAAqB,IAAI,IAA8B;CAC7D,KAAK,MAAM,CAAC,cAAc,cAAc,OAAO,QAAQ,SAAS,OAAO,UAAU,GAAG;EAClF,MAAM,cAAc,cAAc,YAAY;EAC9C,mBAAmB,IAAI,aAAa,IAAI,IAAI,OAAO,KAAK,UAAU,gBAAgB,CAAC,CAAC,CAAC,CAAC;CACxF;CAEA,SAAS,UACP,MACA,UACA,aACM;EACN,IAAI,CAAC,MAAM;EACX,MAAM,UAAU,mBAAmB,IAAI,WAAW,qBAAK,IAAI,IAAY;EACvE,IAAI,KAAK,SAAS,iBAAiB,KAAK,QAAQ,CAAC,QAAQ,IAAI,KAAK,IAAI,GAAG;GACvE,OAAO,KACL,GAAG,SAAS,4BAA4B,YAAY,GAAG,KAAK,KAAK,wDACnE;GACA;EACF;EACA,IAAI,KAAK,SAAS,SAChB,KAAK,MAAM,UAAU,KAAK,WAAW,CAAC,GAAG,UAAU,QAAQ,UAAU,WAAW;CAEpF;CAEA,KAAK,MAAM,CAAC,cAAc,cAAc,OAAO,QAAQ,SAAS,OAAO,UAAU,GAAG;EAClF,MAAM,cAAc,cAAc,YAAY;EAC9C,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,UAAU,MAAM,GAC9D,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,MAAM,GAE1D,UAAUA,OAAG,MAAM,UAAU,YAAY,GAAG,UAAU,WAAW,UAAU,IAAI,WAAW;EAG9F,KAAK,MAAM,CAAC,QAAQ,OAAO,OAAO,QAAQ,UAAU,gBAAgB,CAAC,CAAC,GACpE,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,MAAM,GAEvD,UACEA,OAAG,MACH,iBAAiB,YAAY,GAAG,OAAO,WAAW,UAAU,IAC5D,WACF;CAGN;AACF;AAEA,SAAS,uBACP,YACA,UACA,QACM;CACN,KAAK,MAAM,EAAE,aAAa,MAAM,WAAW,WAAW,qBAAqB,UAAU,GACnF,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,MAAM,GAAG;EAC7D,MAAM,IAAI;EACV,IAAI,GAAG,QAAQ,GAAG,MAChB,OAAO,KACL,UAAU,YAAY,GAAG,UAAU,WAAW,UAAU,+CAC1D;CAEJ;CAEF,KAAK,MAAM,CAAC,cAAc,cAAc,OAAO,QAAQ,SAAS,OAAO,UAAU,GAAG;EAClF,MAAM,cAAc,cAAc,YAAY;EAC9C,KAAK,MAAM,CAAC,QAAQ,OAAO,OAAO,QAAQ,UAAU,gBAAgB,CAAC,CAAC,GACpE,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,MAAM,GAAG;GAC1D,MAAM,IAAI;GACV,IAAI,GAAG,QAAQ,GAAG,MAChB,OAAO,KACL,iBAAiB,YAAY,GAAG,OAAO,WAAW,UAAU,+CAC9D;EAEJ;CAEJ;AACF"}
+{"version":3,"file":"validate-domain.mjs","names":["f"],"sources":["../src/validate-domain.ts"],"sourcesContent":["import { ContractValidationError } from './contract-validation-error';\nimport type { CrossReference } from './cross-reference';\nimport type { ContractWithDomain } from './domain-envelope';\nimport { asNamespaceId, type NamespaceId } from './namespace-id';\n\nexport interface DomainModelShape {\n  readonly fields: Record<string, unknown>;\n  readonly relations?: Record<string, { readonly to: CrossReference }>;\n  readonly discriminator?: { readonly field: string };\n  readonly variants?: Record<string, unknown>;\n  readonly base?: CrossReference;\n  readonly owner?: string;\n}\n\nexport interface DomainContractShape extends ContractWithDomain {\n  readonly roots: Record<string, CrossReference>;\n}\n\ninterface IndexedModel {\n  readonly namespaceId: NamespaceId;\n  readonly name: string;\n  readonly model: DomainModelShape;\n}\n\ntype ModelIndex = Map<NamespaceId, Map<string, IndexedModel>>;\n\nfunction indexDomainModels(contract: DomainContractShape): ModelIndex {\n  const index: ModelIndex = new Map();\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    let modelsInNamespace = index.get(namespaceId);\n    if (modelsInNamespace === undefined) {\n      modelsInNamespace = new Map();\n      index.set(namespaceId, modelsInNamespace);\n    }\n    for (const [name, model] of Object.entries(namespace.models)) {\n      modelsInNamespace.set(name, { namespaceId, name, model });\n    }\n  }\n  return index;\n}\n\nfunction lookupModel(index: ModelIndex, ref: CrossReference): IndexedModel | undefined {\n  return index.get(ref.namespace)?.get(ref.model);\n}\n\nfunction* iterateIndexedModels(index: ModelIndex): IterableIterator<IndexedModel> {\n  for (const modelsInNamespace of index.values()) {\n    for (const entry of modelsInNamespace.values()) {\n      yield entry;\n    }\n  }\n}\n\nexport function validateContractDomain(contract: DomainContractShape): void {\n  const errors: string[] = [];\n  const modelIndex = indexDomainModels(contract);\n\n  validateRoots(contract, modelIndex, errors);\n  validateVariantsAndBases(modelIndex, errors);\n  validateRelationTargets(modelIndex, errors);\n  validateDiscriminators(modelIndex, errors);\n  validateOwnership(contract, modelIndex, errors);\n  validateValueObjectReferences(contract, errors);\n  validateFieldModifiers(modelIndex, contract, errors);\n\n  if (errors.length > 0) {\n    throw new ContractValidationError(\n      `Contract domain validation failed:\\n- ${errors.join('\\n- ')}`,\n      'domain',\n    );\n  }\n}\n\nfunction validateRoots(\n  contract: DomainContractShape,\n  modelIndex: ModelIndex,\n  errors: string[],\n): void {\n  const seenRootTargets = new Map<NamespaceId, Set<string>>();\n  for (const [rootKey, crossRef] of Object.entries(contract.roots)) {\n    let modelsInNamespace = seenRootTargets.get(crossRef.namespace);\n    if (modelsInNamespace === undefined) {\n      modelsInNamespace = new Set();\n      seenRootTargets.set(crossRef.namespace, modelsInNamespace);\n    }\n    if (modelsInNamespace.has(crossRef.model)) {\n      errors.push(\n        `Duplicate root value: \"${crossRef.namespace}:${crossRef.model}\" is mapped by multiple root keys`,\n      );\n    }\n    modelsInNamespace.add(crossRef.model);\n\n    if (!lookupModel(modelIndex, crossRef)) {\n      errors.push(\n        `Root \"${rootKey}\" references model \"${crossRef.namespace}:${crossRef.model}\" which does not exist in domain.namespaces`,\n      );\n    }\n  }\n}\n\nfunction validateVariantsAndBases(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (model.variants) {\n      for (const variantName of Object.keys(model.variants)) {\n        const variantRef: CrossReference = { namespace: namespaceId, model: variantName };\n        const variantEntry = lookupModel(modelIndex, variantRef);\n        if (!variantEntry) {\n          errors.push(\n            `Model \"${namespaceId}:${modelName}\" lists variant \"${variantName}\" which does not exist at that namespace coordinate`,\n          );\n          continue;\n        }\n        const variantBase = variantEntry.model.base;\n        if (variantBase?.namespace !== namespaceId || variantBase?.model !== modelName) {\n          errors.push(\n            `Variant \"${namespaceId}:${variantName}\" has base \"${variantBase?.namespace ?? '?'}:${variantBase?.model ?? '(none)'}\" but expected \"${namespaceId}:${modelName}\"`,\n          );\n        }\n      }\n    }\n\n    if (model.base) {\n      const baseEntry = lookupModel(modelIndex, model.base);\n      if (!baseEntry) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" has base \"${model.base.namespace}:${model.base.model}\" which does not exist in domain.namespaces`,\n        );\n        continue;\n      }\n      if (!baseEntry.model.variants || !Object.hasOwn(baseEntry.model.variants, modelName)) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" has base \"${model.base.namespace}:${model.base.model}\" which does not list it as a variant`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateRelationTargets(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    for (const [relName, relation] of Object.entries(model.relations ?? {})) {\n      // Cross-space relations (relation.to.space is defined) target a model in a\n      // different contract space. The local domain index only contains this\n      // contract's own models, so the target is intentionally absent here.\n      // Existence of the target is verified by the aggregate verifier at\n      // deploy time (after the spaces are composed), not at parse time.\n      if (relation.to.space !== undefined) continue;\n      if (!lookupModel(modelIndex, relation.to)) {\n        errors.push(\n          `Relation \"${relName}\" on model \"${namespaceId}:${modelName}\" targets \"${relation.to.namespace}:${relation.to.model}\" which does not exist in domain.namespaces`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateDiscriminators(modelIndex: ModelIndex, errors: string[]): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (model.discriminator) {\n      if (!model.variants || Object.keys(model.variants).length === 0) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has discriminator but no variants`);\n      }\n      if (!Object.hasOwn(model.fields, model.discriminator.field)) {\n        errors.push(\n          `Discriminator field \"${model.discriminator.field}\" is not a field on model \"${namespaceId}:${modelName}\"`,\n        );\n      }\n    }\n\n    if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) {\n      errors.push(`Model \"${namespaceId}:${modelName}\" has variants but no discriminator`);\n    }\n\n    if (model.base) {\n      if (model.discriminator) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has base and must not have discriminator`);\n      }\n      if (model.variants && Object.keys(model.variants).length > 0) {\n        errors.push(`Model \"${namespaceId}:${modelName}\" has base and must not have variants`);\n      }\n    }\n  }\n}\n\nfunction validateOwnership(\n  contract: DomainContractShape,\n  modelIndex: ModelIndex,\n  errors: string[],\n): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    if (!model.owner) continue;\n\n    if (model.owner === modelName) {\n      errors.push(`Model \"${namespaceId}:${modelName}\" cannot own itself`);\n    }\n\n    const ownerRef: CrossReference = { namespace: namespaceId, model: model.owner };\n    if (!lookupModel(modelIndex, ownerRef)) {\n      errors.push(\n        `Model \"${namespaceId}:${modelName}\" has owner \"${namespaceId}:${model.owner}\" which does not exist in domain.namespaces`,\n      );\n    }\n\n    for (const [rootKey, rootRef] of Object.entries(contract.roots)) {\n      if (rootRef.namespace === namespaceId && rootRef.model === modelName) {\n        errors.push(\n          `Owned model \"${namespaceId}:${modelName}\" must not appear in roots (found as root \"${rootKey}\")`,\n        );\n      }\n    }\n  }\n}\n\ninterface FieldTypeLike {\n  readonly kind?: string;\n  readonly name?: string;\n  readonly members?: readonly FieldTypeLike[];\n}\n\ninterface FieldLike {\n  readonly type?: FieldTypeLike;\n  readonly many?: boolean;\n  readonly dict?: boolean;\n}\n\nfunction validateValueObjectReferences(contract: DomainContractShape, errors: string[]): void {\n  const voNamesByNamespace = new Map<NamespaceId, Set<string>>();\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    voNamesByNamespace.set(namespaceId, new Set(Object.keys(namespace.valueObjects ?? {})));\n  }\n\n  function checkType(\n    type: FieldTypeLike | undefined,\n    location: string,\n    namespaceId: NamespaceId,\n  ): void {\n    if (!type) return;\n    const voNames = voNamesByNamespace.get(namespaceId) ?? new Set<string>();\n    if (type.kind === 'valueObject' && type.name && !voNames.has(type.name)) {\n      errors.push(\n        `${location} references value object \"${namespaceId}:${type.name}\" which does not exist in that namespace's valueObjects`,\n      );\n      return;\n    }\n    if (type.kind === 'union') {\n      for (const member of type.members ?? []) checkType(member, location, namespaceId);\n    }\n  }\n\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    for (const [modelName, model] of Object.entries(namespace.models)) {\n      for (const [fieldName, field] of Object.entries(model.fields)) {\n        const f = field as FieldLike | undefined;\n        checkType(f?.type, `Model \"${namespaceId}:${modelName}\" field \"${fieldName}\"`, namespaceId);\n      }\n    }\n    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {\n      for (const [fieldName, field] of Object.entries(vo.fields)) {\n        const f = field as FieldLike | undefined;\n        checkType(\n          f?.type,\n          `Value object \"${namespaceId}:${voName}\" field \"${fieldName}\"`,\n          namespaceId,\n        );\n      }\n    }\n  }\n}\n\nfunction validateFieldModifiers(\n  modelIndex: ModelIndex,\n  contract: DomainContractShape,\n  errors: string[],\n): void {\n  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {\n    for (const [fieldName, field] of Object.entries(model.fields)) {\n      const f = field as FieldLike | undefined;\n      if (f?.many && f?.dict) {\n        errors.push(\n          `Model \"${namespaceId}:${modelName}\" field \"${fieldName}\" cannot have both \"many\" and \"dict\" modifiers`,\n        );\n      }\n    }\n  }\n  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {\n    const namespaceId = asNamespaceId(namespaceKey);\n    for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) {\n      for (const [fieldName, field] of Object.entries(vo.fields)) {\n        const f = field as FieldLike | undefined;\n        if (f?.many && f?.dict) {\n          errors.push(\n            `Value object \"${namespaceId}:${voName}\" field \"${fieldName}\" cannot have both \"many\" and \"dict\" modifiers`,\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.12.0",
+  "version": "0.13.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/utils": "0.12.0",
+    "@prisma-next/utils": "0.13.0-dev.10",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.12.0",
-    "@prisma-next/tsdown": "0.12.0",
-    "tsdown": "0.22.0",
+    "@prisma-next/tsconfig": "0.13.0-dev.10",
+    "@prisma-next/tsdown": "0.13.0-dev.10",
+    "tsdown": "0.22.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.6"
+    "vitest": "4.1.8"
   },
   "peerDependencies": {
     "typescript": ">=5.9"
@@ -31,9 +31,13 @@
     "schemas"
   ],
   "exports": {
+    "./apply-specifier-default-control-policy": "./dist/apply-specifier-default-control-policy.mjs",
     "./contract-validation-error": "./dist/contract-validation-error.mjs",
+    "./default-namespace": "./dist/default-namespace.mjs",
+    "./enum-accessor": "./dist/enum-accessor.mjs",
     "./hashing": "./dist/hashing.mjs",
     "./hashing-utils": "./dist/hashing-utils.mjs",
+    "./resolve-domain-model": "./dist/resolve-domain-model.mjs",
     "./types": "./dist/types.mjs",
     "./validate-domain": "./dist/validate-domain.mjs",
     "./package.json": "./package.json"

package/src/apply-specifier-default-control-policy.ts

@@ -0,0 +1,12 @@
+import type { Contract } from './contract-types';
+import type { ControlPolicy } from './control-policy';
+
+export function applySpecifierDefaultControlPolicy(
+  contract: Contract,
+  specifierDefault: ControlPolicy | undefined,
+): Contract {
+  if (specifierDefault === undefined || contract.defaultControlPolicy !== undefined) {
+    return contract;
+  }
+  return { ...contract, defaultControlPolicy: specifierDefault };
+}

package/src/canonicalization-storage-sort.ts

@@ -11,10 +11,17 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+// Order by UTF-16 code unit, not locale collation: canonicalization feeds
+// storageHash, which must be byte-identical across hosts, and locale
+// collation (localeCompare/Intl) varies by the engine's ICU build.
+function compareCodeUnits(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
 export function compareByNameProperty(a: unknown, b: unknown): number {
   const nameA = isPlainRecord(a) && typeof a['name'] === 'string' ? a['name'] : '';
   const nameB = isPlainRecord(b) && typeof b['name'] === 'string' ? b['name'] : '';
-  return nameA.localeCompare(nameB);
+  return compareCodeUnits(nameA, nameB);
 }
 
 function sortArrayKeysOnRecord(

package/src/canonicalization.ts

@@ -56,6 +56,12 @@ const DOMAIN_MODEL_STORAGE_PATTERN = [
   '*',
   'storage',
 ] as const satisfies PathPattern;
+const STORAGE_NAMESPACE_ENTRIES_PATTERN = [
+  'storage',
+  'namespaces',
+  '*',
+  'entries',
+] as const satisfies PathPattern;
 
 const TOP_LEVEL_ORDER = [
   'schemaVersion',
@@ -69,6 +75,7 @@ const TOP_LEVEL_ORDER = [
   'execution',
   'capabilities',
   'extensionPacks',
+  'defaultControlPolicy',
   'meta',
 ] as const;
 
@@ -121,9 +128,10 @@ function omitDefaults(
         DOMAIN_MODELS_CONTAINER_PATTERN,
       );
       const isRequiredStorageNamespaces = isArrayEqual(currentPath, ['storage', 'namespaces']);
-      const isStorageNamespaceSlot =
-        currentPath.length === 3 &&
-        isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);
+      const isStorageNamespaceEntries = matchesPathPattern(
+        currentPath,
+        STORAGE_NAMESPACE_ENTRIES_PATTERN,
+      );
       const isRequiredRoots = isArrayEqual(currentPath, ['roots']);
       const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);
       const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);
@@ -146,7 +154,7 @@ function omitDefaults(
         !isDomainNamespaceSlot &&
         !isRequiredDomainModels &&
         !isRequiredStorageNamespaces &&
-        !isStorageNamespaceSlot &&
+        !isStorageNamespaceEntries &&
         !isRequiredRoots &&
         !isRequiredExtensionPacks &&
         !isRequiredCapabilities &&
@@ -255,6 +263,7 @@ export function canonicalizeContractToObject(
     ...ifDefined('execution', serialized['execution']),
     extensionPacks: serialized['extensionPacks'],
     capabilities: serialized['capabilities'],
+    ...ifDefined('defaultControlPolicy', serialized['defaultControlPolicy']),
     meta: serialized['meta'],
   };
   const withDefaultsOmitted = omitDefaults(normalized, [], options.shouldPreserveEmpty) as Record<

package/src/contract-types.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from './control-policy';
 import type { CrossReference } from './cross-reference';
 import type { ApplicationDomain } from './domain-envelope';
 import type { ContractModelBase, ContractValueObject } from './domain-types';
@@ -57,12 +58,15 @@ export interface Contract<
   readonly execution?: ContractExecutionSection;
   readonly profileHash: ProfileHashBase<string>;
   readonly meta: Record<string, unknown>;
+  readonly defaultControlPolicy?: ControlPolicy;
 }
 
-export type ContractModelsMap<TContract extends Contract> =
+/** Model definitions union carried on a {@link Contract}'s `TModels` type parameter. */
+export type ContractModelDefinitions<TContract extends Contract> =
   TContract extends Contract<StorageBase, infer TModels> ? TModels : never;
 
-type ExactlyOneKey<T extends Record<string, unknown>> = keyof T extends infer Only extends keyof T
+type ExactlyOneNamespace<T extends Record<string, unknown>> = keyof T extends infer Only extends
+  keyof T
   ? [keyof T] extends [Only]
     ? Only
     : never
@@ -76,10 +80,10 @@ type NamespaceValueObjectsOf<TNamespace> = TNamespace extends {
     : Record<never, never>
   : Record<never, never>;
 
-/** Value-object map for the contract's sole domain namespace (type-level single-namespace projection). */
-export type ContractValueObjectsMap<TContract extends Contract> =
+/** Value-object map when the contract declares exactly one domain namespace. */
+export type ContractValueObjectDefinitions<TContract extends Contract> =
   NamespaceValueObjectsOf<
-    TContract['domain']['namespaces'][ExactlyOneKey<TContract['domain']['namespaces']>]
+    TContract['domain']['namespaces'][ExactlyOneNamespace<TContract['domain']['namespaces']>]
   > extends infer Projected
     ? Projected extends Record<string, ContractValueObject>
       ? Projected

package/src/control-policy.ts

@@ -0,0 +1,25 @@
+/**
+ * Governance posture for a storage-plane node or for the contract as a whole.
+ *
+ * - `managed`  — Prisma Next owns the full lifecycle (DDL, migrations, verification).
+ * - `tolerated` — node was found in the database but is not schema-managed; Prisma Next
+ *   leaves it untouched while tracking its existence.
+ * - `external` — node is owned by an external system; Prisma Next never emits DDL for it.
+ * - `observed` — read-only access; Prisma Next does not write to or migrate the node.
+ */
+export type ControlPolicy = 'managed' | 'tolerated' | 'external' | 'observed';
+
+/**
+ * Resolves the effective control policy for a storage-plane node.
+ *
+ * Precedence: node-level value → contract default → `'managed'`.
+ *
+ * Both parameters are optional raw values so this function stays node-type-agnostic
+ * and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
+ */
+export function effectiveControlPolicy(
+  nodeControl: ControlPolicy | undefined,
+  defaultControlPolicy: ControlPolicy | undefined,
+): ControlPolicy {
+  return nodeControl ?? defaultControlPolicy ?? 'managed';
+}

package/src/cross-reference.ts

@@ -5,16 +5,23 @@ import { asNamespaceId, type NamespaceId } from './namespace-id';
 export interface CrossReference {
   readonly namespace: NamespaceId;
   readonly model: string;
+  /**
+   * Contract-space identity for cross-space relations. When present, the
+   * referenced model lives in a different contract space. Absent for local
+   * (same-space) relations.
+   */
+  readonly space?: string;
 }
 
-export const CrossReferenceSchema = blindCast<
+export const CrossReferenceSchema = /* @__PURE__ */ blindCast<
   Type<CrossReference>,
   'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'
 >(
-  type({
+  /* @__PURE__ */ type({
     '+': 'reject',
     namespace: 'string',
     model: 'string',
+    'space?': 'string',
   }),
 );
 
@@ -23,6 +30,11 @@ const DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';
 export function crossRef(
   model: string,
   namespace: string = DEFAULT_CROSS_REF_NAMESPACE,
+  space?: string,
 ): CrossReference {
-  return { namespace: asNamespaceId(namespace), model };
+  return {
+    namespace: asNamespaceId(namespace),
+    model,
+    ...(space !== undefined ? { space } : {}),
+  };
 }

package/src/default-namespace.ts

@@ -0,0 +1,36 @@
+import { DomainNamespaceResolutionError } from './contract-validation-error';
+
+/**
+ * Reserved sentinel domain namespace id for the late-bound application-domain
+ * slot — the namespace a model lands in when it is authored without an explicit
+ * namespace. This is target-agnostic: targets that allow un-namespaced
+ * authoring (e.g. Mongo, SQLite) declare this id as their default on the target
+ * descriptor; the framework names the sentinel, never a target. Mirrors
+ * storage's `UNBOUND_NAMESPACE_ID` on the domain plane.
+ */
+export const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;
+
+/**
+ * Resolve the single domain namespace of a single-namespace contract.
+ *
+ * Bare-name access (`db.User`) reads "the contract's one namespace". Every
+ * contract in scope today declares exactly one domain namespace, so this is
+ * exact — there is nothing to infer. A contract that declares more than one
+ * namespace is ambiguous for a bare name, so rather than silently pick one this
+ * throws; cross-namespace selection is made explicit (TML-2550).
+ */
+export function soleDomainNamespaceId(domain: {
+  readonly namespaces: Readonly<Record<string, unknown>>;
+}): string {
+  const [soleNamespaceId, ...rest] = Object.keys(domain.namespaces);
+  if (soleNamespaceId === undefined) {
+    throw new DomainNamespaceResolutionError('domain has no namespaces');
+  }
+  if (rest.length > 0) {
+    const all = [soleNamespaceId, ...rest];
+    throw new DomainNamespaceResolutionError(
+      `bare-name resolution requires exactly one domain namespace, found ${all.length} (${all.join(', ')}); select a namespace explicitly`,
+    );
+  }
+  return soleNamespaceId;
+}

package/src/domain-envelope.ts

@@ -1,7 +1,6 @@
-import { DomainNamespaceResolutionError } from './contract-validation-error';
-import type { ContractModelBase, ContractValueObject } from './domain-types';
+import type { ContractEnum, ContractModelBase, ContractValueObject } from './domain-types';
 
-export const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;
+export { UNBOUND_DOMAIN_NAMESPACE_ID } from './default-namespace';
 
 /**
  * One namespace's application-domain entities — models and optional value
@@ -12,6 +11,7 @@ export interface ApplicationDomainNamespace<
 > {
   readonly models: TModels;
   readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
 }
 
 /**
@@ -27,61 +27,3 @@ export interface ApplicationDomain<
 export type ContractWithDomain = {
   readonly domain: ApplicationDomain;
 };
-
-export function resolveSingleDomainNamespaceId(
-  domain: ApplicationDomain,
-  namespaceId?: string,
-): string {
-  if (namespaceId !== undefined) {
-    if (!Object.hasOwn(domain.namespaces, namespaceId)) {
-      throw new DomainNamespaceResolutionError(
-        `domain namespace "${namespaceId}" is not present on the contract`,
-      );
-    }
-    return namespaceId;
-  }
-
-  const namespaceIds = Object.keys(domain.namespaces);
-  if (namespaceIds.length === 0) {
-    throw new DomainNamespaceResolutionError('domain has no namespaces');
-  }
-  if (namespaceIds.length > 1) {
-    throw new DomainNamespaceResolutionError(
-      `expected exactly one domain namespace, found ${namespaceIds.length} (${namespaceIds.join(', ')})`,
-    );
-  }
-  const [soleNamespaceId] = namespaceIds;
-  if (soleNamespaceId === undefined) {
-    throw new DomainNamespaceResolutionError('domain has no namespaces');
-  }
-  return soleNamespaceId;
-}
-
-// Transitional single-namespace projection; pending runtime-qualification slice.
-export function contractModels<TModels extends Record<string, ContractModelBase>>(
-  contract: { readonly domain: ApplicationDomain<TModels> },
-  namespaceId?: string,
-): TModels {
-  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-  const domainNamespace = contract.domain.namespaces[resolved];
-  if (domainNamespace === undefined) {
-    throw new DomainNamespaceResolutionError(
-      `domain namespace "${resolved}" is not present on the contract`,
-    );
-  }
-  return domainNamespace.models;
-}
-
-export function contractValueObjects<TModels extends Record<string, ContractModelBase>>(
-  contract: { readonly domain: ApplicationDomain<TModels> },
-  namespaceId?: string,
-): Record<string, ContractValueObject> | undefined {
-  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-  const domainNamespace = contract.domain.namespaces[resolved];
-  if (domainNamespace === undefined) {
-    throw new DomainNamespaceResolutionError(
-      `domain namespace "${resolved}" is not present on the contract`,
-    );
-  }
-  return domainNamespace.valueObjects;
-}