@prisma-next/contract 0.3.0-dev.143 → 0.3.0-dev.144

package/dist/{validate-domain-CTQiBiei.mjs → validate-domain-BlwWyv01.mjs}

@@ -1,16 +1,80 @@
+import { type } from "arktype";
+
+//#region src/validate-contract.ts
+var ContractValidationError = class extends Error {
+	code = "CONTRACT.VALIDATION_FAILED";
+	phase;
+	constructor(message, phase) {
+		super(message);
+		this.name = "ContractValidationError";
+		this.phase = phase;
+	}
+};
+const ContractSchema = type({
+	target: "string",
+	targetFamily: "string",
+	roots: "Record<string, string>",
+	models: "Record<string, unknown>",
+	storage: "Record<string, unknown>",
+	capabilities: "Record<string, Record<string, boolean>>",
+	extensionPacks: "Record<string, unknown>",
+	meta: "Record<string, unknown>",
+	"execution?": {
+		"executionHash?": "string",
+		mutations: { defaults: "unknown[]" }
+	},
+	profileHash: "string"
+});
+function stripPersistenceFields(raw) {
+	const { schemaVersion: _, _generated: _g, ...rest } = raw;
+	return rest;
+}
+function extractDomainShape(contract) {
+	return {
+		roots: contract.roots,
+		models: contract.models
+	};
+}
+/**
+* Framework-level contract validation (ADR 182).
+*
+* Three-pass validation:
+* 1. **Structural validation** (arktype): verifies required fields exist with
+*    correct base types.
+* 2. **Domain validation** (framework-owned): roots, relation targets,
+*    variant/base consistency, discriminators, ownership, orphans.
+* 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;
+*    Mongo validates collections/embedding.
+*
+* JSON persistence fields (`schemaVersion`, `_generated`) are stripped before
+* validation — they are not part of the in-memory contract representation.
+*
+* @template TContract  The fully-typed contract type (preserves literal types).
+* @param value           Raw contract value (e.g. parsed from JSON).
+* @param storageValidator  Family-specific storage validation function.
+* @returns The validated contract with full literal types.
+*/
+function validateContract(value, storageValidator) {
+	if (typeof value !== "object" || value === null) throw new ContractValidationError("Contract must be a non-null object", "structural");
+	const parsed = ContractSchema(stripPersistenceFields(value));
+	if (parsed instanceof type.errors) throw new ContractValidationError(`Invalid contract structure: ${parsed.summary}`, "structural");
+	const contract = parsed;
+	validateContractDomain(extractDomainShape(contract));
+	storageValidator(contract);
+	return contract;
+}
+
+//#endregion
 //#region src/validate-domain.ts
 function validateContractDomain(contract) {
 	const errors = [];
-	const warnings = [];
 	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);
-	detectOrphanedModels(contract, modelNames, warnings);
-	if (errors.length > 0) throw new Error(`Contract domain validation failed:\n- ${errors.join("\n- ")}`);
-	return { warnings };
+	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();
@@ -67,18 +131,7 @@ function validateOwnership(contract, modelNames, errors) {
 		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}")`);
 	}
 }
-function detectOrphanedModels(contract, modelNames, warnings) {
-	const referenced = /* @__PURE__ */ new Set();
-	for (const modelName of Object.values(contract.roots)) referenced.add(modelName);
-	for (const [modelName, model] of Object.entries(contract.models)) {
-		for (const relation of Object.values(model.relations ?? {})) referenced.add(relation.to);
-		if (model.variants) for (const variantName of Object.keys(model.variants)) referenced.add(variantName);
-		if (model.base) referenced.add(model.base);
-		if (model.owner) referenced.add(modelName);
-	}
-	for (const modelName of modelNames) if (!referenced.has(modelName)) warnings.push(`Orphaned model: "${modelName}" is not referenced by any root, relation, or variant`);
-}
 
 //#endregion
-export { validateContractDomain as t };
-//# sourceMappingURL=validate-domain-CTQiBiei.mjs.map
+export { ContractValidationError as n, validateContract as r, validateContractDomain as t };
+//# sourceMappingURL=validate-domain-BlwWyv01.mjs.map

package/dist/validate-domain-BlwWyv01.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-domain-BlwWyv01.mjs","names":["errors: string[]"],"sources":["../src/validate-contract.ts","../src/validate-domain.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type { Contract } from './contract-types';\nimport type { DomainContractShape } from './validate-domain';\nimport { validateContractDomain } from './validate-domain';\n\nexport 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\n/**\n * Family-provided storage validator.\n * SQL validates tables/columns/FKs; Mongo validates collections/embedding.\n */\nexport type StorageValidator = (contract: Contract) => void;\n\nconst ContractSchema = type({\n  target: 'string',\n  targetFamily: 'string',\n  roots: 'Record<string, string>',\n  models: 'Record<string, unknown>',\n  storage: 'Record<string, unknown>',\n  capabilities: 'Record<string, Record<string, boolean>>',\n  extensionPacks: 'Record<string, unknown>',\n  meta: 'Record<string, unknown>',\n  'execution?': {\n    'executionHash?': 'string',\n    mutations: {\n      defaults: 'unknown[]',\n    },\n  },\n  profileHash: 'string',\n});\n\nfunction stripPersistenceFields(raw: Record<string, unknown>): Record<string, unknown> {\n  const { schemaVersion: _, _generated: _g, ...rest } = raw;\n  return rest;\n}\n\nfunction extractDomainShape(contract: Contract): DomainContractShape {\n  return {\n    roots: contract.roots,\n    models: contract.models,\n  };\n}\n\n/**\n * Framework-level contract validation (ADR 182).\n *\n * Three-pass validation:\n * 1. **Structural validation** (arktype): verifies required fields exist with\n *    correct base types.\n * 2. **Domain validation** (framework-owned): roots, relation targets,\n *    variant/base consistency, discriminators, ownership, orphans.\n * 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;\n *    Mongo validates collections/embedding.\n *\n * JSON persistence fields (`schemaVersion`, `_generated`) are stripped before\n * validation — they are not part of the in-memory contract representation.\n *\n * @template TContract  The fully-typed contract type (preserves literal types).\n * @param value           Raw contract value (e.g. parsed from JSON).\n * @param storageValidator  Family-specific storage validation function.\n * @returns The validated contract with full literal types.\n */\nexport function validateContract<TContract extends Contract>(\n  value: unknown,\n  storageValidator: StorageValidator,\n): TContract {\n  if (typeof value !== 'object' || value === null) {\n    throw new ContractValidationError('Contract must be a non-null object', 'structural');\n  }\n\n  const stripped = stripPersistenceFields(value as Record<string, unknown>);\n\n  const parsed = ContractSchema(stripped);\n  if (parsed instanceof type.errors) {\n    throw new ContractValidationError(\n      `Invalid contract structure: ${parsed.summary}`,\n      'structural',\n    );\n  }\n\n  const contract = parsed as unknown as Contract;\n\n  validateContractDomain(extractDomainShape(contract));\n\n  storageValidator(contract);\n\n  return contract as unknown as TContract;\n}\n","import { ContractValidationError } from './validate-contract';\n\nexport interface DomainModelShape {\n  readonly fields: Record<string, unknown>;\n  readonly relations?: Record<string, { readonly to: string }>;\n  readonly discriminator?: { readonly field: string };\n  readonly variants?: Record<string, unknown>;\n  readonly base?: string;\n  readonly owner?: string;\n}\n\nexport interface DomainContractShape {\n  readonly roots: Record<string, string>;\n  readonly models: Record<string, DomainModelShape>;\n}\n\nexport function validateContractDomain(contract: DomainContractShape): void {\n  const errors: string[] = [];\n  const modelNames = new Set(Object.keys(contract.models));\n\n  validateRoots(contract, modelNames, errors);\n  validateVariantsAndBases(contract, modelNames, errors);\n  validateRelationTargets(contract, modelNames, errors);\n  validateDiscriminators(contract, errors);\n  validateOwnership(contract, modelNames, 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  modelNames: Set<string>,\n  errors: string[],\n): void {\n  const seenValues = new Set<string>();\n  for (const [rootKey, modelName] of Object.entries(contract.roots)) {\n    if (seenValues.has(modelName)) {\n      errors.push(`Duplicate root value: \"${modelName}\" is mapped by multiple root keys`);\n    }\n    seenValues.add(modelName);\n\n    if (!modelNames.has(modelName)) {\n      errors.push(\n        `Root \"${rootKey}\" references model \"${modelName}\" which does not exist in models`,\n      );\n    }\n  }\n}\n\nfunction validateVariantsAndBases(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  const models = new Map(Object.entries(contract.models));\n\n  for (const [modelName, model] of models) {\n    if (model.variants) {\n      for (const variantName of Object.keys(model.variants)) {\n        if (!modelNames.has(variantName)) {\n          errors.push(\n            `Model \"${modelName}\" lists variant \"${variantName}\" which does not exist in models`,\n          );\n          continue;\n        }\n        const variantModel = models.get(variantName);\n        if (!variantModel) continue;\n        if (variantModel.base !== modelName) {\n          errors.push(\n            `Variant \"${variantName}\" has base \"${variantModel.base ?? '(none)'}\" but expected \"${modelName}\"`,\n          );\n        }\n      }\n    }\n\n    if (model.base) {\n      if (!modelNames.has(model.base)) {\n        errors.push(`Model \"${modelName}\" has base \"${model.base}\" which does not exist in models`);\n        continue;\n      }\n      const baseModel = models.get(model.base);\n      if (!baseModel) continue;\n      if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) {\n        errors.push(\n          `Model \"${modelName}\" has base \"${model.base}\" which does not list it as a variant`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateRelationTargets(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    for (const [relName, relation] of Object.entries(model.relations ?? {})) {\n      if (!modelNames.has(relation.to)) {\n        errors.push(\n          `Relation \"${relName}\" on model \"${modelName}\" targets \"${relation.to}\" which does not exist in models`,\n        );\n      }\n    }\n  }\n}\n\nfunction validateDiscriminators(contract: DomainContractShape, errors: string[]): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    if (model.discriminator) {\n      if (!model.variants || Object.keys(model.variants).length === 0) {\n        errors.push(`Model \"${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 \"${modelName}\"`,\n        );\n      }\n    }\n\n    if (model.variants && Object.keys(model.variants).length > 0 && !model.discriminator) {\n      errors.push(`Model \"${modelName}\" has variants but no discriminator`);\n    }\n\n    if (model.base) {\n      if (model.discriminator) {\n        errors.push(`Model \"${modelName}\" has base and must not have discriminator`);\n      }\n      if (model.variants && Object.keys(model.variants).length > 0) {\n        errors.push(`Model \"${modelName}\" has base and must not have variants`);\n      }\n    }\n  }\n}\n\nfunction validateOwnership(\n  contract: DomainContractShape,\n  modelNames: Set<string>,\n  errors: string[],\n): void {\n  for (const [modelName, model] of Object.entries(contract.models)) {\n    if (!model.owner) continue;\n\n    if (model.owner === modelName) {\n      errors.push(`Model \"${modelName}\" cannot own itself`);\n    }\n\n    if (!modelNames.has(model.owner)) {\n      errors.push(`Model \"${modelName}\" has owner \"${model.owner}\" which does not exist in models`);\n    }\n\n    for (const [rootKey, rootModel] of Object.entries(contract.roots)) {\n      if (rootModel === modelName) {\n        errors.push(\n          `Owned model \"${modelName}\" must not appear in roots (found as root \"${rootKey}\")`,\n        );\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/validate-domain.d.mts

@@ -15,10 +15,7 @@ interface DomainContractShape {
   readonly roots: Record<string, string>;
   readonly models: Record<string, DomainModelShape>;
 }
-interface DomainValidationResult {
-  readonly warnings: string[];
-}
-declare function validateContractDomain(contract: DomainContractShape): DomainValidationResult;
+declare function validateContractDomain(contract: DomainContractShape): void;
 //#endregion
-export { type DomainContractShape, type DomainModelShape, type DomainValidationResult, validateContractDomain };
+export { type DomainContractShape, type DomainModelShape, validateContractDomain };
 //# sourceMappingURL=validate-domain.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate-domain.d.mts","names":[],"sources":["../src/validate-domain.ts"],"sourcesContent":[],"mappings":";UAAiB,gBAAA;EAAA,SAAA,MAAA,EACE,MADc,CAAA,MAAA,EAAA,OAAA,CAAA;EACd,SAAA,SAAA,CAAA,EACI,MADJ,CAAA,MAAA,EAAA;IACI,SAAA,EAAA,EAAA,MAAA;EAED,CAAA,CAAA;EAAM,SAAA,aAAA,CAAA,EAAA;IAKX,SAAA,KAAA,EAAA,MAAmB;EAClB,CAAA;EACgB,SAAA,QAAA,CAAA,EAPZ,MAOY,CAAA,MAAA,EAAA,OAAA,CAAA;EAAf,SAAA,IAAA,CAAA,EAAA,MAAA;EAAM,SAAA,KAAA,CAAA,EAAA,MAAA;AAGzB;AAIgB,UATC,mBAAA,CASqB;kBARpB;mBACC,eAAe;;UAGjB,sBAAA;;;iBAID,sBAAA,WAAiC,sBAAsB"}
+{"version":3,"file":"validate-domain.d.mts","names":[],"sources":["../src/validate-domain.ts"],"sourcesContent":[],"mappings":";UAEiB,gBAAA;EAAA,SAAA,MAAA,EACE,MADc,CAAA,MAAA,EAAA,OAAA,CAAA;EACd,SAAA,SAAA,CAAA,EACI,MADJ,CAAA,MAAA,EAAA;IACI,SAAA,EAAA,EAAA,MAAA;EAED,CAAA,CAAA;EAAM,SAAA,aAAA,CAAA,EAAA;IAKX,SAAA,KAAA,EAAA,MAAmB;EAClB,CAAA;EACgB,SAAA,QAAA,CAAA,EAPZ,MAOY,CAAA,MAAA,EAAA,OAAA,CAAA;EAAf,SAAA,IAAA,CAAA,EAAA,MAAA;EAAM,SAAA,KAAA,CAAA,EAAA,MAAA;AAGzB;UALiB,mBAAA;kBACC;mBACC,eAAe;;iBAGlB,sBAAA,WAAiC"}

package/dist/validate-domain.mjs

@@ -1,3 +1,3 @@
-import { t as validateContractDomain } from "./validate-domain-CTQiBiei.mjs";
+import { t as validateContractDomain } from "./validate-domain-BlwWyv01.mjs";
 
 export { validateContractDomain };

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.3.0-dev.143",
+  "version": "0.3.0-dev.144",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.29",
-    "@prisma-next/utils": "0.3.0-dev.143"
+    "@prisma-next/utils": "0.3.0-dev.144"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",

package/src/canonicalization.ts

@@ -1,6 +1,7 @@
 import { isArrayEqual } from '@prisma-next/utils/array-equal';
+import { ifDefined } from '@prisma-next/utils/defined';
 
-import type { StorageBase } from './types';
+import type { Contract } from './contract-types';
 import { bigintJsonReplacer } from './types';
 
 const TOP_LEVEL_ORDER = [
@@ -8,8 +9,6 @@ const TOP_LEVEL_ORDER = [
   'canonicalVersion',
   'targetFamily',
   'target',
-  'storageHash',
-  'executionHash',
   'profileHash',
   'roots',
   'models',
@@ -54,10 +53,6 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       continue;
     }
 
-    if (key === 'nullable' && value === false) {
-      continue;
-    }
-
     if (key === 'generated' && value === false) {
       continue;
     }
@@ -115,6 +110,8 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
         currentPath[3] === 'foreignKeys' &&
         (key === 'constraint' || key === 'index');
 
+      const isNullableField = key === 'nullable';
+
       if (
         !isRequiredModels &&
         !isRequiredTables &&
@@ -131,7 +128,8 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
         !isTableUniques &&
         !isTableIndexes &&
         !isTableForeignKeys &&
-        !isFkBooleanField
+        !isFkBooleanField &&
+        !isNullableField
       ) {
         continue;
       }
@@ -241,49 +239,23 @@ export function orderTopLevel(obj: Record<string, unknown>): Record<string, unkn
   return ordered;
 }
 
-export type CanonicalContractInput = {
-  readonly schemaVersion?: string | undefined;
-  readonly targetFamily: string;
-  readonly target: string;
-  readonly roots: Record<string, string>;
-  readonly models: Record<string, unknown>;
-  readonly storage: StorageBase | Record<string, unknown>;
-  readonly execution?: Record<string, unknown> | undefined;
-  readonly extensionPacks: Record<string, unknown>;
-  readonly capabilities: Record<string, Record<string, boolean>>;
-  readonly meta: Record<string, unknown>;
-  readonly storageHash?: string | undefined;
-  readonly executionHash?: string | undefined;
-  readonly profileHash?: string | undefined;
-};
-
 export function canonicalizeContractToObject(
-  input: CanonicalContractInput,
+  contract: Contract,
+  options?: { schemaVersion?: string },
 ): Record<string, unknown> {
-  const i = input as Record<string, unknown>;
   const normalized: Record<string, unknown> = {
-    ...(i['schemaVersion'] !== undefined ? { schemaVersion: i['schemaVersion'] } : {}),
-    targetFamily: i['targetFamily'],
-    target: i['target'],
-    ...(i['profileHash'] !== undefined ? { profileHash: i['profileHash'] } : {}),
-    roots: i['roots'],
-    models: i['models'],
-    storage: i['storage'],
-    ...(i['execution'] !== undefined ? { execution: i['execution'] } : {}),
-    extensionPacks: i['extensionPacks'],
-    capabilities: i['capabilities'],
-    meta: i['meta'],
+    ...ifDefined('schemaVersion', options?.schemaVersion),
+    targetFamily: contract.targetFamily,
+    target: contract.target,
+    profileHash: contract.profileHash,
+    roots: contract.roots,
+    models: contract.models,
+    storage: contract.storage,
+    ...ifDefined('execution', contract.execution),
+    extensionPacks: contract.extensionPacks,
+    capabilities: contract.capabilities,
+    meta: contract.meta,
   };
-  if (i['storageHash'] !== undefined) {
-    normalized['storageHash'] = i['storageHash'];
-  }
-  if (i['executionHash'] !== undefined) {
-    normalized['executionHash'] = i['executionHash'];
-  }
-  if (i['profileHash'] !== undefined) {
-    normalized['profileHash'] = i['profileHash'];
-  }
-
   const withDefaultsOmitted = omitDefaults(normalized, []) as Record<string, unknown>;
   const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted['storage']);
   const withSortedStorage = { ...withDefaultsOmitted, storage: withSortedIndexes };
@@ -291,6 +263,9 @@ export function canonicalizeContractToObject(
   return orderTopLevel(withSortedKeys);
 }
 
-export function canonicalizeContract(input: CanonicalContractInput): string {
-  return JSON.stringify(canonicalizeContractToObject(input), bigintJsonReplacer, 2);
+export function canonicalizeContract(
+  contract: Contract,
+  options?: { schemaVersion?: string },
+): string {
+  return JSON.stringify(canonicalizeContractToObject(contract, options), bigintJsonReplacer, 2);
 }

package/src/domain-types.ts

@@ -43,23 +43,6 @@ export interface ContractModel<TModelStorage extends ModelStorageBase = ModelSto
 
 // ── Backward-compatible aliases ──────────────────────────────────────────────
 
-/** @deprecated Use {@link ContractField} */
-export type DomainField = ContractField;
-/** @deprecated Use {@link ContractRelationOn} */
-export type DomainRelationOn = ContractRelationOn;
-/** @deprecated Use {@link ContractReferenceRelation} */
-export type DomainReferenceRelation = ContractReferenceRelation;
-/** @deprecated Use {@link ContractEmbedRelation} */
-export type DomainEmbedRelation = ContractEmbedRelation;
-/** @deprecated Use {@link ContractRelation} */
-export type DomainRelation = ContractRelation;
-/** @deprecated Use {@link ContractDiscriminator} */
-export type DomainDiscriminator = ContractDiscriminator;
-/** @deprecated Use {@link ContractVariantEntry} */
-export type DomainVariantEntry = ContractVariantEntry;
-/** @deprecated Use {@link ContractModel} */
-export type DomainModel = ContractModel;
-
 // ── Relation key helpers ─────────────────────────────────────────────────────
 
 type HasModelsWithRelations = {

package/src/exports/hashing.ts

@@ -1,6 +1,2 @@
-export {
-  type CanonicalContractInput,
-  canonicalizeContract,
-  canonicalizeContractToObject,
-} from '../canonicalization';
+export { canonicalizeContract, canonicalizeContractToObject } from '../canonicalization';
 export { computeExecutionHash, computeProfileHash, computeStorageHash } from '../hashing';

package/src/exports/types.ts

@@ -8,14 +8,6 @@ export type {
   ContractRelation,
   ContractRelationOn,
   ContractVariantEntry,
-  DomainDiscriminator,
-  DomainEmbedRelation,
-  DomainField,
-  DomainModel,
-  DomainReferenceRelation,
-  DomainRelation,
-  DomainRelationOn,
-  DomainVariantEntry,
   EmbedRelationKeys,
   ModelStorageBase,
   ReferenceRelationKeys,
@@ -26,12 +18,9 @@ export type {
   ColumnDefault,
   ColumnDefaultLiteralInputValue,
   ColumnDefaultLiteralValue,
-  ContractBase,
   ContractMarkerRecord,
   DocCollection,
   DocIndex,
-  DocumentContract,
-  DocumentStorage,
   ExecutionHashBase,
   ExecutionMutationDefault,
   ExecutionMutationDefaultValue,
@@ -58,7 +47,6 @@ export {
   bigintJsonReplacer,
   coreHash,
   executionHash,
-  isDocumentContract,
   isTaggedBigInt,
   isTaggedRaw,
   profileHash,

package/src/exports/validate-contract.ts

@@ -1,5 +1,6 @@
 export {
+  ContractValidationError,
+  type ContractValidationPhase,
   type StorageValidator,
-  type ValidateContractResult,
   validateContract,
 } from '../validate-contract';

package/src/exports/validate-domain.ts

@@ -1,6 +1,5 @@
 export {
   type DomainContractShape,
   type DomainModelShape,
-  type DomainValidationResult,
   validateContractDomain,
 } from '../validate-domain';

package/src/hashing.ts

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { canonicalizeContract } from './canonicalization';
+import type { Contract } from './contract-types';
 import type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';
 
 const SCHEMA_VERSION = '1';
@@ -10,23 +11,29 @@ function sha256(content: string): string {
   return `sha256:${hash.digest('hex')}`;
 }
 
+function hashContract(section: Record<string, unknown>): string {
+  const contract = {
+    targetFamily: section['targetFamily'],
+    target: section['target'],
+    roots: {},
+    models: {},
+    storage: section['storage'] ?? {},
+    execution: section['execution'],
+    extensionPacks: {},
+    capabilities: section['capabilities'] ?? {},
+    meta: {},
+    profileHash: '',
+    ...section,
+  } as Contract;
+  return canonicalizeContract(contract, { schemaVersion: SCHEMA_VERSION });
+}
+
 export function computeStorageHash(args: {
   target: string;
   targetFamily: string;
   storage: Record<string, unknown>;
 }): StorageHashBase<string> {
-  const canonical = canonicalizeContract({
-    schemaVersion: SCHEMA_VERSION,
-    targetFamily: args.targetFamily,
-    target: args.target,
-    storage: args.storage,
-    roots: {},
-    models: {},
-    extensionPacks: {},
-    capabilities: {},
-    meta: {},
-  });
-  return sha256(canonical) as StorageHashBase<string>;
+  return sha256(hashContract(args)) as StorageHashBase<string>;
 }
 
 export function computeExecutionHash(args: {
@@ -34,19 +41,7 @@ export function computeExecutionHash(args: {
   targetFamily: string;
   execution: Record<string, unknown>;
 }): ExecutionHashBase<string> {
-  const canonical = canonicalizeContract({
-    schemaVersion: SCHEMA_VERSION,
-    targetFamily: args.targetFamily,
-    target: args.target,
-    execution: args.execution,
-    roots: {},
-    models: {},
-    storage: {},
-    extensionPacks: {},
-    capabilities: {},
-    meta: {},
-  });
-  return sha256(canonical) as ExecutionHashBase<string>;
+  return sha256(hashContract(args)) as ExecutionHashBase<string>;
 }
 
 export function computeProfileHash(args: {
@@ -54,16 +49,5 @@ export function computeProfileHash(args: {
   targetFamily: string;
   capabilities: Record<string, Record<string, boolean>>;
 }): ProfileHashBase<string> {
-  const canonical = canonicalizeContract({
-    schemaVersion: SCHEMA_VERSION,
-    targetFamily: args.targetFamily,
-    target: args.target,
-    capabilities: args.capabilities,
-    roots: {},
-    models: {},
-    storage: {},
-    extensionPacks: {},
-    meta: {},
-  });
-  return sha256(canonical) as ProfileHashBase<string>;
+  return sha256(hashContract(args)) as ProfileHashBase<string>;
 }

package/src/types.ts

@@ -1,5 +1,3 @@
-import type { DomainModel } from './domain-types';
-
 /**
  * Unique symbol used as the key for branding types.
  */
@@ -59,26 +57,6 @@ export interface StorageBase<THash extends string = string> {
   readonly storageHash: StorageHashBase<THash>;
 }
 
-export interface ContractBase<
-  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
-  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
-  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
-> {
-  readonly schemaVersion: string;
-  readonly target: string;
-  readonly targetFamily: string;
-  readonly storageHash: TStorageHash;
-  readonly executionHash?: TExecutionHash;
-  readonly profileHash?: TProfileHash;
-  readonly capabilities: Record<string, Record<string, boolean>>;
-  readonly extensionPacks: Record<string, unknown>;
-  readonly meta: Record<string, unknown>;
-  readonly sources: Record<string, Source>;
-  readonly execution?: ExecutionSection;
-  readonly roots: Record<string, string>;
-  readonly models: Record<string, DomainModel>;
-}
-
 export interface FieldType {
   readonly type: string;
   readonly nullable: boolean;
@@ -188,22 +166,6 @@ export interface DocCollection {
   readonly readOnly?: boolean;
 }
 
-export interface DocumentStorage {
-  readonly document: {
-    readonly collections: Record<string, DocCollection>;
-  };
-}
-
-export interface DocumentContract<
-  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
-  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
-  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
-> extends ContractBase<TStorageHash, TExecutionHash, TProfileHash> {
-  // Accept string to work with JSON imports; runtime validation ensures 'document'
-  readonly targetFamily: string;
-  readonly storage: DocumentStorage;
-}
-
 // Plan types - target-family agnostic execution types
 export interface ParamDescriptor {
   readonly index?: number;
@@ -277,18 +239,6 @@ export interface ExecutionPlan<Row = unknown, Ast = unknown> {
 export type ResultType<P> =
   P extends ExecutionPlan<infer R, unknown> ? R : P extends { readonly _Row?: infer R } ? R : never;
 
-/**
- * Type guard to check if a contract is a Document contract
- */
-export function isDocumentContract(contract: unknown): contract is DocumentContract {
-  return (
-    typeof contract === 'object' &&
-    contract !== null &&
-    'targetFamily' in contract &&
-    contract.targetFamily === 'document'
-  );
-}
-
 /**
  * Contract marker record stored in the database.
  * Represents the current contract identity for a database.

package/src/validate-contract.ts

@@ -1,18 +1,27 @@
 import { type } from 'arktype';
 import type { Contract } from './contract-types';
-import type { DomainContractShape, DomainValidationResult } from './validate-domain';
+import type { DomainContractShape } from './validate-domain';
 import { validateContractDomain } from './validate-domain';
 
+export type ContractValidationPhase = 'structural' | 'domain' | 'storage';
+
+export class ContractValidationError extends Error {
+  readonly code = 'CONTRACT.VALIDATION_FAILED';
+  readonly phase: ContractValidationPhase;
+
+  constructor(message: string, phase: ContractValidationPhase) {
+    super(message);
+    this.name = 'ContractValidationError';
+    this.phase = phase;
+  }
+}
+
 /**
  * Family-provided storage validator.
  * SQL validates tables/columns/FKs; Mongo validates collections/embedding.
  */
 export type StorageValidator = (contract: Contract) => void;
 
-export interface ValidateContractResult {
-  readonly warnings: string[];
-}
-
 const ContractSchema = type({
   target: 'string',
   targetFamily: 'string',
@@ -28,11 +37,11 @@ const ContractSchema = type({
       defaults: 'unknown[]',
     },
   },
-  'profileHash?': 'string',
+  profileHash: 'string',
 });
 
 function stripPersistenceFields(raw: Record<string, unknown>): Record<string, unknown> {
-  const { schemaVersion: _, sources: _s, ...rest } = raw;
+  const { schemaVersion: _, _generated: _g, ...rest } = raw;
   return rest;
 }
 
@@ -54,7 +63,7 @@ function extractDomainShape(contract: Contract): DomainContractShape {
  * 3. **Storage validation** (family-provided): SQL validates tables/columns/FKs;
  *    Mongo validates collections/embedding.
  *
- * JSON persistence fields (`schemaVersion`, `sources`) are stripped before
+ * JSON persistence fields (`schemaVersion`, `_generated`) are stripped before
  * validation — they are not part of the in-memory contract representation.
  *
  * @template TContract  The fully-typed contract type (preserves literal types).
@@ -65,29 +74,26 @@ function extractDomainShape(contract: Contract): DomainContractShape {
 export function validateContract<TContract extends Contract>(
   value: unknown,
   storageValidator: StorageValidator,
-): TContract & ValidateContractResult {
+): TContract {
   if (typeof value !== 'object' || value === null) {
-    throw new Error('Contract must be a non-null object');
+    throw new ContractValidationError('Contract must be a non-null object', 'structural');
   }
 
   const stripped = stripPersistenceFields(value as Record<string, unknown>);
 
   const parsed = ContractSchema(stripped);
   if (parsed instanceof type.errors) {
-    throw new Error(`Invalid contract structure: ${parsed.summary}`);
+    throw new ContractValidationError(
+      `Invalid contract structure: ${parsed.summary}`,
+      'structural',
+    );
   }
 
-  // Arktype verified the structural shape; Contract adds branded hash types and
-  // ContractModel generics that can't be expressed in the schema.
   const contract = parsed as unknown as Contract;
 
-  const domainResult: DomainValidationResult = validateContractDomain(extractDomainShape(contract));
+  validateContractDomain(extractDomainShape(contract));
 
   storageValidator(contract);
 
-  // TContract narrows Contract with literal types from the caller's contract.d.ts;
-  // the runtime object is the same — the cast preserves the caller's type parameter.
-  return Object.assign(contract as unknown as TContract, {
-    warnings: domainResult.warnings,
-  });
+  return contract as unknown as TContract;
 }