@prisma-next/family-sql 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/core/schema-verify/verify-sql-schema.ts

@@ -2,22 +2,29 @@
  * Pure SQL schema verification function.
  *
  * This module provides a pure function that verifies a SqlSchemaIR against
- * a SqlContract without requiring a database connection. It can be reused
+ * a Contract without requiring a database connection. It can be reused
  * by migration planners and other tools that need to compare schema states.
  */
 
-import type { TargetBoundComponentDescriptor } from '@prisma-next/contract/framework-components';
+import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   OperationContext,
   SchemaIssue,
   SchemaVerificationNode,
   VerifyDatabaseSchemaResult,
-} from '@prisma-next/core-control-plane/types';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+} from '@prisma-next/framework-components/control';
+import type {
+  SqlStorage,
+  StorageColumn,
+  StorageTypeInstance,
+} from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { ifDefined } from '@prisma-next/utils/defined';
-import type { ComponentDatabaseDependency } from '../migrations/types';
+import { extractCodecControlHooks } from '../assembly';
+import { type CodecControlHooks, collectInitDependencies } from '../migrations/types';
 import {
+  arraysEqual,
   computeCounts,
   verifyDatabaseDependencies,
   verifyForeignKeys,
@@ -26,12 +33,28 @@ import {
   verifyUniqueConstraints,
 } from './verify-helpers';
 
+/**
+ * Function type for normalizing raw database default expressions into ColumnDefault.
+ * Target-specific implementations handle database dialect differences.
+ */
+export type DefaultNormalizer = (
+  rawDefault: string,
+  nativeType: string,
+) => ColumnDefault | undefined;
+
+/**
+ * Function type for normalizing schema native types to canonical form for comparison.
+ * Target-specific implementations handle dialect-specific type name variations
+ * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).
+ */
+export type NativeTypeNormalizer = (nativeType: string) => string;
+
 /**
  * Options for the pure schema verification function.
  */
 export interface VerifySqlSchemaOptions {
   /** The validated SQL contract to verify against */
-  readonly contract: SqlContract<SqlStorage>;
+  readonly contract: Contract<SqlStorage>;
   /** The schema IR from introspection (or another source) */
   readonly schema: SqlSchemaIR;
   /** Whether to run in strict mode (detects extra tables/columns) */
@@ -45,10 +68,22 @@ export interface VerifySqlSchemaOptions {
    * All components must have matching familyId ('sql') and targetId.
    */
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /**
+   * Optional target-specific normalizer for raw database default expressions.
+   * When provided, schema defaults (raw strings) are normalized before comparison
+   * with contract defaults (ColumnDefault objects).
+   */
+  readonly normalizeDefault?: DefaultNormalizer;
+  /**
+   * Optional target-specific normalizer for schema native type names.
+   * When provided, schema native types are normalized before comparison
+   * with contract native types (e.g., Postgres 'varchar' → 'character varying').
+   */
+  readonly normalizeNativeType?: NativeTypeNormalizer;
 }
 
 /**
- * Verifies that a SqlSchemaIR matches a SqlContract.
+ * Verifies that a SqlSchemaIR matches a Contract.
  *
  * This is a pure function that does NOT perform any database I/O.
  * It takes an already-introspected schema IR and compares it against
@@ -58,22 +93,168 @@ export interface VerifySqlSchemaOptions {
  * @returns VerifyDatabaseSchemaResult with verification tree and issues
  */
 export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabaseSchemaResult {
-  const { contract, schema, strict, context, typeMetadataRegistry } = options;
+  const {
+    contract,
+    schema,
+    strict,
+    context,
+    typeMetadataRegistry,
+    normalizeDefault,
+    normalizeNativeType,
+  } = options;
   const startTime = Date.now();
 
-  // Extract contract hashes and target
-  const contractCoreHash = contract.coreHash;
-  const contractProfileHash =
-    'profileHash' in contract && typeof contract.profileHash === 'string'
-      ? contract.profileHash
-      : undefined;
-  const contractTarget = contract.target;
+  // Extract codec control hooks once at entry point for reuse
+  const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+
+  const { contractStorageHash, contractProfileHash, contractTarget } =
+    extractContractMetadata(contract);
+  const storageTypes = contract.storage.types ?? {};
+  const { issues, rootChildren } = verifySchemaTables({
+    contract,
+    schema,
+    strict,
+    typeMetadataRegistry,
+    codecHooks,
+    storageTypes,
+    ...ifDefined('normalizeDefault', normalizeDefault),
+    ...ifDefined('normalizeNativeType', normalizeNativeType),
+  });
+
+  validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
+
+  // Verify storage type instances via codec control hooks (pure, deterministic)
+  const storageTypeEntries = Object.entries(storageTypes);
+  if (storageTypeEntries.length > 0) {
+    const typeNodes: SchemaVerificationNode[] = [];
+    for (const [typeName, typeInstance] of storageTypeEntries) {
+      const hook = codecHooks.get(typeInstance.codecId);
+      const typeIssues = hook?.verifyType
+        ? hook.verifyType({ typeName, typeInstance, schema })
+        : [];
+      if (typeIssues.length > 0) {
+        issues.push(...typeIssues);
+      }
+      const typeStatus = typeIssues.length > 0 ? 'fail' : 'pass';
+      const typeCode = typeIssues.length > 0 ? (typeIssues[0]?.kind ?? '') : '';
+      typeNodes.push({
+        status: typeStatus,
+        kind: 'storageType',
+        name: `type ${typeName}`,
+        contractPath: `storage.types.${typeName}`,
+        code: typeCode,
+        message:
+          typeIssues.length > 0
+            ? `${typeIssues.length} issue${typeIssues.length === 1 ? '' : 's'}`
+            : '',
+        expected: undefined,
+        actual: undefined,
+        children: [],
+      });
+    }
+    const typesStatus = typeNodes.some((n) => n.status === 'fail') ? 'fail' : 'pass';
+    rootChildren.push({
+      status: typesStatus,
+      kind: 'storageTypes',
+      name: 'types',
+      contractPath: 'storage.types',
+      code: typesStatus === 'fail' ? 'type_mismatch' : '',
+      message: '',
+      expected: undefined,
+      actual: undefined,
+      children: typeNodes,
+    });
+  }
+
+  const databaseDependencies = collectInitDependencies(options.frameworkComponents);
+  const dependencyStatuses = verifyDatabaseDependencies(databaseDependencies, schema, issues);
+  rootChildren.push(...dependencyStatuses);
+
+  const root = buildRootNode(rootChildren);
+
+  // Compute counts
+  const counts = computeCounts(root);
+
+  // Set ok flag
+  const ok = counts.fail === 0;
+
+  // Set code
+  const code = ok ? undefined : 'PN-SCHEMA-0001';
+
+  // Set summary
+  const summary = ok
+    ? 'Database schema satisfies contract'
+    : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? '' : 's'})`;
+
+  const totalTime = Date.now() - startTime;
+
+  return {
+    ok,
+    ...ifDefined('code', code),
+    summary,
+    contract: {
+      storageHash: contractStorageHash,
+      ...ifDefined('profileHash', contractProfileHash),
+    },
+    target: {
+      expected: contractTarget,
+      actual: contractTarget,
+    },
+    schema: {
+      issues,
+      root,
+      counts,
+    },
+    meta: {
+      strict,
+      ...ifDefined('contractPath', context?.contractPath),
+      ...ifDefined('configPath', context?.configPath),
+    },
+    timings: {
+      total: totalTime,
+    },
+  };
+}
+
+type VerificationStatus = 'pass' | 'warn' | 'fail';
 
-  // Compare contract vs schema IR
+function extractContractMetadata(contract: Contract<SqlStorage>): {
+  contractStorageHash: SqlStorage['storageHash'];
+  contractProfileHash?: Contract<SqlStorage>['profileHash'] | undefined;
+  contractTarget: Contract<SqlStorage>['target'];
+} {
+  return {
+    contractStorageHash: contract.storage.storageHash,
+    contractProfileHash:
+      'profileHash' in contract && typeof contract.profileHash === 'string'
+        ? contract.profileHash
+        : undefined,
+    contractTarget: contract.target,
+  };
+}
+
+function verifySchemaTables(options: {
+  contract: Contract<SqlStorage>;
+  schema: SqlSchemaIR;
+  strict: boolean;
+  typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
+  codecHooks: Map<string, CodecControlHooks>;
+  storageTypes: Record<string, StorageTypeInstance>;
+  normalizeDefault?: DefaultNormalizer;
+  normalizeNativeType?: NativeTypeNormalizer;
+}): { issues: SchemaIssue[]; rootChildren: SchemaVerificationNode[] } {
+  const {
+    contract,
+    schema,
+    strict,
+    typeMetadataRegistry,
+    codecHooks,
+    storageTypes,
+    normalizeDefault,
+    normalizeNativeType,
+  } = options;
   const issues: SchemaIssue[] = [];
   const rootChildren: SchemaVerificationNode[] = [];
-
-  // Compare tables
   const contractTables = contract.storage.tables;
   const schemaTables = schema.tables;
 
@@ -82,7 +263,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     const tablePath = `storage.tables.${tableName}`;
 
     if (!schemaTable) {
-      // Missing table
       issues.push({
         kind: 'missing_table',
         table: tableName,
@@ -102,366 +282,639 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
       continue;
     }
 
-    // Table exists - compare columns, constraints, etc.
-    const tableChildren: SchemaVerificationNode[] = [];
-    const columnNodes: SchemaVerificationNode[] = [];
-
-    // Compare columns
-    for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
-      const schemaColumn = schemaTable.columns[columnName];
-      const columnPath = `${tablePath}.columns.${columnName}`;
+    const tableChildren = verifyTableChildren({
+      contractTable,
+      schemaTable,
+      tableName,
+      tablePath,
+      issues,
+      strict,
+      typeMetadataRegistry,
+      codecHooks,
+      storageTypes,
+      ...ifDefined('normalizeDefault', normalizeDefault),
+      ...ifDefined('normalizeNativeType', normalizeNativeType),
+    });
+    rootChildren.push(buildTableNode(tableName, tablePath, tableChildren));
+  }
 
-      if (!schemaColumn) {
-        // Missing column
+  if (strict) {
+    for (const tableName of Object.keys(schemaTables)) {
+      if (!contractTables[tableName]) {
         issues.push({
-          kind: 'missing_column',
+          kind: 'extra_table',
           table: tableName,
-          column: columnName,
-          message: `Column "${tableName}"."${columnName}" is missing from database`,
+          message: `Extra table "${tableName}" found in database (not in contract)`,
         });
-        columnNodes.push({
+        rootChildren.push({
           status: 'fail',
-          kind: 'column',
-          name: `${columnName}: missing`,
-          contractPath: columnPath,
-          code: 'missing_column',
-          message: `Column "${columnName}" is missing`,
+          kind: 'table',
+          name: `table ${tableName}`,
+          contractPath: `storage.tables.${tableName}`,
+          code: 'extra_table',
+          message: `Extra table "${tableName}" found`,
           expected: undefined,
           actual: undefined,
           children: [],
         });
-        continue;
       }
+    }
+  }
+
+  return { issues, rootChildren };
+}
+
+function verifyTableChildren(options: {
+  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  schemaTable: SqlSchemaIR['tables'][string];
+  tableName: string;
+  tablePath: string;
+  issues: SchemaIssue[];
+  strict: boolean;
+  typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
+  codecHooks: Map<string, CodecControlHooks>;
+  storageTypes: Record<string, StorageTypeInstance>;
+  normalizeDefault?: DefaultNormalizer;
+  normalizeNativeType?: NativeTypeNormalizer;
+}): SchemaVerificationNode[] {
+  const {
+    contractTable,
+    schemaTable,
+    tableName,
+    tablePath,
+    issues,
+    strict,
+    typeMetadataRegistry,
+    codecHooks,
+    storageTypes,
+    normalizeDefault,
+    normalizeNativeType,
+  } = options;
+  const tableChildren: SchemaVerificationNode[] = [];
+  const columnNodes = collectContractColumnNodes({
+    contractTable,
+    schemaTable,
+    tableName,
+    tablePath,
+    issues,
+    strict,
+    typeMetadataRegistry,
+    codecHooks,
+    storageTypes,
+    ...ifDefined('normalizeDefault', normalizeDefault),
+    ...ifDefined('normalizeNativeType', normalizeNativeType),
+  });
+  if (columnNodes.length > 0) {
+    tableChildren.push(buildColumnsNode(tablePath, columnNodes));
+  }
+  if (strict) {
+    appendExtraColumnNodes({
+      contractTable,
+      schemaTable,
+      tableName,
+      tablePath,
+      issues,
+      columnNodes,
+    });
+  }
 
-      // Column exists - compare type and nullability
-      const columnChildren: SchemaVerificationNode[] = [];
-      let columnStatus: 'pass' | 'warn' | 'fail' = 'pass';
+  if (contractTable.primaryKey) {
+    const pkStatus = verifyPrimaryKey(
+      contractTable.primaryKey,
+      schemaTable.primaryKey,
+      tableName,
+      issues,
+    );
+    if (pkStatus === 'fail') {
+      tableChildren.push({
+        status: 'fail',
+        kind: 'primaryKey',
+        name: `primary key: ${contractTable.primaryKey.columns.join(', ')}`,
+        contractPath: `${tablePath}.primaryKey`,
+        code: 'primary_key_mismatch',
+        message: 'Primary key mismatch',
+        expected: contractTable.primaryKey,
+        actual: schemaTable.primaryKey,
+        children: [],
+      });
+    } else {
+      tableChildren.push({
+        status: 'pass',
+        kind: 'primaryKey',
+        name: `primary key: ${contractTable.primaryKey.columns.join(', ')}`,
+        contractPath: `${tablePath}.primaryKey`,
+        code: '',
+        message: '',
+        expected: undefined,
+        actual: undefined,
+        children: [],
+      });
+    }
+  } else if (schemaTable.primaryKey && strict) {
+    issues.push({
+      kind: 'extra_primary_key',
+      table: tableName,
+      message: 'Extra primary key found in database (not in contract)',
+    });
+    tableChildren.push({
+      status: 'fail',
+      kind: 'primaryKey',
+      name: `primary key: ${schemaTable.primaryKey.columns.join(', ')}`,
+      contractPath: `${tablePath}.primaryKey`,
+      code: 'extra_primary_key',
+      message: 'Extra primary key found',
+      expected: undefined,
+      actual: schemaTable.primaryKey,
+      children: [],
+    });
+  }
 
-      // Compare type using nativeType directly
-      // Both contractColumn.nativeType and schemaColumn.nativeType are required by their types
-      const contractNativeType = contractColumn.nativeType;
-      const schemaNativeType = schemaColumn.nativeType;
+  // Verify FK constraints only for FKs with constraint: true.
+  // Always call when strict mode is on so extra-FK detection runs even if
+  // the contract has no FKs for this table.
+  const constraintFks = contractTable.foreignKeys.filter((fk) => fk.constraint === true);
+  if (constraintFks.length > 0 || strict) {
+    const fkStatuses = verifyForeignKeys(
+      constraintFks,
+      schemaTable.foreignKeys,
+      tableName,
+      tablePath,
+      issues,
+      strict,
+    );
+    tableChildren.push(...fkStatuses);
+  }
 
-      if (contractNativeType !== schemaNativeType) {
-        // Compare native types directly
-        issues.push({
-          kind: 'type_mismatch',
-          table: tableName,
-          column: columnName,
-          expected: contractNativeType,
-          actual: schemaNativeType,
-          message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`,
-        });
-        columnChildren.push({
-          status: 'fail',
-          kind: 'type',
-          name: 'type',
-          contractPath: `${columnPath}.nativeType`,
-          code: 'type_mismatch',
-          message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
-          expected: contractNativeType,
-          actual: schemaNativeType,
-          children: [],
-        });
-        columnStatus = 'fail';
-      }
+  const uniqueStatuses = verifyUniqueConstraints(
+    contractTable.uniques,
+    schemaTable.uniques,
+    schemaTable.indexes,
+    tableName,
+    tablePath,
+    issues,
+    strict,
+  );
+  tableChildren.push(...uniqueStatuses);
 
-      // Optionally validate that codecId (if present) and nativeType agree with registry
-      if (contractColumn.codecId) {
-        const typeMetadata = typeMetadataRegistry.get(contractColumn.codecId);
-        if (!typeMetadata) {
-          // Warning: codecId not found in registry
-          columnChildren.push({
-            status: 'warn',
-            kind: 'type',
-            name: 'type_metadata_missing',
-            contractPath: `${columnPath}.codecId`,
-            code: 'type_metadata_missing',
-            message: `codecId "${contractColumn.codecId}" not found in type metadata registry`,
-            expected: contractColumn.codecId,
-            actual: undefined,
-            children: [],
-          });
-        } else if (typeMetadata.nativeType && typeMetadata.nativeType !== contractNativeType) {
-          // Warning: codecId and nativeType don't agree with registry
-          columnChildren.push({
-            status: 'warn',
-            kind: 'type',
-            name: 'type_consistency',
-            contractPath: `${columnPath}.codecId`,
-            code: 'type_consistency_warning',
-            message: `codecId "${contractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${contractNativeType}"`,
-            expected: typeMetadata.nativeType,
-            actual: contractNativeType,
-            children: [],
-          });
-        }
-      }
+  // Combine user-declared indexes with FK-backing indexes (from FKs with index: true)
+  // so the verifier treats FK-backing indexes as expected, not "extra".
+  // Deduplicate: skip FK-backing indexes already covered by a user-declared index.
+  const fkBackingIndexes = contractTable.foreignKeys
+    .filter(
+      (fk) =>
+        fk.index === true &&
+        !contractTable.indexes.some((idx) => arraysEqual(idx.columns, fk.columns)),
+    )
+    .map((fk) => ({ columns: fk.columns }));
+  const allExpectedIndexes = [...contractTable.indexes, ...fkBackingIndexes];
 
-      // Compare nullability
-      if (contractColumn.nullable !== schemaColumn.nullable) {
-        issues.push({
-          kind: 'nullability_mismatch',
-          table: tableName,
-          column: columnName,
-          expected: String(contractColumn.nullable),
-          actual: String(schemaColumn.nullable),
-          message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? 'nullable' : 'not null'}, got ${schemaColumn.nullable ? 'nullable' : 'not null'}`,
-        });
-        columnChildren.push({
-          status: 'fail',
-          kind: 'nullability',
-          name: 'nullability',
-          contractPath: `${columnPath}.nullable`,
-          code: 'nullability_mismatch',
-          message: `Nullability mismatch: expected ${contractColumn.nullable ? 'nullable' : 'not null'}, got ${schemaColumn.nullable ? 'nullable' : 'not null'}`,
-          expected: contractColumn.nullable,
-          actual: schemaColumn.nullable,
-          children: [],
-        });
-        columnStatus = 'fail';
-      }
+  const indexStatuses = verifyIndexes(
+    allExpectedIndexes,
+    schemaTable.indexes,
+    schemaTable.uniques,
+    tableName,
+    tablePath,
+    issues,
+    strict,
+  );
+  tableChildren.push(...indexStatuses);
 
-      // Compute column status from children (fail > warn > pass)
-      const computedColumnStatus = columnChildren.some((c) => c.status === 'fail')
-        ? 'fail'
-        : columnChildren.some((c) => c.status === 'warn')
-          ? 'warn'
-          : 'pass';
-      // Use computed status if we have children, otherwise use the manually set status
-      const finalColumnStatus = columnChildren.length > 0 ? computedColumnStatus : columnStatus;
-
-      // Build column node
-      const nullableText = contractColumn.nullable ? 'nullable' : 'not nullable';
-      const columnTypeDisplay = contractColumn.codecId
-        ? `${contractNativeType} (${contractColumn.codecId})`
-        : contractNativeType;
-      // Collect failure messages from children to create a summary message
-      const failureMessages = columnChildren
-        .filter((child) => child.status === 'fail' && child.message)
-        .map((child) => child.message)
-        .filter((msg): msg is string => typeof msg === 'string' && msg.length > 0);
-      const columnMessage =
-        finalColumnStatus === 'fail' && failureMessages.length > 0
-          ? failureMessages.join('; ')
-          : '';
-      // Extract code from first child if status indicates an issue
-      const columnCode =
-        (finalColumnStatus === 'fail' || finalColumnStatus === 'warn') && columnChildren[0]
-          ? columnChildren[0].code
-          : '';
+  return tableChildren;
+}
+
+function collectContractColumnNodes(options: {
+  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  schemaTable: SqlSchemaIR['tables'][string];
+  tableName: string;
+  tablePath: string;
+  issues: SchemaIssue[];
+  strict: boolean;
+  typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
+  codecHooks: Map<string, CodecControlHooks>;
+  storageTypes: Record<string, StorageTypeInstance>;
+  normalizeDefault?: DefaultNormalizer;
+  normalizeNativeType?: NativeTypeNormalizer;
+}): SchemaVerificationNode[] {
+  const {
+    contractTable,
+    schemaTable,
+    tableName,
+    tablePath,
+    issues,
+    strict,
+    typeMetadataRegistry,
+    codecHooks,
+    storageTypes,
+    normalizeDefault,
+    normalizeNativeType,
+  } = options;
+  const columnNodes: SchemaVerificationNode[] = [];
+
+  for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
+    const schemaColumn = schemaTable.columns[columnName];
+    const columnPath = `${tablePath}.columns.${columnName}`;
+
+    if (!schemaColumn) {
+      issues.push({
+        kind: 'missing_column',
+        table: tableName,
+        column: columnName,
+        message: `Column "${tableName}"."${columnName}" is missing from database`,
+      });
       columnNodes.push({
-        status: finalColumnStatus,
+        status: 'fail',
         kind: 'column',
-        name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
+        name: `${columnName}: missing`,
         contractPath: columnPath,
-        code: columnCode,
-        message: columnMessage,
+        code: 'missing_column',
+        message: `Column "${columnName}" is missing`,
         expected: undefined,
         actual: undefined,
-        children: columnChildren,
+        children: [],
       });
+      continue;
     }
 
-    // Group columns under a "columns" header if we have any columns
-    if (columnNodes.length > 0) {
-      const columnsStatus = columnNodes.some((c) => c.status === 'fail')
-        ? 'fail'
-        : columnNodes.some((c) => c.status === 'warn')
-          ? 'warn'
-          : 'pass';
-      tableChildren.push({
-        status: columnsStatus,
-        kind: 'columns',
-        name: 'columns',
-        contractPath: `${tablePath}.columns`,
-        code: '',
-        message: '',
+    columnNodes.push(
+      verifyColumn({
+        tableName,
+        columnName,
+        contractColumn,
+        schemaColumn,
+        columnPath,
+        issues,
+        strict,
+        typeMetadataRegistry,
+        codecHooks,
+        storageTypes,
+        ...ifDefined('normalizeDefault', normalizeDefault),
+        ...ifDefined('normalizeNativeType', normalizeNativeType),
+      }),
+    );
+  }
+
+  return columnNodes;
+}
+
+function appendExtraColumnNodes(options: {
+  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  schemaTable: SqlSchemaIR['tables'][string];
+  tableName: string;
+  tablePath: string;
+  issues: SchemaIssue[];
+  columnNodes: SchemaVerificationNode[];
+}): void {
+  const { contractTable, schemaTable, tableName, tablePath, issues, columnNodes } = options;
+  for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) {
+    if (!contractTable.columns[columnName]) {
+      issues.push({
+        kind: 'extra_column',
+        table: tableName,
+        column: columnName,
+        message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`,
+      });
+      columnNodes.push({
+        status: 'fail',
+        kind: 'column',
+        name: `${columnName}: extra`,
+        contractPath: `${tablePath}.columns.${columnName}`,
+        code: 'extra_column',
+        message: `Extra column "${columnName}" found`,
         expected: undefined,
-        actual: undefined,
-        children: columnNodes,
+        actual: nativeType,
+        children: [],
       });
     }
+  }
+}
 
-    // Check for extra columns in strict mode
-    if (strict) {
-      for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) {
-        if (!contractTable.columns[columnName]) {
-          issues.push({
-            kind: 'extra_column',
-            table: tableName,
-            column: columnName,
-            message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`,
-          });
-          columnNodes.push({
-            status: 'fail',
-            kind: 'column',
-            name: `${columnName}: extra`,
-            contractPath: `${tablePath}.columns.${columnName}`,
-            code: 'extra_column',
-            message: `Extra column "${columnName}" found`,
-            expected: undefined,
-            actual: nativeType,
-            children: [],
-          });
-        }
-      }
+function verifyColumn(options: {
+  tableName: string;
+  columnName: string;
+  contractColumn: Contract<SqlStorage>['storage']['tables'][string]['columns'][string];
+  schemaColumn: SqlSchemaIR['tables'][string]['columns'][string];
+  columnPath: string;
+  issues: SchemaIssue[];
+  strict: boolean;
+  typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
+  codecHooks: Map<string, CodecControlHooks>;
+  storageTypes: Record<string, StorageTypeInstance>;
+  normalizeDefault?: DefaultNormalizer;
+  normalizeNativeType?: NativeTypeNormalizer;
+}): SchemaVerificationNode {
+  const {
+    tableName,
+    columnName,
+    contractColumn,
+    schemaColumn,
+    columnPath,
+    issues,
+    strict,
+    codecHooks,
+    storageTypes,
+    normalizeDefault,
+    normalizeNativeType,
+  } = options;
+  const columnChildren: SchemaVerificationNode[] = [];
+  let columnStatus: VerificationStatus = 'pass';
+
+  const resolvedContractColumn = resolveContractColumnTypeMetadata(contractColumn, storageTypes, {
+    tableName,
+    columnName,
+  });
+  const contractNativeType = renderExpectedNativeType(contractColumn, storageTypes, codecHooks, {
+    tableName,
+    columnName,
+  });
+  const schemaNativeType =
+    normalizeNativeType?.(schemaColumn.nativeType) ?? schemaColumn.nativeType;
+
+  if (contractNativeType !== schemaNativeType) {
+    issues.push({
+      kind: 'type_mismatch',
+      table: tableName,
+      column: columnName,
+      expected: contractNativeType,
+      actual: schemaNativeType,
+      message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`,
+    });
+    columnChildren.push({
+      status: 'fail',
+      kind: 'type',
+      name: 'type',
+      contractPath: `${columnPath}.nativeType`,
+      code: 'type_mismatch',
+      message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
+      expected: contractNativeType,
+      actual: schemaNativeType,
+      children: [],
+    });
+    columnStatus = 'fail';
+  }
+
+  if (resolvedContractColumn.codecId) {
+    const typeMetadata = options.typeMetadataRegistry.get(resolvedContractColumn.codecId);
+    if (!typeMetadata) {
+      columnChildren.push({
+        status: 'warn',
+        kind: 'type',
+        name: 'type_metadata_missing',
+        contractPath: `${columnPath}.codecId`,
+        code: 'type_metadata_missing',
+        message: `codecId "${resolvedContractColumn.codecId}" not found in type metadata registry`,
+        expected: resolvedContractColumn.codecId,
+        actual: undefined,
+        children: [],
+      });
+    } else if (
+      typeMetadata.nativeType &&
+      typeMetadata.nativeType !== resolvedContractColumn.nativeType
+    ) {
+      columnChildren.push({
+        status: 'warn',
+        kind: 'type',
+        name: 'type_consistency',
+        contractPath: `${columnPath}.codecId`,
+        code: 'type_consistency_warning',
+        message: `codecId "${resolvedContractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${resolvedContractColumn.nativeType}"`,
+        expected: typeMetadata.nativeType,
+        actual: resolvedContractColumn.nativeType,
+        children: [],
+      });
     }
+  }
 
-    // Compare primary key
-    if (contractTable.primaryKey) {
-      const pkStatus = verifyPrimaryKey(
-        contractTable.primaryKey,
-        schemaTable.primaryKey,
-        tableName,
-        issues,
-      );
-      if (pkStatus === 'fail') {
-        tableChildren.push({
-          status: 'fail',
-          kind: 'primaryKey',
-          name: `primary key: ${contractTable.primaryKey.columns.join(', ')}`,
-          contractPath: `${tablePath}.primaryKey`,
-          code: 'primary_key_mismatch',
-          message: 'Primary key mismatch',
-          expected: contractTable.primaryKey,
-          actual: schemaTable.primaryKey,
-          children: [],
-        });
-      } else {
-        tableChildren.push({
-          status: 'pass',
-          kind: 'primaryKey',
-          name: `primary key: ${contractTable.primaryKey.columns.join(', ')}`,
-          contractPath: `${tablePath}.primaryKey`,
-          code: '',
-          message: '',
-          expected: undefined,
-          actual: undefined,
-          children: [],
-        });
-      }
-    } else if (schemaTable.primaryKey && strict) {
-      // Extra primary key in strict mode
+  if (contractColumn.nullable !== schemaColumn.nullable) {
+    issues.push({
+      kind: 'nullability_mismatch',
+      table: tableName,
+      column: columnName,
+      expected: String(contractColumn.nullable),
+      actual: String(schemaColumn.nullable),
+      message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? 'nullable' : 'not null'}, got ${schemaColumn.nullable ? 'nullable' : 'not null'}`,
+    });
+    columnChildren.push({
+      status: 'fail',
+      kind: 'nullability',
+      name: 'nullability',
+      contractPath: `${columnPath}.nullable`,
+      code: 'nullability_mismatch',
+      message: `Nullability mismatch: expected ${contractColumn.nullable ? 'nullable' : 'not null'}, got ${schemaColumn.nullable ? 'nullable' : 'not null'}`,
+      expected: contractColumn.nullable,
+      actual: schemaColumn.nullable,
+      children: [],
+    });
+    columnStatus = 'fail';
+  }
+
+  if (contractColumn.default) {
+    if (!schemaColumn.default) {
+      const defaultDescription = describeColumnDefault(contractColumn.default);
       issues.push({
-        kind: 'extra_primary_key',
+        kind: 'default_missing',
         table: tableName,
-        message: 'Extra primary key found in database (not in contract)',
+        column: columnName,
+        expected: defaultDescription,
+        message: `Column "${tableName}"."${columnName}" should have default ${defaultDescription} but database has no default`,
       });
-      tableChildren.push({
+      columnChildren.push({
         status: 'fail',
-        kind: 'primaryKey',
-        name: `primary key: ${schemaTable.primaryKey.columns.join(', ')}`,
-        contractPath: `${tablePath}.primaryKey`,
-        code: 'extra_primary_key',
-        message: 'Extra primary key found',
-        expected: undefined,
-        actual: schemaTable.primaryKey,
+        kind: 'default',
+        name: 'default',
+        contractPath: `${columnPath}.default`,
+        code: 'default_missing',
+        message: `Default missing: expected ${defaultDescription}`,
+        expected: defaultDescription,
+        actual: undefined,
         children: [],
       });
+      columnStatus = 'fail';
+    } else if (
+      !columnDefaultsEqual(
+        contractColumn.default,
+        schemaColumn.default,
+        normalizeDefault,
+        schemaNativeType,
+      )
+    ) {
+      const expectedDescription = describeColumnDefault(contractColumn.default);
+      // schemaColumn.default is now a raw string, describe it as-is
+      const actualDescription = schemaColumn.default;
+      issues.push({
+        kind: 'default_mismatch',
+        table: tableName,
+        column: columnName,
+        expected: expectedDescription,
+        actual: actualDescription,
+        message: `Column "${tableName}"."${columnName}" has default mismatch: expected ${expectedDescription}, got ${actualDescription}`,
+      });
+      columnChildren.push({
+        status: 'fail',
+        kind: 'default',
+        name: 'default',
+        contractPath: `${columnPath}.default`,
+        code: 'default_mismatch',
+        message: `Default mismatch: expected ${expectedDescription}, got ${actualDescription}`,
+        expected: expectedDescription,
+        actual: actualDescription,
+        children: [],
+      });
+      columnStatus = 'fail';
     }
-
-    // Compare foreign keys
-    const fkStatuses = verifyForeignKeys(
-      contractTable.foreignKeys,
-      schemaTable.foreignKeys,
-      tableName,
-      tablePath,
-      issues,
-      strict,
-    );
-    tableChildren.push(...fkStatuses);
-
-    // Compare unique constraints
-    // Pass schemaIndexes so unique indexes can satisfy unique constraint requirements
-    const uniqueStatuses = verifyUniqueConstraints(
-      contractTable.uniques,
-      schemaTable.uniques,
-      schemaTable.indexes,
-      tableName,
-      tablePath,
-      issues,
-      strict,
-    );
-    tableChildren.push(...uniqueStatuses);
-
-    // Compare indexes
-    // Pass schemaUniques so unique constraints can satisfy index requirements
-    const indexStatuses = verifyIndexes(
-      contractTable.indexes,
-      schemaTable.indexes,
-      schemaTable.uniques,
-      tableName,
-      tablePath,
-      issues,
-      strict,
-    );
-    tableChildren.push(...indexStatuses);
-
-    // Build table node
-    const tableStatus = tableChildren.some((c) => c.status === 'fail')
-      ? 'fail'
-      : tableChildren.some((c) => c.status === 'warn')
-        ? 'warn'
-        : 'pass';
-    // Collect failure messages from children to create a summary message
-    const tableFailureMessages = tableChildren
-      .filter((child) => child.status === 'fail' && child.message)
-      .map((child) => child.message)
-      .filter((msg): msg is string => typeof msg === 'string' && msg.length > 0);
-    const tableMessage =
-      tableStatus === 'fail' && tableFailureMessages.length > 0
-        ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? '' : 's'}`
-        : '';
-    const tableCode =
-      tableStatus === 'fail' && tableChildren.length > 0 && tableChildren[0]
-        ? tableChildren[0].code
-        : '';
-    rootChildren.push({
-      status: tableStatus,
-      kind: 'table',
-      name: `table ${tableName}`,
-      contractPath: tablePath,
-      code: tableCode,
-      message: tableMessage,
+  } else if (strict && schemaColumn.default) {
+    issues.push({
+      kind: 'extra_default',
+      table: tableName,
+      column: columnName,
+      actual: schemaColumn.default,
+      message: `Column "${tableName}"."${columnName}" has default ${schemaColumn.default} in database but contract specifies no default`,
+    });
+    columnChildren.push({
+      status: 'fail',
+      kind: 'default',
+      name: 'default',
+      contractPath: `${columnPath}.default`,
+      code: 'extra_default',
+      message: `Extra default: ${schemaColumn.default}`,
       expected: undefined,
-      actual: undefined,
-      children: tableChildren,
+      actual: schemaColumn.default,
+      children: [],
     });
+    columnStatus = 'fail';
   }
 
-  // Check for extra tables in strict mode
-  if (strict) {
-    for (const tableName of Object.keys(schemaTables)) {
-      if (!contractTables[tableName]) {
-        issues.push({
-          kind: 'extra_table',
-          table: tableName,
-          message: `Extra table "${tableName}" found in database (not in contract)`,
-        });
-        rootChildren.push({
-          status: 'fail',
-          kind: 'table',
-          name: `table ${tableName}`,
-          contractPath: `storage.tables.${tableName}`,
-          code: 'extra_table',
-          message: `Extra table "${tableName}" found`,
-          expected: undefined,
-          actual: undefined,
-          children: [],
-        });
+  // Single-pass aggregation for better performance
+  const aggregated = aggregateChildState(columnChildren, columnStatus);
+  const nullableText = contractColumn.nullable ? 'nullable' : 'not nullable';
+  const columnTypeDisplay = resolvedContractColumn.codecId
+    ? `${contractNativeType} (${resolvedContractColumn.codecId})`
+    : contractNativeType;
+  const columnMessage = aggregated.failureMessages.join('; ');
+
+  return {
+    status: aggregated.status,
+    kind: 'column',
+    name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
+    contractPath: columnPath,
+    code: aggregated.firstCode,
+    message: columnMessage,
+    expected: undefined,
+    actual: undefined,
+    children: columnChildren,
+  };
+}
+
+function buildColumnsNode(
+  tablePath: string,
+  columnNodes: SchemaVerificationNode[],
+): SchemaVerificationNode {
+  return {
+    status: aggregateChildState(columnNodes, 'pass').status,
+    kind: 'columns',
+    name: 'columns',
+    contractPath: `${tablePath}.columns`,
+    code: '',
+    message: '',
+    expected: undefined,
+    actual: undefined,
+    children: columnNodes,
+  };
+}
+
+function buildTableNode(
+  tableName: string,
+  tablePath: string,
+  tableChildren: SchemaVerificationNode[],
+): SchemaVerificationNode {
+  const tableStatus = aggregateChildState(tableChildren, 'pass').status;
+  const tableFailureMessages = tableChildren
+    .filter((child) => child.status === 'fail' && child.message)
+    .map((child) => child.message)
+    .filter((msg): msg is string => typeof msg === 'string' && msg.length > 0);
+  const tableMessage =
+    tableStatus === 'fail' && tableFailureMessages.length > 0
+      ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? '' : 's'}`
+      : '';
+  const tableCode =
+    tableStatus === 'fail' && tableChildren.length > 0 && tableChildren[0]
+      ? tableChildren[0].code
+      : '';
+
+  return {
+    status: tableStatus,
+    kind: 'table',
+    name: `table ${tableName}`,
+    contractPath: tablePath,
+    code: tableCode,
+    message: tableMessage,
+    expected: undefined,
+    actual: undefined,
+    children: tableChildren,
+  };
+}
+
+function buildRootNode(rootChildren: SchemaVerificationNode[]): SchemaVerificationNode {
+  return {
+    status: aggregateChildState(rootChildren, 'pass').status,
+    kind: 'contract',
+    name: 'contract',
+    contractPath: '',
+    code: '',
+    message: '',
+    expected: undefined,
+    actual: undefined,
+    children: rootChildren,
+  };
+}
+
+/**
+ * Aggregated state from child nodes, computed in a single pass.
+ */
+interface AggregatedChildState {
+  readonly status: VerificationStatus;
+  readonly failureMessages: readonly string[];
+  readonly firstCode: string;
+}
+
+/**
+ * Aggregates status, failure messages, and code from children in a single pass.
+ * This is more efficient than calling separate functions that each iterate the array.
+ */
+function aggregateChildState(
+  children: SchemaVerificationNode[],
+  fallback: VerificationStatus,
+): AggregatedChildState {
+  let status: VerificationStatus = fallback;
+  const failureMessages: string[] = [];
+  let firstCode = '';
+
+  for (const child of children) {
+    if (child.status === 'fail') {
+      status = 'fail';
+      if (!firstCode) {
+        firstCode = child.code;
+      }
+      if (child.message && typeof child.message === 'string' && child.message.length > 0) {
+        failureMessages.push(child.message);
+      }
+    } else if (child.status === 'warn' && status !== 'fail') {
+      status = 'warn';
+      if (!firstCode) {
+        firstCode = child.code;
       }
     }
   }
 
-  // Validate that all extension packs declared in the contract are present in frameworkComponents
-  // This is a configuration integrity check - if the contract was emitted with an extension,
-  // that extension must be provided in the current configuration.
-  // Note: contract.extensionPacks includes adapter.id and target.id (from extractExtensionIds),
-  // so we check for matches as extension, adapter, or target components.
+  return { status, failureMessages, firstCode };
+}
+
+function validateFrameworkComponentsForExtensions(
+  contract: Contract<SqlStorage>,
+  frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>,
+): void {
   const contractExtensionPacks = contract.extensionPacks ?? {};
   for (const extensionNamespace of Object.keys(contractExtensionPacks)) {
-    const hasComponent = options.frameworkComponents.some(
+    const hasComponent = frameworkComponents.some(
       (component) =>
         component.id === extensionNamespace &&
         (component.kind === 'extension' ||
@@ -476,113 +929,206 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
       );
     }
   }
+}
 
-  // Compare component-owned database dependencies (pure, deterministic)
-  // Per ADR 154: We do NOT infer dependencies from contract extension packs.
-  // Dependencies are only collected from frameworkComponents provided by the CLI.
-  const databaseDependencies = collectDependenciesFromFrameworkComponents(
-    options.frameworkComponents,
+/**
+ * Renders the expected native type for a contract column, expanding parameterized types
+ * using codec control hooks when available.
+ *
+ * This function delegates to the `expandNativeType` hook if the codec provides one,
+ * ensuring that the SQL family layer remains dialect-agnostic while allowing
+ * target-specific adapters (like Postgres) to provide their own expansion logic.
+ */
+function renderExpectedNativeType(
+  contractColumn: Contract<SqlStorage>['storage']['tables'][string]['columns'][string],
+  storageTypes: Record<string, StorageTypeInstance>,
+  codecHooks: Map<string, CodecControlHooks>,
+  context?: {
+    readonly tableName: string;
+    readonly columnName: string;
+  },
+): string {
+  const { codecId, nativeType, typeParams } = resolveContractColumnTypeMetadata(
+    contractColumn,
+    storageTypes,
+    context,
   );
-  const dependencyStatuses = verifyDatabaseDependencies(databaseDependencies, schema, issues);
-  rootChildren.push(...dependencyStatuses);
-
-  // Build root node
-  const rootStatus = rootChildren.some((c) => c.status === 'fail')
-    ? 'fail'
-    : rootChildren.some((c) => c.status === 'warn')
-      ? 'warn'
-      : 'pass';
-  const root: SchemaVerificationNode = {
-    status: rootStatus,
-    kind: 'contract',
-    name: 'contract',
-    contractPath: '',
-    code: '',
-    message: '',
-    expected: undefined,
-    actual: undefined,
-    children: rootChildren,
-  };
 
-  // Compute counts
-  const counts = computeCounts(root);
+  // If no typeParams or codecId, return the base native type
+  if (!typeParams || !codecId) {
+    return nativeType;
+  }
 
-  // Set ok flag
-  const ok = counts.fail === 0;
+  // Try to use the codec's expandNativeType hook if available
+  const hooks = codecHooks.get(codecId);
+  if (hooks?.expandNativeType) {
+    return hooks.expandNativeType({ nativeType, codecId, typeParams });
+  }
 
-  // Set code
-  const code = ok ? undefined : 'PN-SCHEMA-0001';
+  // Fallback: return base native type if no hook is available
+  return nativeType;
+}
 
-  // Set summary
-  const summary = ok
-    ? 'Database schema satisfies contract'
-    : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? '' : 's'})`;
+function resolveContractColumnTypeMetadata(
+  contractColumn: StorageColumn,
+  storageTypes: Record<string, StorageTypeInstance>,
+  context?: {
+    readonly tableName: string;
+    readonly columnName: string;
+  },
+): Pick<StorageColumn, 'codecId' | 'nativeType' | 'typeParams'> {
+  if (!contractColumn.typeRef) {
+    return contractColumn;
+  }
 
-  const totalTime = Date.now() - startTime;
+  const referencedType = storageTypes[contractColumn.typeRef];
+  if (!referencedType) {
+    const columnLabel = context
+      ? `Column "${context.tableName}"."${context.columnName}"`
+      : 'Column';
+    throw new Error(
+      `${columnLabel} references storage type "${contractColumn.typeRef}" but it is not defined in storage.types.`,
+    );
+  }
 
   return {
-    ok,
-    ...ifDefined('code', code),
-    summary,
-    contract: {
-      coreHash: contractCoreHash,
-      ...ifDefined('profileHash', contractProfileHash),
-    },
-    target: {
-      expected: contractTarget,
-      actual: contractTarget,
-    },
-    schema: {
-      issues,
-      root,
-      counts,
-    },
-    meta: {
-      strict,
-      ...ifDefined('contractPath', context?.contractPath),
-      ...ifDefined('configPath', context?.configPath),
-    },
-    timings: {
-      total: totalTime,
-    },
+    codecId: referencedType.codecId,
+    nativeType: referencedType.nativeType,
+    typeParams: referencedType.typeParams,
   };
 }
 
 /**
- * Type predicate to check if a component has database dependencies with an init array.
- * The familyId check is redundant since TargetBoundComponentDescriptor<'sql', T> already
- * guarantees familyId is 'sql' at the type level, so we don't need runtime checks for it.
+ * Describes a column default for display purposes.
  */
-function hasDatabaseDependenciesInit<T extends string>(
-  component: TargetBoundComponentDescriptor<'sql', T>,
-): component is TargetBoundComponentDescriptor<'sql', T> & {
-  readonly databaseDependencies: {
-    readonly init: readonly ComponentDatabaseDependency<T>[];
-  };
-} {
-  if (!('databaseDependencies' in component)) {
-    return false;
+function describeColumnDefault(columnDefault: ColumnDefault): string {
+  switch (columnDefault.kind) {
+    case 'literal':
+      return `literal(${formatLiteralValue(columnDefault.value)})`;
+    case 'function':
+      return columnDefault.expression;
   }
-  const dbDeps = (component as Record<string, unknown>)['databaseDependencies'];
-  if (dbDeps === undefined || dbDeps === null || typeof dbDeps !== 'object') {
+}
+
+/**
+ * Compares a contract ColumnDefault against a schema raw default string for semantic equality.
+ *
+ * When a normalizer is provided, the raw schema default is first normalized to a ColumnDefault
+ * before comparison. Without a normalizer, falls back to direct string comparison against
+ * the contract expression.
+ *
+ * @param contractDefault - The expected default from the contract (normalized ColumnDefault)
+ * @param schemaDefault - The raw default expression from the database (string)
+ * @param normalizer - Optional target-specific normalizer to convert raw defaults
+ * @param nativeType - The column's native type, passed to normalizer for context
+ */
+function columnDefaultsEqual(
+  contractDefault: ColumnDefault,
+  schemaDefault: string,
+  normalizer?: DefaultNormalizer,
+  nativeType?: string,
+): boolean {
+  // If no normalizer provided, fall back to direct string comparison
+  if (!normalizer) {
+    if (contractDefault.kind === 'function') {
+      return contractDefault.expression === schemaDefault;
+    }
+    const normalizedValue = normalizeLiteralValue(contractDefault.value, nativeType);
+    if (typeof normalizedValue === 'string') {
+      return normalizedValue === schemaDefault || `'${normalizedValue}'` === schemaDefault;
+    }
+    return String(normalizedValue) === schemaDefault;
+  }
+
+  // Normalize the raw schema default using target-specific logic
+  const normalizedSchema = normalizer(schemaDefault, nativeType ?? '');
+  if (!normalizedSchema) {
+    // Normalizer couldn't parse the expression - treat as mismatch
     return false;
   }
-  const depsRecord = dbDeps as Record<string, unknown>;
-  const init = depsRecord['init'];
-  if (init === undefined || !Array.isArray(init)) {
+
+  // Compare normalized defaults
+  if (contractDefault.kind !== normalizedSchema.kind) {
     return false;
   }
-  return true;
+  if (contractDefault.kind === 'literal' && normalizedSchema.kind === 'literal') {
+    const contractValue = normalizeLiteralValue(contractDefault.value, nativeType);
+    const schemaValue = normalizeLiteralValue(normalizedSchema.value, nativeType);
+    return literalValuesEqual(contractValue, schemaValue);
+  }
+  if (contractDefault.kind === 'function' && normalizedSchema.kind === 'function') {
+    // Normalize function expressions for comparison (case-insensitive, whitespace-tolerant)
+    const normalizeExpr = (expr: string) => expr.toLowerCase().replace(/\s+/g, '');
+    return normalizeExpr(contractDefault.expression) === normalizeExpr(normalizedSchema.expression);
+  }
+  return false;
+}
+
+function isTemporalNativeType(nativeType?: string): boolean {
+  if (!nativeType) return false;
+  const normalized = nativeType.toLowerCase();
+  return normalized.includes('timestamp') || normalized === 'date';
 }
 
-function collectDependenciesFromFrameworkComponents<T extends string>(
-  components: ReadonlyArray<TargetBoundComponentDescriptor<'sql', T>>,
-): ReadonlyArray<ComponentDatabaseDependency<T>> {
-  const dependencies: ComponentDatabaseDependency<T>[] = [];
-  for (const component of components) {
-    if (hasDatabaseDependenciesInit(component)) {
-      dependencies.push(...component.databaseDependencies.init);
+function normalizeLiteralValue(value: unknown, nativeType?: string): unknown {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === 'string' && isTemporalNativeType(nativeType)) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
     }
   }
-  return dependencies;
+  return value;
+}
+
+/**
+ * Recursively sorts object keys for deterministic JSON comparison.
+ * Postgres jsonb may canonicalize key order, so two semantically equal
+ * objects can have different key insertion order.
+ */
+function stableStringify(value: unknown): string {
+  return JSON.stringify(value, (_key, val) => {
+    if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+      const sorted: Record<string, unknown> = {};
+      for (const k of Object.keys(val as Record<string, unknown>).sort()) {
+        sorted[k] = (val as Record<string, unknown>)[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+
+function literalValuesEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+    return stableStringify(a) === stableStringify(b);
+  }
+  if (typeof a === 'object' && a !== null && typeof b === 'string') {
+    try {
+      return stableStringify(a) === stableStringify(JSON.parse(b));
+    } catch {
+      return false;
+    }
+  }
+  if (typeof a === 'string' && typeof b === 'object' && b !== null) {
+    try {
+      return stableStringify(JSON.parse(a)) === stableStringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function formatLiteralValue(value: unknown): string {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  return JSON.stringify(value);
 }