@prisma-next/contract 0.11.0 → 0.12.0

package/src/validate-domain.ts

@@ -1,31 +1,68 @@
 import { ContractValidationError } from './contract-validation-error';
+import type { CrossReference } from './cross-reference';
+import type { ContractWithDomain } from './domain-envelope';
+import { asNamespaceId, type NamespaceId } from './namespace-id';
 
 export interface DomainModelShape {
   readonly fields: Record<string, unknown>;
-  readonly relations?: Record<string, { readonly to: string }>;
+  readonly relations?: Record<string, { readonly to: CrossReference }>;
   readonly discriminator?: { readonly field: string };
   readonly variants?: Record<string, unknown>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
 
-export interface DomainContractShape {
-  readonly roots: Record<string, string>;
-  readonly models: Record<string, DomainModelShape>;
-  readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;
+export interface DomainContractShape extends ContractWithDomain {
+  readonly roots: Record<string, CrossReference>;
+}
+
+interface IndexedModel {
+  readonly namespaceId: NamespaceId;
+  readonly name: string;
+  readonly model: DomainModelShape;
+}
+
+type ModelIndex = Map<NamespaceId, Map<string, IndexedModel>>;
+
+function indexDomainModels(contract: DomainContractShape): ModelIndex {
+  const index: ModelIndex = new Map();
+  for (const [namespaceKey, namespace] of Object.entries(contract.domain.namespaces)) {
+    const namespaceId = asNamespaceId(namespaceKey);
+    let modelsInNamespace = index.get(namespaceId);
+    if (modelsInNamespace === undefined) {
+      modelsInNamespace = 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: ModelIndex, ref: CrossReference): IndexedModel | undefined {
+  return index.get(ref.namespace)?.get(ref.model);
+}
+
+function* iterateIndexedModels(index: ModelIndex): IterableIterator<IndexedModel> {
+  for (const modelsInNamespace of index.values()) {
+    for (const entry of modelsInNamespace.values()) {
+      yield entry;
+    }
+  }
 }
 
 export function validateContractDomain(contract: DomainContractShape): void {
   const errors: string[] = [];
-  const modelNames = new Set(Object.keys(contract.models));
+  const modelIndex = indexDomainModels(contract);
 
-  validateRoots(contract, modelNames, errors);
-  validateVariantsAndBases(contract, modelNames, errors);
-  validateRelationTargets(contract, modelNames, errors);
-  validateDiscriminators(contract, errors);
-  validateOwnership(contract, modelNames, errors);
+  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(
@@ -37,105 +74,104 @@ export function validateContractDomain(contract: DomainContractShape): void {
 
 function validateRoots(
   contract: DomainContractShape,
-  modelNames: Set<string>,
+  modelIndex: ModelIndex,
   errors: string[],
 ): void {
-  const seenValues = new Set<string>();
-  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`);
+  const seenRootTargets = new Map<NamespaceId, Set<string>>();
+  for (const [rootKey, crossRef] of Object.entries(contract.roots)) {
+    let modelsInNamespace = seenRootTargets.get(crossRef.namespace);
+    if (modelsInNamespace === undefined) {
+      modelsInNamespace = new Set();
+      seenRootTargets.set(crossRef.namespace, modelsInNamespace);
     }
-    seenValues.add(modelName);
+    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 (!modelNames.has(modelName)) {
+    if (!lookupModel(modelIndex, crossRef)) {
       errors.push(
-        `Root "${rootKey}" references model "${modelName}" which does not exist in models`,
+        `Root "${rootKey}" references model "${crossRef.namespace}:${crossRef.model}" which does not exist in domain.namespaces`,
       );
     }
   }
 }
 
-function validateVariantsAndBases(
-  contract: DomainContractShape,
-  modelNames: Set<string>,
-  errors: string[],
-): void {
-  const models = new Map(Object.entries(contract.models));
-
-  for (const [modelName, model] of models) {
+function validateVariantsAndBases(modelIndex: ModelIndex, errors: string[]): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     if (model.variants) {
       for (const variantName of Object.keys(model.variants)) {
-        if (!modelNames.has(variantName)) {
+        const variantRef: CrossReference = { namespace: namespaceId, model: variantName };
+        const variantEntry = lookupModel(modelIndex, variantRef);
+        if (!variantEntry) {
           errors.push(
-            `Model "${modelName}" lists variant "${variantName}" which does not exist in models`,
+            `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) {
+        const variantBase = variantEntry.model.base;
+        if (variantBase?.namespace !== namespaceId || variantBase?.model !== modelName) {
           errors.push(
-            `Variant "${variantName}" has base "${variantModel.base ?? '(none)'}" but expected "${modelName}"`,
+            `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)) {
+      if (!baseEntry.model.variants || !Object.hasOwn(baseEntry.model.variants, modelName)) {
         errors.push(
-          `Model "${modelName}" has base "${model.base}" which does not list it as a variant`,
+          `Model "${namespaceId}:${modelName}" has base "${model.base.namespace}:${model.base.model}" which does not list it as a variant`,
         );
       }
     }
   }
 }
 
-function validateRelationTargets(
-  contract: DomainContractShape,
-  modelNames: Set<string>,
-  errors: string[],
-): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+function validateRelationTargets(modelIndex: ModelIndex, errors: string[]): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     for (const [relName, relation] of Object.entries(model.relations ?? {})) {
-      if (!modelNames.has(relation.to)) {
+      if (!lookupModel(modelIndex, relation.to)) {
         errors.push(
-          `Relation "${relName}" on model "${modelName}" targets "${relation.to}" which does not exist in models`,
+          `Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`,
         );
       }
     }
   }
 }
 
-function validateDiscriminators(contract: DomainContractShape, errors: string[]): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+function validateDiscriminators(modelIndex: ModelIndex, errors: string[]): void {
+  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`);
+        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 "${modelName}"`,
+          `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`);
+      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`);
+        errors.push(`Model "${namespaceId}:${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`);
+        errors.push(`Model "${namespaceId}:${modelName}" has base and must not have variants`);
       }
     }
   }
@@ -143,24 +179,27 @@ function validateDiscriminators(contract: DomainContractShape, errors: string[])
 
 function validateOwnership(
   contract: DomainContractShape,
-  modelNames: Set<string>,
+  modelIndex: ModelIndex,
   errors: string[],
 ): void {
-  for (const [modelName, model] of Object.entries(contract.models)) {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     if (!model.owner) continue;
 
     if (model.owner === modelName) {
-      errors.push(`Model "${modelName}" cannot own itself`);
+      errors.push(`Model "${namespaceId}:${modelName}" cannot own itself`);
     }
 
-    if (!modelNames.has(model.owner)) {
-      errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
+    const ownerRef: CrossReference = { namespace: namespaceId, model: model.owner };
+    if (!lookupModel(modelIndex, ownerRef)) {
+      errors.push(
+        `Model "${namespaceId}:${modelName}" has owner "${namespaceId}:${model.owner}" which does not exist in domain.namespaces`,
+      );
     }
 
-    for (const [rootKey, rootModel] of Object.entries(contract.roots)) {
-      if (rootModel === modelName) {
+    for (const [rootKey, rootRef] of Object.entries(contract.roots)) {
+      if (rootRef.namespace === namespaceId && rootRef.model === modelName) {
         errors.push(
-          `Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`,
+          `Owned model "${namespaceId}:${modelName}" must not appear in roots (found as root "${rootKey}")`,
         );
       }
     }
@@ -179,49 +218,78 @@ interface FieldLike {
   readonly dict?: boolean;
 }
 
-function forEachContractField(
-  contract: DomainContractShape,
-  callback: (field: unknown, location: string) => void,
-): void {
-  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: DomainContractShape, errors: string[]): void {
-  const voNames = new Set(Object.keys(contract.valueObjects ?? {}));
+  const voNamesByNamespace = new Map<NamespaceId, Set<string>>();
+  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: FieldTypeLike | undefined, location: string): void {
+  function checkType(
+    type: FieldTypeLike | undefined,
+    location: string,
+    namespaceId: NamespaceId,
+  ): void {
     if (!type) return;
+    const voNames = voNamesByNamespace.get(namespaceId) ?? new Set<string>();
     if (type.kind === 'valueObject' && type.name && !voNames.has(type.name)) {
       errors.push(
-        `${location} references value object "${type.name}" which does not exist in valueObjects`,
+        `${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);
+      for (const member of type.members ?? []) checkType(member, location, namespaceId);
     }
   }
 
-  forEachContractField(contract, (field, location) => {
-    const f = field as FieldLike | undefined;
-    checkType(f?.type, location);
-  });
+  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)) {
+        const f = field as FieldLike | undefined;
+        checkType(f?.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)) {
+        const f = field as FieldLike | undefined;
+        checkType(
+          f?.type,
+          `Value object "${namespaceId}:${voName}" field "${fieldName}"`,
+          namespaceId,
+        );
+      }
+    }
+  }
 }
 
-function validateFieldModifiers(contract: DomainContractShape, errors: string[]): void {
-  forEachContractField(contract, (field, location) => {
-    const f = field as FieldLike | undefined;
-    if (f?.many && f?.dict) {
-      errors.push(`${location} cannot have both "many" and "dict" modifiers`);
+function validateFieldModifiers(
+  modelIndex: ModelIndex,
+  contract: DomainContractShape,
+  errors: string[],
+): void {
+  for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      const f = field as FieldLike | undefined;
+      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 as FieldLike | undefined;
+        if (f?.many && f?.dict) {
+          errors.push(
+            `Value object "${namespaceId}:${voName}" field "${fieldName}" cannot have both "many" and "dict" modifiers`,
+          );
+        }
+      }
+    }
+  }
 }

package/dist/contract-types-Bt2uyqs3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-types-Bt2uyqs3.d.mts","names":[],"sources":["../src/domain-types.ts","../src/types.ts","../src/contract-types.ts"],"mappings":"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"}

package/dist/contract-validation-error-Dp2vHZt5.mjs

@@ -1,14 +0,0 @@
-//#region src/contract-validation-error.ts
-var ContractValidationError = class extends Error {
-	code = "CONTRACT.VALIDATION_FAILED";
-	phase;
-	constructor(message, phase) {
-		super(message);
-		this.name = "ContractValidationError";
-		this.phase = phase;
-	}
-};
-//#endregion
-export { ContractValidationError as t };
-
-//# sourceMappingURL=contract-validation-error-Dp2vHZt5.mjs.map

package/dist/contract-validation-error-Dp2vHZt5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-validation-error-Dp2vHZt5.mjs","names":[],"sources":["../src/contract-validation-error.ts"],"sourcesContent":["export type ContractValidationPhase = 'structural' | 'domain' | 'storage';\n\nexport class ContractValidationError extends Error {\n  readonly code = 'CONTRACT.VALIDATION_FAILED';\n  readonly phase: ContractValidationPhase;\n\n  constructor(message: string, phase: ContractValidationPhase) {\n    super(message);\n    this.name = 'ContractValidationError';\n    this.phase = phase;\n  }\n}\n"],"mappings":";AAEA,IAAa,0BAAb,cAA6C,MAAM;CACjD,OAAgB;CAChB;CAEA,YAAY,SAAiB,OAAgC;EAC3D,MAAM,QAAQ;EACd,KAAK,OAAO;EACZ,KAAK,QAAQ"}

package/dist/contract-validation-error.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-validation-error.d.mts","names":[],"sources":["../src/contract-validation-error.ts"],"mappings":";KAAY,uBAAA;AAAA,cAEC,uBAAA,SAAgC,KAAA;EAAA,SAClC,IAAA;EAAA,SACA,KAAA,EAAO,uBAAA;cAEJ,OAAA,UAAiB,KAAA,EAAO,uBAAA;AAAA"}

package/dist/hashing-rZiqFOlc.mjs

@@ -1,204 +0,0 @@
-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 TOP_LEVEL_ORDER = [
-	"schemaVersion",
-	"canonicalVersion",
-	"targetFamily",
-	"target",
-	"profileHash",
-	"roots",
-	"models",
-	"valueObjects",
-	"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) {
-	if (obj === null || typeof obj !== "object") return obj;
-	if (Array.isArray(obj)) return obj.map((item) => omitDefaults(item, path));
-	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 isRequiredModels = isArrayEqual(currentPath, ["models"]);
-			const isRequiredNamespaces = isArrayEqual(currentPath, ["storage", "namespaces"]);
-			const isNamespaceSlot = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[1]], ["storage", "namespaces"]);
-			const isRequiredNamespaceTables = currentPath.length === 4 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables";
-			const isNamespaceTableEntry = currentPath.length === 5 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables";
-			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 = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[2]], ["models", "relations"]);
-			const isModelStorage = currentPath.length === 3 && isArrayEqual([currentPath[0], currentPath[2]], ["models", "storage"]);
-			const isNamespaceTableUniques = currentPath.length === 6 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables" && currentPath[5] === "uniques";
-			const isNamespaceTableIndexes = currentPath.length === 6 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables" && currentPath[5] === "indexes";
-			const isNamespaceTableForeignKeys = currentPath.length === 6 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables" && currentPath[5] === "foreignKeys";
-			const isStorageTypeTypeParams = currentPath.length === 4 && currentPath[0] === "storage" && currentPath[1] === "types" && key === "typeParams";
-			const isFkBooleanField = currentPath.length === 7 && currentPath[0] === "storage" && currentPath[1] === "namespaces" && currentPath[3] === "tables" && currentPath[5] === "foreignKeys" && (key === "constraint" || key === "index");
-			if (!isRequiredModels && !isRequiredNamespaces && !isNamespaceSlot && !isRequiredNamespaceTables && !isNamespaceTableEntry && !isRequiredRoots && !isRequiredExtensionPacks && !isRequiredCapabilities && !isRequiredMeta && !isRequiredExecutionDefaults && !isExtensionNamespace && !isModelRelations && !isModelStorage && !isNamespaceTableUniques && !isNamespaceTableIndexes && !isNamespaceTableForeignKeys && !isFkBooleanField && !(key === "nullable") && !isStorageTypeTypeParams) continue;
-		}
-		result[key] = omitDefaults(value, currentPath);
-	}
-	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 sortTableArrays(tableObj) {
-	const sortedTable = { ...tableObj };
-	if (Array.isArray(tableObj.indexes)) sortedTable.indexes = [...tableObj.indexes].sort((a, b) => {
-		const nameA = a?.name || "";
-		const nameB = b?.name || "";
-		return nameA.localeCompare(nameB);
-	});
-	if (Array.isArray(tableObj.uniques)) sortedTable.uniques = [...tableObj.uniques].sort((a, b) => {
-		const nameA = a?.name || "";
-		const nameB = b?.name || "";
-		return nameA.localeCompare(nameB);
-	});
-	return sortedTable;
-}
-function sortIndexesAndUniques(storage) {
-	if (!storage || typeof storage !== "object") return storage;
-	const storageObj = storage;
-	if (!storageObj.namespaces || typeof storageObj.namespaces !== "object") return storage;
-	const namespaces = storageObj.namespaces;
-	const result = {
-		...storageObj,
-		namespaces: {}
-	};
-	const resultNamespaces = result.namespaces;
-	for (const nsId of Object.keys(namespaces)) {
-		const ns = namespaces[nsId];
-		if (!ns || typeof ns !== "object") {
-			resultNamespaces[nsId] = ns;
-			continue;
-		}
-		const nsObj = ns;
-		if (!nsObj.tables || typeof nsObj.tables !== "object") {
-			resultNamespaces[nsId] = ns;
-			continue;
-		}
-		const sortedTables = {};
-		const sortedTableNames = Object.keys(nsObj.tables).sort();
-		for (const tableName of sortedTableNames) {
-			const table = nsObj.tables[tableName];
-			if (!table || typeof table !== "object") {
-				sortedTables[tableName] = table;
-				continue;
-			}
-			sortedTables[tableName] = sortTableArrays(table);
-		}
-		resultNamespaces[nsId] = {
-			...nsObj,
-			tables: sortedTables
-		};
-	}
-	return result;
-}
-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"],
-		models: serialized["models"],
-		...ifDefined("valueObjects", serialized["valueObjects"]),
-		storage: serialized["storage"],
-		...ifDefined("execution", serialized["execution"]),
-		extensionPacks: serialized["extensionPacks"],
-		capabilities: serialized["capabilities"],
-		meta: serialized["meta"]
-	}, []);
-	const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted["storage"]);
-	return orderTopLevel(sortObjectKeys({
-		...withDefaultsOmitted,
-		storage: withSortedIndexes
-	}));
-}
-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) {
-	return canonicalizeContract({
-		targetFamily: section["targetFamily"],
-		target: section["target"],
-		roots: {},
-		models: {},
-		storage: section["storage"] ?? {},
-		execution: section["execution"],
-		extensionPacks: {},
-		capabilities: section["capabilities"] ?? {},
-		meta: {},
-		profileHash: "",
-		...section
-	}, {
-		schemaVersion: SCHEMA_VERSION,
-		serializeContract: (c) => JSON.parse(JSON.stringify(c))
-	});
-}
-function computeStorageHash(args) {
-	return sha256(hashContract(args));
-}
-function computeExecutionHash(args) {
-	return sha256(hashContract(args));
-}
-function computeProfileHash(args) {
-	return sha256(hashContract(args));
-}
-//#endregion
-export { canonicalizeContractToObject as a, canonicalizeContract as i, computeProfileHash as n, computeStorageHash as r, computeExecutionHash as t };
-
-//# sourceMappingURL=hashing-rZiqFOlc.mjs.map