@prisma-next/contract 0.11.0 → 0.12.0

package/dist/hashing.mjs

@@ -1,2 +1,176 @@
-import { a as canonicalizeContractToObject, i as canonicalizeContract, n as computeProfileHash, r as computeStorageHash, t as computeExecutionHash } from "./hashing-rZiqFOlc.mjs";
+import { n as matchesPathPattern } from "./canonicalization-path-match-b2jFuEso.mjs";
+import { isArrayEqual } from "@prisma-next/utils/array-equal";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { createHash } from "node:crypto";
+//#region src/canonicalization.ts
+const DOMAIN_NAMESPACE_SLOT_PATTERN = [
+	"domain",
+	"namespaces",
+	"*"
+];
+const DOMAIN_MODELS_CONTAINER_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models"
+];
+const DOMAIN_MODEL_RELATIONS_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models",
+	"*",
+	"relations"
+];
+const DOMAIN_MODEL_STORAGE_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models",
+	"*",
+	"storage"
+];
+const TOP_LEVEL_ORDER = [
+	"schemaVersion",
+	"canonicalVersion",
+	"targetFamily",
+	"target",
+	"profileHash",
+	"roots",
+	"domain",
+	"storage",
+	"execution",
+	"capabilities",
+	"extensionPacks",
+	"meta"
+];
+function isDefaultValue(value) {
+	if (value === false) return true;
+	if (value === null) return false;
+	if (Array.isArray(value) && value.length === 0) return true;
+	if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
+	return false;
+}
+function omitDefaults(obj, path, shouldPreserveEmpty) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const currentPath = [...path, key];
+		if (key === "_generated") continue;
+		if (key === "generated" && value === false) continue;
+		if ((key === "onDelete" || key === "onUpdate") && value === "noAction") continue;
+		if (isDefaultValue(value)) {
+			const isRequiredDomainNamespaces = isArrayEqual(currentPath, ["domain", "namespaces"]);
+			const isDomainNamespaceSlot = matchesPathPattern(currentPath, DOMAIN_NAMESPACE_SLOT_PATTERN);
+			const isRequiredDomainModels = matchesPathPattern(currentPath, DOMAIN_MODELS_CONTAINER_PATTERN);
+			const isRequiredStorageNamespaces = isArrayEqual(currentPath, ["storage", "namespaces"]);
+			const isStorageNamespaceSlot = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[1]], ["storage", "namespaces"]);
+			const isRequiredRoots = isArrayEqual(currentPath, ["roots"]);
+			const isRequiredExtensionPacks = isArrayEqual(currentPath, ["extensionPacks"]);
+			const isRequiredCapabilities = isArrayEqual(currentPath, ["capabilities"]);
+			const isRequiredMeta = isArrayEqual(currentPath, ["meta"]);
+			const isRequiredExecutionDefaults = isArrayEqual(currentPath, [
+				"execution",
+				"mutations",
+				"defaults"
+			]);
+			const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === "extensionPacks";
+			const isModelRelations = matchesPathPattern(currentPath, DOMAIN_MODEL_RELATIONS_PATTERN);
+			const isModelStorage = matchesPathPattern(currentPath, DOMAIN_MODEL_STORAGE_PATTERN);
+			const isNullableField = key === "nullable";
+			const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
+			if (!isRequiredDomainNamespaces && !isDomainNamespaceSlot && !isRequiredDomainModels && !isRequiredStorageNamespaces && !isStorageNamespaceSlot && !isRequiredRoots && !isRequiredExtensionPacks && !isRequiredCapabilities && !isRequiredMeta && !isRequiredExecutionDefaults && !isExtensionNamespace && !isModelRelations && !isModelStorage && !isNullableField && !isFamilyPreserved) continue;
+		}
+		result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
+	}
+	return result;
+}
+function sortObjectKeys(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => sortObjectKeys(item));
+	const sorted = {};
+	const keys = Object.keys(obj).sort();
+	for (const key of keys) sorted[key] = sortObjectKeys(obj[key]);
+	return sorted;
+}
+function orderTopLevel(obj) {
+	const ordered = {};
+	const remaining = new Set(Object.keys(obj));
+	for (const key of TOP_LEVEL_ORDER) if (remaining.has(key)) {
+		ordered[key] = obj[key];
+		remaining.delete(key);
+	}
+	for (const key of Array.from(remaining).sort()) ordered[key] = obj[key];
+	return ordered;
+}
+/**
+* Object-form variant of {@link canonicalizeContract}. Exported because the
+* emitter writes the canonical contract through a separate JSON-stringify
+* pass and consumes the structured object directly.
+*/
+function canonicalizeContractToObject(contract, options) {
+	const serialized = options.serializeContract(contract);
+	const withDefaultsOmitted = omitDefaults({
+		...ifDefined("schemaVersion", options.schemaVersion),
+		targetFamily: serialized["targetFamily"],
+		target: serialized["target"],
+		profileHash: serialized["profileHash"],
+		roots: serialized["roots"],
+		domain: serialized["domain"],
+		storage: serialized["storage"],
+		...ifDefined("execution", serialized["execution"]),
+		extensionPacks: serialized["extensionPacks"],
+		capabilities: serialized["capabilities"],
+		meta: serialized["meta"]
+	}, [], options.shouldPreserveEmpty);
+	return orderTopLevel(sortObjectKeys(options.sortStorage ? {
+		...withDefaultsOmitted,
+		storage: options.sortStorage(withDefaultsOmitted["storage"])
+	} : withDefaultsOmitted));
+}
+function canonicalizeContract(contract, options) {
+	return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);
+}
+//#endregion
+//#region src/hashing.ts
+const SCHEMA_VERSION = "1";
+function sha256(content) {
+	const hash = createHash("sha256");
+	hash.update(content);
+	return `sha256:${hash.digest("hex")}`;
+}
+function hashContract(section) {
+	const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
+	return canonicalizeContract({
+		targetFamily: sectionData["targetFamily"],
+		target: sectionData["target"],
+		roots: {},
+		domain: { namespaces: {} },
+		storage: sectionData["storage"] ?? {},
+		execution: sectionData["execution"],
+		extensionPacks: {},
+		capabilities: sectionData["capabilities"] ?? {},
+		meta: {},
+		profileHash: "",
+		...sectionData
+	}, {
+		schemaVersion: SCHEMA_VERSION,
+		serializeContract: (c) => JSON.parse(JSON.stringify(c)),
+		...ifDefined("shouldPreserveEmpty", shouldPreserveEmpty),
+		...ifDefined("sortStorage", sortStorage)
+	});
+}
+function computeStorageHash(args) {
+	return sha256(hashContract(args));
+}
+function computeExecutionHash(args) {
+	return sha256(hashContract(args));
+}
+function computeProfileHash(args) {
+	return sha256(hashContract(args));
+}
+//#endregion
 export { canonicalizeContract, canonicalizeContractToObject, computeExecutionHash, computeProfileHash, computeStorageHash };
+
+//# sourceMappingURL=hashing.mjs.map

package/dist/hashing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.mjs","names":[],"sources":["../src/canonicalization.ts","../src/hashing.ts"],"sourcesContent":["import { isArrayEqual } from '@prisma-next/utils/array-equal';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { matchesPathPattern, type PathPattern } from './canonicalization-path-match';\nimport type { Contract } from './contract-types';\n\n/**\n * Per-target contract serializer hook. The framework canonicalizer uses\n * this to convert an in-memory contract (which may carry class-instance\n * IR nodes whose runtime-only fields must not appear in the on-disk\n * envelope) into a plain JsonObject before applying the family-agnostic\n * canonical-key ordering / default-omission / sort steps. Targets whose\n * contract is JSON-clean by construction return the contract unchanged.\n */\nexport type SerializeContract = (contract: Contract) => JsonObject;\n\n/**\n * Family-contributed predicate for the default-omission walk. Called when\n * a value at `path` is a default (empty object/array or `false`); if this\n * returns `true` the value is kept rather than stripped.\n *\n * The framework only calls the predicate inside the `isDefaultValue` branch,\n * so there is no need to guard against non-default values.\n */\nexport type PreserveEmptyPredicate = (path: readonly string[]) => boolean;\n\n/**\n * Family-contributed storage sort. Applied to the serialized `storage`\n * subtree after the default-omission walk; the result replaces the\n * `storage` field before the final key sort. Use to establish a\n * deterministic order for storage arrays (indexes, uniques) that the\n * family-agnostic `sortObjectKeys` pass cannot handle.\n */\nexport type StorageSort = (storage: unknown) => unknown;\n\nconst DOMAIN_NAMESPACE_SLOT_PATTERN = ['domain', 'namespaces', '*'] as const satisfies PathPattern;\nconst DOMAIN_MODELS_CONTAINER_PATTERN = [\n  'domain',\n  'namespaces',\n  '*',\n  'models',\n] as const satisfies PathPattern;\nconst DOMAIN_MODEL_RELATIONS_PATTERN = [\n  'domain',\n  'namespaces',\n  '*',\n  'models',\n  '*',\n  'relations',\n] as const satisfies PathPattern;\nconst DOMAIN_MODEL_STORAGE_PATTERN = [\n  'domain',\n  'namespaces',\n  '*',\n  'models',\n  '*',\n  'storage',\n] as const satisfies PathPattern;\n\nconst TOP_LEVEL_ORDER = [\n  'schemaVersion',\n  'canonicalVersion',\n  'targetFamily',\n  'target',\n  'profileHash',\n  'roots',\n  'domain',\n  'storage',\n  'execution',\n  'capabilities',\n  'extensionPacks',\n  'meta',\n] as const;\n\nfunction isDefaultValue(value: unknown): boolean {\n  if (value === false) return true;\n  if (value === null) return false;\n  if (Array.isArray(value) && value.length === 0) return true;\n  if (typeof value === 'object' && value !== null) {\n    const keys = Object.keys(value);\n    return keys.length === 0;\n  }\n  return false;\n}\n\nfunction omitDefaults(\n  obj: unknown,\n  path: readonly string[],\n  shouldPreserveEmpty: PreserveEmptyPredicate | undefined,\n): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));\n  }\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    const currentPath = [...path, key];\n\n    if (key === '_generated') {\n      continue;\n    }\n\n    if (key === 'generated' && value === false) {\n      continue;\n    }\n\n    if ((key === 'onDelete' || key === 'onUpdate') && value === 'noAction') {\n      continue;\n    }\n\n    if (isDefaultValue(value)) {\n      const isRequiredDomainNamespaces = isArrayEqual(currentPath, ['domain', 'namespaces']);\n      const isDomainNamespaceSlot = matchesPathPattern(currentPath, DOMAIN_NAMESPACE_SLOT_PATTERN);\n      const isRequiredDomainModels = matchesPathPattern(\n        currentPath,\n        DOMAIN_MODELS_CONTAINER_PATTERN,\n      );\n      const isRequiredStorageNamespaces = isArrayEqual(currentPath, ['storage', 'namespaces']);\n      const isStorageNamespaceSlot =\n        currentPath.length === 3 &&\n        isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);\n      const isRequiredRoots = isArrayEqual(currentPath, ['roots']);\n      const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);\n      const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);\n      const isRequiredMeta = isArrayEqual(currentPath, ['meta']);\n      const isRequiredExecutionDefaults = isArrayEqual(currentPath, [\n        'execution',\n        'mutations',\n        'defaults',\n      ]);\n      const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === 'extensionPacks';\n      const isModelRelations = matchesPathPattern(currentPath, DOMAIN_MODEL_RELATIONS_PATTERN);\n      const isModelStorage = matchesPathPattern(currentPath, DOMAIN_MODEL_STORAGE_PATTERN);\n\n      const isNullableField = key === 'nullable';\n\n      const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;\n\n      if (\n        !isRequiredDomainNamespaces &&\n        !isDomainNamespaceSlot &&\n        !isRequiredDomainModels &&\n        !isRequiredStorageNamespaces &&\n        !isStorageNamespaceSlot &&\n        !isRequiredRoots &&\n        !isRequiredExtensionPacks &&\n        !isRequiredCapabilities &&\n        !isRequiredMeta &&\n        !isRequiredExecutionDefaults &&\n        !isExtensionNamespace &&\n        !isModelRelations &&\n        !isModelStorage &&\n        !isNullableField &&\n        !isFamilyPreserved\n      ) {\n        continue;\n      }\n    }\n\n    result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);\n  }\n\n  return result;\n}\n\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sorted: Record<string, unknown> = {};\n  const keys = Object.keys(obj).sort();\n  for (const key of keys) {\n    sorted[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n  }\n\n  return sorted;\n}\n\nexport function orderTopLevel(obj: Record<string, unknown>): Record<string, unknown> {\n  const ordered: Record<string, unknown> = {};\n  const remaining = new Set(Object.keys(obj));\n\n  for (const key of TOP_LEVEL_ORDER) {\n    if (remaining.has(key)) {\n      ordered[key] = obj[key];\n      remaining.delete(key);\n    }\n  }\n\n  for (const key of Array.from(remaining).sort()) {\n    ordered[key] = obj[key];\n  }\n\n  return ordered;\n}\n\nexport interface CanonicalizeContractOptions {\n  readonly schemaVersion?: string;\n  /**\n   * Per-target hook that converts the in-memory contract (which may\n   * carry class-instance IR nodes) into a plain JsonObject before the\n   * family-agnostic canonicalization steps run.\n   *\n   * Routing through the hook is what lets each target decide which\n   * fields appear in the on-disk envelope; runtime-only class API\n   * fields stay invisible to the canonicalization walk by virtue of\n   * the per-target serializer not putting them in the JSON shape.\n   */\n  readonly serializeContract: SerializeContract;\n  /**\n   * Family-contributed preserve-empty predicate. When the walk encounters a\n   * default value (empty object/array or `false`) at `path`, calling this\n   * with the full path allows the family to veto the omission. If absent,\n   * only the framework's family-agnostic required-slot rules apply.\n   */\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  /**\n   * Family-contributed storage sort. Applied to the serialized `storage`\n   * subtree after the default-omission walk, before the final key sort.\n   * SQL family uses this to impose a deterministic order on `indexes` and\n   * `uniques` arrays within each namespace table. Families that require no\n   * special storage ordering omit this hook.\n   */\n  readonly sortStorage?: StorageSort;\n}\n\n/**\n * Object-form variant of {@link canonicalizeContract}. Exported because the\n * emitter writes the canonical contract through a separate JSON-stringify\n * pass and consumes the structured object directly.\n */\nexport function canonicalizeContractToObject(\n  contract: Contract,\n  options: CanonicalizeContractOptions,\n): Record<string, unknown> {\n  const serialized = options.serializeContract(contract);\n  const normalized: Record<string, unknown> = {\n    ...ifDefined('schemaVersion', options.schemaVersion),\n    targetFamily: serialized['targetFamily'],\n    target: serialized['target'],\n    profileHash: serialized['profileHash'],\n    roots: serialized['roots'],\n    domain: serialized['domain'],\n    storage: serialized['storage'],\n    ...ifDefined('execution', serialized['execution']),\n    extensionPacks: serialized['extensionPacks'],\n    capabilities: serialized['capabilities'],\n    meta: serialized['meta'],\n  };\n  const withDefaultsOmitted = omitDefaults(normalized, [], options.shouldPreserveEmpty) as Record<\n    string,\n    unknown\n  >;\n  const withSortedStorage = options.sortStorage\n    ? { ...withDefaultsOmitted, storage: options.sortStorage(withDefaultsOmitted['storage']) }\n    : withDefaultsOmitted;\n  const withSortedKeys = sortObjectKeys(withSortedStorage) as Record<string, unknown>;\n  return orderTopLevel(withSortedKeys);\n}\n\nexport function canonicalizeContract(\n  contract: Contract,\n  options: CanonicalizeContractOptions,\n): string {\n  return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);\n}\n","import { createHash } from 'node:crypto';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport {\n  canonicalizeContract,\n  type PreserveEmptyPredicate,\n  type StorageSort,\n} from './canonicalization';\nimport type { Contract } from './contract-types';\nimport type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';\n\nconst SCHEMA_VERSION = '1';\n\nfunction sha256(content: string): string {\n  const hash = createHash('sha256');\n  hash.update(content);\n  return `sha256:${hash.digest('hex')}`;\n}\n\ntype HashContractSection = Record<string, unknown> & {\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  readonly sortStorage?: StorageSort;\n};\n\nfunction hashContract(section: HashContractSection): string {\n  const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;\n  // Blind cast: the synthesised object is a hash-only stand-in\n  // — never returned to callers, never executed as a Contract.\n  // `canonicalizeContract` only walks the storage / execution /\n  // capabilities slices, all of which are populated above, so the\n  // missing precise Contract typing on the other slots is\n  // immaterial for the hash result.\n  const contract = {\n    targetFamily: sectionData['targetFamily'],\n    target: sectionData['target'],\n    roots: {},\n    domain: { namespaces: {} },\n    storage: sectionData['storage'] ?? {},\n    execution: sectionData['execution'],\n    extensionPacks: {},\n    capabilities: sectionData['capabilities'] ?? {},\n    meta: {},\n    profileHash: '',\n    ...sectionData,\n  } as unknown as Contract;\n  return canonicalizeContract(contract, {\n    schemaVersion: SCHEMA_VERSION,\n    serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,\n    ...ifDefined('shouldPreserveEmpty', shouldPreserveEmpty),\n    ...ifDefined('sortStorage', sortStorage),\n  });\n}\n\nexport type ComputeStorageHashArgs = {\n  target: string;\n  targetFamily: string;\n  storage: Record<string, unknown>;\n  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;\n  readonly sortStorage?: StorageSort;\n};\n\nexport function computeStorageHash(args: ComputeStorageHashArgs): StorageHashBase<string> {\n  return sha256(hashContract(args)) as StorageHashBase<string>;\n}\n\nexport function computeExecutionHash(args: {\n  target: string;\n  targetFamily: string;\n  execution: Record<string, unknown>;\n}): ExecutionHashBase<string> {\n  return sha256(hashContract(args)) as ExecutionHashBase<string>;\n}\n\nexport function computeProfileHash(args: {\n  target: string;\n  targetFamily: string;\n  capabilities: Record<string, Record<string, boolean>>;\n}): ProfileHashBase<string> {\n  return sha256(hashContract(args)) as ProfileHashBase<string>;\n}\n"],"mappings":"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"}

package/dist/namespace-id-CVpkSFUK.mjs

@@ -0,0 +1,9 @@
+import { blindCast } from "@prisma-next/utils/casts";
+//#region src/namespace-id.ts
+function asNamespaceId(value) {
+	return blindCast(value);
+}
+//#endregion
+export { asNamespaceId as t };
+
+//# sourceMappingURL=namespace-id-CVpkSFUK.mjs.map

package/dist/namespace-id-CVpkSFUK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-id-CVpkSFUK.mjs","names":[],"sources":["../src/namespace-id.ts"],"sourcesContent":["import { blindCast } from '@prisma-next/utils/casts';\n\nexport type NamespaceId = string & { readonly __brand: 'NamespaceId' };\n\nexport function asNamespaceId(value: string): NamespaceId {\n  return blindCast<\n    NamespaceId,\n    'NamespaceId is a compile-time-only brand on string; this factory is the sole assertion site'\n  >(value);\n}\n"],"mappings":";;AAIA,SAAgB,cAAc,OAA4B;CACxD,OAAO,UAGL,KAAK;AACT"}

package/dist/types.d.mts

@@ -1,2 +1,4 @@
-import { A as isExecutionMutationDefaultValue, B as ContractRelationOn, C as Source, D as executionHash, E as coreHash, F as ContractFieldType, G as ReferenceRelationKeys, H as ContractVariantEntry, I as ContractModel, J as ValueObjectFieldType, K as ScalarFieldType, L as ContractModelBase, M as ContractDiscriminator, N as ContractEmbedRelation, O as isColumnDefault, P as ContractField, R as ContractReferenceRelation, S as ProfileHashBase, T as StorageHashBase, U as EmbedRelationKeys, V as ContractValueObject, W as ModelStorageBase, _ as FieldType, a as ColumnDefault, b as JsonValue, c as ContractMarkerRecord, d as ExecutionHashBase, f as ExecutionMutationDefault, g as Expr, h as ExecutionSection, i as Brand, j as profileHash, k as isColumnDefaultLiteralInputValue, l as DocCollection, m as ExecutionMutationDefaultValue, n as ContractExecutionSection, o as ColumnDefaultLiteralInputValue, p as ExecutionMutationDefaultPhases, q as UnionFieldType, r as $, s as ColumnDefaultLiteralValue, t as Contract, u as DocIndex, v as GeneratedValueSpec, w as StorageBase, x as PlanMeta, y as JsonPrimitive, z as ContractRelation } from "./contract-types-Bt2uyqs3.mjs";
-export { type $, type Brand, type ColumnDefault, type ColumnDefaultLiteralInputValue, type ColumnDefaultLiteralValue, type Contract, type ContractDiscriminator, type ContractEmbedRelation, type ContractExecutionSection, type ContractField, type ContractFieldType, type ContractMarkerRecord, type ContractModel, type ContractModelBase, type ContractReferenceRelation, type ContractRelation, type ContractRelationOn, type ContractValueObject, type ContractVariantEntry, type DocCollection, type DocIndex, type EmbedRelationKeys, type ExecutionHashBase, type ExecutionMutationDefault, type ExecutionMutationDefaultPhases, type ExecutionMutationDefaultValue, type ExecutionSection, type Expr, type FieldType, type GeneratedValueSpec, type JsonPrimitive, type JsonValue, type ModelStorageBase, type PlanMeta, type ProfileHashBase, type ReferenceRelationKeys, type ScalarFieldType, type Source, type StorageBase, type StorageHashBase, type UnionFieldType, type ValueObjectFieldType, coreHash, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash };
+import { r as DomainNamespaceResolutionError } from "./contract-validation-error-T5LH4DW-.mjs";
+import { C as UnionFieldType, D as crossRef, E as CrossReferenceSchema, O as NamespaceId, S as ScalarFieldType, T as CrossReference, _ as ContractValueObject, a as contractModels, b as ModelStorageBase, c as ContractDiscriminator, d as ContractFieldType, f as ContractModel, g as ContractRelationOn, h as ContractRelation, i as UNBOUND_DOMAIN_NAMESPACE_ID, k as asNamespaceId, l as ContractEmbedRelation, m as ContractReferenceRelation, n as ApplicationDomainNamespace, o as contractValueObjects, p as ContractModelBase, r as ContractWithDomain, s as resolveSingleDomainNamespaceId, t as ApplicationDomain, u as ContractField, v as ContractVariantEntry, w as ValueObjectFieldType, x as ReferenceRelationKeys, y as EmbedRelationKeys } from "./domain-envelope-4hyFtJ4_.mjs";
+import { A as coreHash, C as PlanMeta, D as StorageEntitySlot, E as StorageBase, F as profileHash, M as isColumnDefault, N as isColumnDefaultLiteralInputValue, O as StorageHashBase, P as isExecutionMutationDefaultValue, S as JsonValue, T as Source, _ as ExecutionSection, a as $, b as GeneratedValueSpec, c as ColumnDefaultLiteralInputValue, d as DocCollection, f as DocIndex, g as ExecutionMutationDefaultValue, h as ExecutionMutationDefaultPhases, i as ContractValueObjectsMap, j as executionHash, k as StorageNamespace, l as ColumnDefaultLiteralValue, m as ExecutionMutationDefault, n as ContractExecutionSection, o as Brand, p as ExecutionHashBase, r as ContractModelsMap, s as ColumnDefault, t as Contract, u as ContractMarkerRecord, v as Expr, w as ProfileHashBase, x as JsonPrimitive, y as FieldType } from "./contract-types-xgwKtd7y.mjs";
+export { type $, type ApplicationDomain, type ApplicationDomainNamespace, type Brand, type ColumnDefault, type ColumnDefaultLiteralInputValue, type ColumnDefaultLiteralValue, type Contract, type ContractDiscriminator, type ContractEmbedRelation, type ContractExecutionSection, type ContractField, type ContractFieldType, type ContractMarkerRecord, type ContractModel, type ContractModelBase, type ContractModelsMap, type ContractReferenceRelation, type ContractRelation, type ContractRelationOn, type ContractValueObject, type ContractValueObjectsMap, type ContractVariantEntry, type ContractWithDomain, type CrossReference, CrossReferenceSchema, type DocCollection, type DocIndex, DomainNamespaceResolutionError, type EmbedRelationKeys, type ExecutionHashBase, type ExecutionMutationDefault, type ExecutionMutationDefaultPhases, type ExecutionMutationDefaultValue, type ExecutionSection, type Expr, type FieldType, type GeneratedValueSpec, type JsonPrimitive, type JsonValue, type ModelStorageBase, type NamespaceId, type PlanMeta, type ProfileHashBase, type ReferenceRelationKeys, type ScalarFieldType, type Source, type StorageBase, type StorageEntitySlot, type StorageHashBase, type StorageNamespace, UNBOUND_DOMAIN_NAMESPACE_ID, type UnionFieldType, type ValueObjectFieldType, asNamespaceId, contractModels, contractValueObjects, coreHash, crossRef, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash, resolveSingleDomainNamespaceId };

package/dist/types.mjs

@@ -1,2 +1,91 @@
-import { a as isExecutionMutationDefaultValue, i as isColumnDefaultLiteralInputValue, n as executionHash, o as profileHash, r as isColumnDefault, t as coreHash } from "./types-CVGwkRLa.mjs";
-export { coreHash, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash };
+import { n as DomainNamespaceResolutionError } from "./contract-validation-error-ClZaKqMW.mjs";
+import { t as asNamespaceId } from "./namespace-id-CVpkSFUK.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
+import { type } from "arktype";
+//#region src/cross-reference.ts
+const CrossReferenceSchema = blindCast(type({
+	"+": "reject",
+	namespace: "string",
+	model: "string"
+}));
+const DEFAULT_CROSS_REF_NAMESPACE = "__unbound__";
+function crossRef(model, namespace = DEFAULT_CROSS_REF_NAMESPACE) {
+	return {
+		namespace: asNamespaceId(namespace),
+		model
+	};
+}
+//#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`);
+	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;
+}
+//#endregion
+//#region src/types.ts
+function executionHash(value) {
+	return value;
+}
+function coreHash(value) {
+	return value;
+}
+function profileHash(value) {
+	return value;
+}
+/**
+* Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers
+* resolve template values from caller-supplied args (typed `unknown` at the
+* boundary) and need to validate before constructing a `ColumnDefault`.
+* Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`
+* instances. Rejects functions, class instances (other than `Date`),
+* `undefined`, `bigint`, `symbol`, and arrays/objects containing those.
+*/
+function isColumnDefaultLiteralInputValue(value) {
+	if (value === null) return true;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return true;
+	if (value instanceof Date) return true;
+	if (Array.isArray(value)) return value.every(isColumnDefaultLiteralInputValue);
+	if (t === "object" && Object.getPrototypeOf(value) === Object.prototype) return Object.values(value).every(isColumnDefaultLiteralInputValue);
+	return false;
+}
+function isColumnDefault(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const kind = value.kind;
+	if (kind === "literal") return "value" in value;
+	if (kind === "function") return typeof value.expression === "string";
+	return false;
+}
+function isExecutionMutationDefaultValue(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (candidate.kind !== "generator") return false;
+	if (typeof candidate.id !== "string") return false;
+	if (candidate.params !== void 0 && (typeof candidate.params !== "object" || candidate.params === null || Array.isArray(candidate.params))) return false;
+	return true;
+}
+//#endregion
+export { CrossReferenceSchema, DomainNamespaceResolutionError, UNBOUND_DOMAIN_NAMESPACE_ID, asNamespaceId, contractModels, contractValueObjects, coreHash, crossRef, executionHash, isColumnDefault, isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue, profileHash, resolveSingleDomainNamespaceId };
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +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"}

package/dist/validate-domain.d.mts

@@ -1,22 +1,20 @@
+import { T as CrossReference, r as ContractWithDomain } from "./domain-envelope-4hyFtJ4_.mjs";
+
 //#region src/validate-domain.d.ts
 interface DomainModelShape {
   readonly fields: Record<string, unknown>;
   readonly relations?: Record<string, {
-    readonly to: string;
+    readonly to: CrossReference;
   }>;
   readonly discriminator?: {
     readonly field: string;
   };
   readonly variants?: Record<string, unknown>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
-interface DomainContractShape {
-  readonly roots: Record<string, string>;
-  readonly models: Record<string, DomainModelShape>;
-  readonly valueObjects?: Record<string, {
-    readonly fields: Record<string, unknown>;
-  }>;
+interface DomainContractShape extends ContractWithDomain {
+  readonly roots: Record<string, CrossReference>;
 }
 declare function validateContractDomain(contract: DomainContractShape): void;
 //#endregion

package/dist/validate-domain.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-domain.d.mts","names":[],"sources":["../src/validate-domain.ts"],"mappings":";UAEiB,gBAAA;EAAA,SACN,MAAA,EAAQ,MAAA;EAAA,SACR,SAAA,GAAY,MAAA;IAAA,SAA0B,EAAA;EAAA;EAAA,SACtC,aAAA;IAAA,SAA2B,KAAA;EAAA;EAAA,SAC3B,QAAA,GAAW,MAAA;EAAA,SACX,IAAA;EAAA,SACA,KAAA;AAAA;AAAA,UAGM,mBAAA;EAAA,SACN,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,MAAA,SAAe,gBAAA;EAAA,SACvB,YAAA,GAAe,MAAA;IAAA,SAA0B,MAAA,EAAQ,MAAA;EAAA;AAAA;AAAA,iBAG5C,sBAAA,CAAuB,QAAA,EAAU,mBAAA"}
+{"version":3,"file":"validate-domain.d.mts","names":[],"sources":["../src/validate-domain.ts"],"mappings":";;;UAKiB,gBAAA;EAAA,SACN,MAAA,EAAQ,MAAA;EAAA,SACR,SAAA,GAAY,MAAA;IAAA,SAA0B,EAAA,EAAI,cAAA;EAAA;EAAA,SAC1C,aAAA;IAAA,SAA2B,KAAA;EAAA;EAAA,SAC3B,QAAA,GAAW,MAAA;EAAA,SACX,IAAA,GAAO,cAAA;EAAA,SACP,KAAA;AAAA;AAAA,UAGM,mBAAA,SAA4B,kBAAA;EAAA,SAClC,KAAA,EAAO,MAAA,SAAe,cAAA;AAAA;AAAA,iBAuCjB,sBAAA,CAAuB,QAA6B,EAAnB,mBAAmB"}

package/dist/validate-domain.mjs

@@ -1,95 +1,138 @@
-import { t as ContractValidationError } from "./contract-validation-error-Dp2vHZt5.mjs";
+import { t as ContractValidationError } from "./contract-validation-error-ClZaKqMW.mjs";
+import { t as asNamespaceId } from "./namespace-id-CVpkSFUK.mjs";
 //#region src/validate-domain.ts
+function indexDomainModels(contract) {
+	const index = /* @__PURE__ */ new Map();
+	for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+		const namespaceId = asNamespaceId(namespaceKey);
+		let modelsInNamespace = index.get(namespaceId);
+		if (modelsInNamespace === void 0) {
+			modelsInNamespace = /* @__PURE__ */ new Map();
+			index.set(namespaceId, modelsInNamespace);
+		}
+		for (const [name, model] of Object.entries(namespace.models)) modelsInNamespace.set(name, {
+			namespaceId,
+			name,
+			model
+		});
+	}
+	return index;
+}
+function lookupModel(index, ref) {
+	return index.get(ref.namespace)?.get(ref.model);
+}
+function* iterateIndexedModels(index) {
+	for (const modelsInNamespace of index.values()) for (const entry of modelsInNamespace.values()) yield entry;
+}
 function validateContractDomain(contract) {
 	const errors = [];
-	const modelNames = new Set(Object.keys(contract.models));
-	validateRoots(contract, modelNames, errors);
-	validateVariantsAndBases(contract, modelNames, errors);
-	validateRelationTargets(contract, modelNames, errors);
-	validateDiscriminators(contract, errors);
-	validateOwnership(contract, modelNames, errors);
+	const modelIndex = indexDomainModels(contract);
+	validateRoots(contract, modelIndex, errors);
+	validateVariantsAndBases(modelIndex, errors);
+	validateRelationTargets(modelIndex, errors);
+	validateDiscriminators(modelIndex, errors);
+	validateOwnership(contract, modelIndex, errors);
 	validateValueObjectReferences(contract, errors);
-	validateFieldModifiers(contract, errors);
+	validateFieldModifiers(modelIndex, contract, errors);
 	if (errors.length > 0) throw new ContractValidationError(`Contract domain validation failed:\n- ${errors.join("\n- ")}`, "domain");
 }
-function validateRoots(contract, modelNames, errors) {
-	const seenValues = /* @__PURE__ */ new Set();
-	for (const [rootKey, modelName] of Object.entries(contract.roots)) {
-		if (seenValues.has(modelName)) errors.push(`Duplicate root value: "${modelName}" is mapped by multiple root keys`);
-		seenValues.add(modelName);
-		if (!modelNames.has(modelName)) errors.push(`Root "${rootKey}" references model "${modelName}" which does not exist in models`);
+function validateRoots(contract, modelIndex, errors) {
+	const seenRootTargets = /* @__PURE__ */ new Map();
+	for (const [rootKey, crossRef] of Object.entries(contract.roots)) {
+		let modelsInNamespace = seenRootTargets.get(crossRef.namespace);
+		if (modelsInNamespace === void 0) {
+			modelsInNamespace = /* @__PURE__ */ new Set();
+			seenRootTargets.set(crossRef.namespace, modelsInNamespace);
+		}
+		if (modelsInNamespace.has(crossRef.model)) errors.push(`Duplicate root value: "${crossRef.namespace}:${crossRef.model}" is mapped by multiple root keys`);
+		modelsInNamespace.add(crossRef.model);
+		if (!lookupModel(modelIndex, crossRef)) errors.push(`Root "${rootKey}" references model "${crossRef.namespace}:${crossRef.model}" which does not exist in domain.namespaces`);
 	}
 }
-function validateVariantsAndBases(contract, modelNames, errors) {
-	const models = new Map(Object.entries(contract.models));
-	for (const [modelName, model] of models) {
+function validateVariantsAndBases(modelIndex, errors) {
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
 		if (model.variants) for (const variantName of Object.keys(model.variants)) {
-			if (!modelNames.has(variantName)) {
-				errors.push(`Model "${modelName}" lists variant "${variantName}" which does not exist in models`);
+			const variantEntry = lookupModel(modelIndex, {
+				namespace: namespaceId,
+				model: variantName
+			});
+			if (!variantEntry) {
+				errors.push(`Model "${namespaceId}:${modelName}" lists variant "${variantName}" which does not exist at that namespace coordinate`);
 				continue;
 			}
-			const variantModel = models.get(variantName);
-			if (!variantModel) continue;
-			if (variantModel.base !== modelName) errors.push(`Variant "${variantName}" has base "${variantModel.base ?? "(none)"}" but expected "${modelName}"`);
+			const variantBase = variantEntry.model.base;
+			if (variantBase?.namespace !== namespaceId || variantBase?.model !== modelName) errors.push(`Variant "${namespaceId}:${variantName}" has base "${variantBase?.namespace ?? "?"}:${variantBase?.model ?? "(none)"}" but expected "${namespaceId}:${modelName}"`);
 		}
 		if (model.base) {
-			if (!modelNames.has(model.base)) {
-				errors.push(`Model "${modelName}" has base "${model.base}" which does not exist in models`);
+			const baseEntry = lookupModel(modelIndex, model.base);
+			if (!baseEntry) {
+				errors.push(`Model "${namespaceId}:${modelName}" has base "${model.base.namespace}:${model.base.model}" which does not exist in domain.namespaces`);
 				continue;
 			}
-			const baseModel = models.get(model.base);
-			if (!baseModel) continue;
-			if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) errors.push(`Model "${modelName}" has base "${model.base}" which does not list it as a variant`);
+			if (!baseEntry.model.variants || !Object.hasOwn(baseEntry.model.variants, modelName)) errors.push(`Model "${namespaceId}:${modelName}" has base "${model.base.namespace}:${model.base.model}" which does not list it as a variant`);
 		}
 	}
 }
-function validateRelationTargets(contract, modelNames, errors) {
-	for (const [modelName, model] of Object.entries(contract.models)) for (const [relName, relation] of Object.entries(model.relations ?? {})) if (!modelNames.has(relation.to)) errors.push(`Relation "${relName}" on model "${modelName}" targets "${relation.to}" which does not exist in models`);
+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`);
 }
-function validateDiscriminators(contract, errors) {
-	for (const [modelName, model] of Object.entries(contract.models)) {
+function validateDiscriminators(modelIndex, errors) {
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
 		if (model.discriminator) {
-			if (!model.variants || Object.keys(model.variants).length === 0) errors.push(`Model "${modelName}" has discriminator but no variants`);
-			if (!Object.hasOwn(model.fields, model.discriminator.field)) errors.push(`Discriminator field "${model.discriminator.field}" is not a field on model "${modelName}"`);
+			if (!model.variants || Object.keys(model.variants).length === 0) errors.push(`Model "${namespaceId}:${modelName}" has discriminator but no variants`);
+			if (!Object.hasOwn(model.fields, model.discriminator.field)) errors.push(`Discriminator field "${model.discriminator.field}" is not a field on model "${namespaceId}:${modelName}"`);
 		}
-		if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) errors.push(`Model "${modelName}" has variants but no discriminator`);
+		if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) errors.push(`Model "${namespaceId}:${modelName}" has variants but no discriminator`);
 		if (model.base) {
-			if (model.discriminator) errors.push(`Model "${modelName}" has base and must not have discriminator`);
-			if (model.variants && Object.keys(model.variants).length > 0) errors.push(`Model "${modelName}" has base and must not have variants`);
+			if (model.discriminator) errors.push(`Model "${namespaceId}:${modelName}" has base and must not have discriminator`);
+			if (model.variants && Object.keys(model.variants).length > 0) errors.push(`Model "${namespaceId}:${modelName}" has base and must not have variants`);
 		}
 	}
 }
-function validateOwnership(contract, modelNames, errors) {
-	for (const [modelName, model] of Object.entries(contract.models)) {
+function validateOwnership(contract, modelIndex, errors) {
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
 		if (!model.owner) continue;
-		if (model.owner === modelName) errors.push(`Model "${modelName}" cannot own itself`);
-		if (!modelNames.has(model.owner)) errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
-		for (const [rootKey, rootModel] of Object.entries(contract.roots)) if (rootModel === modelName) errors.push(`Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`);
+		if (model.owner === modelName) errors.push(`Model "${namespaceId}:${modelName}" cannot own itself`);
+		if (!lookupModel(modelIndex, {
+			namespace: namespaceId,
+			model: model.owner
+		})) errors.push(`Model "${namespaceId}:${modelName}" has owner "${namespaceId}:${model.owner}" which does not exist in domain.namespaces`);
+		for (const [rootKey, rootRef] of Object.entries(contract.roots)) if (rootRef.namespace === namespaceId && rootRef.model === modelName) errors.push(`Owned model "${namespaceId}:${modelName}" must not appear in roots (found as root "${rootKey}")`);
 	}
 }
-function forEachContractField(contract, callback) {
-	for (const [modelName, model] of Object.entries(contract.models)) for (const [fieldName, field] of Object.entries(model.fields)) callback(field, `Model "${modelName}" field "${fieldName}"`);
-	for (const [voName, vo] of Object.entries(contract.valueObjects ?? {})) for (const [fieldName, field] of Object.entries(vo.fields)) callback(field, `Value object "${voName}" field "${fieldName}"`);
-}
 function validateValueObjectReferences(contract, errors) {
-	const voNames = new Set(Object.keys(contract.valueObjects ?? {}));
-	function checkType(type, location) {
+	const voNamesByNamespace = /* @__PURE__ */ new Map();
+	for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+		const namespaceId = asNamespaceId(namespaceKey);
+		voNamesByNamespace.set(namespaceId, new Set(Object.keys(namespace.valueObjects ?? {})));
+	}
+	function checkType(type, location, namespaceId) {
 		if (!type) return;
+		const voNames = voNamesByNamespace.get(namespaceId) ?? /* @__PURE__ */ new Set();
 		if (type.kind === "valueObject" && type.name && !voNames.has(type.name)) {
-			errors.push(`${location} references value object "${type.name}" which does not exist in valueObjects`);
+			errors.push(`${location} references value object "${namespaceId}:${type.name}" which does not exist in that namespace's valueObjects`);
 			return;
 		}
-		if (type.kind === "union") for (const member of type.members ?? []) checkType(member, location);
+		if (type.kind === "union") for (const member of type.members ?? []) checkType(member, location, namespaceId);
+	}
+	for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+		const namespaceId = asNamespaceId(namespaceKey);
+		for (const [modelName, model] of Object.entries(namespace.models)) for (const [fieldName, field] of Object.entries(model.fields)) checkType(field?.type, `Model "${namespaceId}:${modelName}" field "${fieldName}"`, namespaceId);
+		for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) for (const [fieldName, field] of Object.entries(vo.fields)) checkType(field?.type, `Value object "${namespaceId}:${voName}" field "${fieldName}"`, namespaceId);
 	}
-	forEachContractField(contract, (field, location) => {
-		checkType(field?.type, location);
-	});
 }
-function validateFieldModifiers(contract, errors) {
-	forEachContractField(contract, (field, location) => {
+function validateFieldModifiers(modelIndex, contract, errors) {
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) for (const [fieldName, field] of Object.entries(model.fields)) {
 		const f = field;
-		if (f?.many && f?.dict) errors.push(`${location} cannot have both "many" and "dict" modifiers`);
-	});
+		if (f?.many && f?.dict) errors.push(`Model "${namespaceId}:${modelName}" field "${fieldName}" cannot have both "many" and "dict" modifiers`);
+	}
+	for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+		const namespaceId = asNamespaceId(namespaceKey);
+		for (const [voName, vo] of Object.entries(namespace.valueObjects ?? {})) for (const [fieldName, field] of Object.entries(vo.fields)) {
+			const f = field;
+			if (f?.many && f?.dict) errors.push(`Value object "${namespaceId}:${voName}" field "${fieldName}" cannot have both "many" and "dict" modifiers`);
+		}
+	}
 }
 //#endregion
 export { validateContractDomain };