@prisma-next/family-sql 0.14.0-dev.5 → 0.14.0-dev.50

package/src/core/diff/diff-tree-normalization.ts

@@ -0,0 +1,211 @@
+/**
+ * ⚠️ ACCEPTED-UNDER-PROTEST DEBT — DELETE IN SLICE 2.6 (`unify-unique-and-index-nodes`).
+ *
+ * A unique constraint IS a unique index. This slice modeled uniques and indexes
+ * as two separate node kinds (`SqlUniqueIR` vs `SqlIndexIR` — even though
+ * `SqlIndexIR` already carries `unique: boolean`), so the strict-by-kind differ
+ * cannot pair a contract unique with a live unique index. This whole file
+ * exists only to reconcile those two representations after the fact — it
+ * should not exist.
+ *
+ * The fix — delete `SqlUniqueIR`, model unique enforcement as
+ * `SqlIndexIR { unique: true }` on both derivation and introspection, and
+ * delete `diff-tree-normalization.ts` — is specified in
+ * `projects/postgres-rls/slices/unify-unique-and-index-nodes/spec.md` and
+ * scheduled as the very next slice. Do NOT extend this.
+ */
+
+/**
+ * Pre-diff tree normalization: adjustments to the actual/expected trees the
+ * generic differ (`diffSchemas`) runs over, so legacy semantic-equivalence
+ * rules (a unique constraint satisfied by a unique index, an FK schema
+ * segment that differs only in spelling) surface as same-kind node pairs
+ * instead of spurious drift.
+ */
+
+import {
+  SqlForeignKeyIR,
+  SqlIndexIR,
+  SqlSchemaIR,
+  SqlTableIR,
+  SqlUniqueIR,
+} from '@prisma-next/sql-schema-ir/types';
+
+// ============================================================================
+// Semantic satisfaction — derivation-side normalization of the actual tree
+// ============================================================================
+
+export interface SemanticSatisfactionInput {
+  readonly expectedUniques: readonly SqlUniqueIR[];
+  readonly expectedIndexes: readonly SqlIndexIR[];
+  readonly actualUniques: readonly SqlUniqueIR[];
+  readonly actualIndexes: readonly SqlIndexIR[];
+}
+
+export interface SemanticSatisfactionResult {
+  readonly actualUniques: readonly SqlUniqueIR[];
+  readonly actualIndexes: readonly SqlIndexIR[];
+}
+
+function sameColumns(a: readonly string[], b: readonly string[]): boolean {
+  return a.length === b.length && a.every((c, i) => c === b[i]);
+}
+
+/**
+ * Adjusts a table pair's ACTUAL unique/index child lists so the legacy
+ * walk's cross-kind semantic satisfaction materializes as same-kind node
+ * pairs for the differ (the differ pairs strictly by id, so a `unique:`
+ * node can never pair with an `index:` node). Three legacy rules, ported
+ * from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the
+ * strict-extras loops of the retired relational walk:
+ *
+ * 1. A contract unique satisfied by a live unique INDEX: the actual index
+ *    node is reclassified as a unique node (it pairs with the expected
+ *    unique and stops being a candidate extra).
+ * 2. A contract index (with no type/options demands) satisfied by a live
+ *    unique CONSTRAINT: a same-kind actual index node is synthesized so
+ *    the expected index pairs — the unique constraint itself stays (the
+ *    legacy strict-extras loop still reports it as an undeclared unique).
+ * 3. Live unique indexes are never extras in the legacy walk (its
+ *    strict-extras loop skips `unique: true` rows), so any remaining
+ *    actual unique-index node with no expected index counterpart is
+ *    dropped rather than surfacing as `not-expected`.
+ */
+export function resolveSemanticSatisfaction(
+  input: SemanticSatisfactionInput,
+): SemanticSatisfactionResult {
+  let actualIndexes = [...input.actualIndexes];
+  const actualUniques = [...input.actualUniques];
+
+  // Rule 1: reclassify a satisfying unique index as the unique constraint
+  // the contract declared.
+  for (const expectedUnique of input.expectedUniques) {
+    const alreadyPaired = actualUniques.some((u) => sameColumns(u.columns, expectedUnique.columns));
+    if (alreadyPaired) continue;
+    const satisfyingIndex = actualIndexes.find(
+      (idx) => idx.unique && sameColumns(idx.columns, expectedUnique.columns),
+    );
+    if (satisfyingIndex) {
+      actualIndexes = actualIndexes.filter((idx) => idx !== satisfyingIndex);
+      actualUniques.push(
+        new SqlUniqueIR({
+          columns: satisfyingIndex.columns,
+          ...(satisfyingIndex.name !== undefined ? { name: satisfyingIndex.name } : {}),
+        }),
+      );
+    }
+  }
+
+  // Rule 2: synthesize an index node from a satisfying unique constraint.
+  for (const expectedIndex of input.expectedIndexes) {
+    if (expectedIndex.type !== undefined || expectedIndex.options !== undefined) continue;
+    const alreadyPaired = actualIndexes.some((idx) =>
+      sameColumns(idx.columns, expectedIndex.columns),
+    );
+    if (alreadyPaired) continue;
+    const satisfyingUnique = actualUniques.find((u) =>
+      sameColumns(u.columns, expectedIndex.columns),
+    );
+    if (satisfyingUnique) {
+      actualIndexes.push(new SqlIndexIR({ columns: satisfyingUnique.columns, unique: false }));
+    }
+  }
+
+  // Rule 3: remaining unique indexes with no expected counterpart are
+  // invisible to the legacy extras loop — drop them.
+  actualIndexes = actualIndexes.filter(
+    (idx) =>
+      !idx.unique || input.expectedIndexes.some((exp) => sameColumns(exp.columns, idx.columns)),
+  );
+
+  return { actualUniques, actualIndexes };
+}
+
+// ============================================================================
+// Flat-tree helpers (single-schema targets)
+// ============================================================================
+
+/**
+ * Applies {@link resolveSemanticSatisfaction} across a flat table pair set:
+ * every actual table with an expected counterpart gets its unique/index
+ * child lists adjusted; unpaired tables pass through untouched.
+ */
+export function normalizeFlatActualForDiff(
+  expected: SqlSchemaIR,
+  actual: SqlSchemaIR,
+): SqlSchemaIR {
+  const tables: Record<string, SqlTableIR> = {};
+  for (const [name, actualTable] of Object.entries(actual.tables)) {
+    const expectedTable = expected.tables[name];
+    if (expectedTable === undefined) {
+      tables[name] = actualTable;
+      continue;
+    }
+    const adjusted = resolveSemanticSatisfaction({
+      expectedUniques: expectedTable.uniques,
+      expectedIndexes: expectedTable.indexes,
+      actualUniques: actualTable.uniques,
+      actualIndexes: actualTable.indexes,
+    });
+    tables[name] = new SqlTableIR({
+      name: actualTable.name,
+      columns: actualTable.columns,
+      foreignKeys: actualTable.foreignKeys,
+      uniques: adjusted.actualUniques,
+      indexes: adjusted.actualIndexes,
+      ...(actualTable.primaryKey !== undefined ? { primaryKey: actualTable.primaryKey } : {}),
+      ...(actualTable.annotations !== undefined ? { annotations: actualTable.annotations } : {}),
+      ...(actualTable.checks !== undefined ? { checks: actualTable.checks } : {}),
+    });
+  }
+  return new SqlSchemaIR({
+    tables,
+    ...(actual.annotations !== undefined ? { annotations: actual.annotations } : {}),
+  });
+}
+
+/**
+ * Neutralizes the FK schema segment on a flat expected tree so its FK diff
+ * nodes pair with introspected FKs on single-schema targets: the family
+ * converter stamps `referencedSchema` with the contract namespace id
+ * verbatim (the unbound sentinel on non-namespaced targets), while a
+ * single-schema introspection stamps none — resolving both sides to the
+ * empty segment makes the ids meet.
+ */
+export function neutralizeFlatExpectedFkSchemas(expected: SqlSchemaIR): SqlSchemaIR {
+  const tables: Record<string, SqlTableIR> = {};
+  for (const [name, table] of Object.entries(expected.tables)) {
+    if (table.foreignKeys.length === 0) {
+      tables[name] = table;
+      continue;
+    }
+    const foreignKeys = table.foreignKeys.map(
+      (fk) =>
+        new SqlForeignKeyIR({
+          columns: fk.columns,
+          referencedTable: fk.referencedTable,
+          referencedColumns: fk.referencedColumns,
+          ...(fk.referencedSchema !== undefined ? { referencedSchema: fk.referencedSchema } : {}),
+          ...(fk.name !== undefined ? { name: fk.name } : {}),
+          ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),
+          ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),
+          ...(fk.annotations !== undefined ? { annotations: fk.annotations } : {}),
+          resolvedReferencedNamespace: '',
+        }),
+    );
+    tables[name] = new SqlTableIR({
+      name: table.name,
+      columns: table.columns,
+      foreignKeys,
+      uniques: table.uniques,
+      indexes: table.indexes,
+      ...(table.primaryKey !== undefined ? { primaryKey: table.primaryKey } : {}),
+      ...(table.annotations !== undefined ? { annotations: table.annotations } : {}),
+      ...(table.checks !== undefined ? { checks: table.checks } : {}),
+    });
+  }
+  return new SqlSchemaIR({
+    tables,
+    ...(expected.annotations !== undefined ? { annotations: expected.annotations } : {}),
+  });
+}

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

@@ -0,0 +1,324 @@
+/**
+ * The differ-based SQL schema verify: post-diff filters and verdict.
+ *
+ * The generic node differ (`diffSchemas`) reports every node-level
+ * difference between the derived expected tree and the introspected actual
+ * tree. This module is the consumer side the spec assigns to the SQL
+ * family: strict-mode extras gating and control-policy disposition are
+ * reason/kind-keyed filters applied AFTER the diff — never inside it — and
+ * the verify verdict derives from the filtered issue list.
+ *
+ * `verifySqlSchemaByDiff` wraps the verdict in the issue-based result
+ * envelope — this is THE SQL schema verify (the legacy relational walk and
+ * its verification tree are retired).
+ */
+
+import type { Contract, ControlPolicy } from '@prisma-next/contract/types';
+import { effectiveControlPolicy } from '@prisma-next/contract/types';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  DiffSubjectGranularity,
+  SchemaDiffIssue,
+  VerifierIssueCategory,
+  VerifierOutcome,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/framework-components/control';
+import { dispositionForCategory } from '@prisma-next/framework-components/control';
+import { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';
+import { RelationalSchemaNodeKind, type SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { extractCodecControlHooks } from '../assembly';
+import type { SqlSchemaDiffFn } from '../migrations/schema-differ';
+import type { CodecControlHooks } from '../migrations/types';
+import { verifierDisposition } from './verifier-disposition';
+
+// ============================================================================
+// Subject-granularity classification — nodeKind → framework-neutral granularity
+// ============================================================================
+
+function issueNode(issue: SchemaDiffIssue): SqlSchemaIRNode | undefined {
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return undefined;
+  return blindCast<
+    SqlSchemaIRNode,
+    'every node in a SQL schema diff tree is a SqlSchemaIRNode; nodeKind is its identity'
+  >(node);
+}
+
+/**
+ * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on
+ * demand, from the issue's node's `nodeKind` via the target-provided
+ * `granularityOf` map. The node carries only its `nodeKind` identity, never a
+ * classification, and nothing is stamped onto the issue — every consumer
+ * (the family verdict below, the framework aggregate's unclaimed-elements
+ * sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})
+ * calls this the same way, resolved by the family/target that owns the node
+ * vocabulary. `undefined` for an issue with no node.
+ */
+export function classifyDiffSubjectGranularity(
+  issue: SchemaDiffIssue,
+  granularityOf: (nodeKind: string) => DiffSubjectGranularity,
+): DiffSubjectGranularity | undefined {
+  const node = issueNode(issue);
+  return node === undefined ? undefined : granularityOf(node.nodeKind);
+}
+
+/**
+ * Resolves an issue's storage `entityKind` on demand, from the issue's
+ * node's `nodeKind` via the target-provided `entityKindOf` map — the sibling
+ * of {@link classifyDiffSubjectGranularity}, called the same way by the same
+ * consumers (via
+ * {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}).
+ * `undefined` for an issue with no node, or for a node kind with no storage
+ * entity of its own.
+ */
+export function classifyDiffEntityKind(
+  issue: SchemaDiffIssue,
+  entityKindOf: (nodeKind: string) => string | undefined,
+): string | undefined {
+  const node = issueNode(issue);
+  return node === undefined ? undefined : entityKindOf(node.nodeKind);
+}
+
+// ============================================================================
+// Issue classification — subject granularity + reason → target-neutral category
+// ============================================================================
+
+/**
+ * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the
+ * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the
+ * issue reason. The vocabulary maps one-to-one: an undeclared live entity or
+ * namespace is `extraTopLevelObject`, an undeclared live field
+ * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
+ * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
+ * drift on a check node is `valueDrift`; every other paired divergence is
+ * `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+ * `granularityOf` is the target's classifier, so target and extension node
+ * kinds classify without the family importing them.
+ */
+export function classifySqlDiffIssue(
+  issue: SchemaDiffIssue,
+  granularityOf: (nodeKind: string) => DiffSubjectGranularity,
+): VerifierIssueCategory {
+  if (issue.reason === 'not-found') {
+    return 'declaredMissing';
+  }
+  if (issue.reason === 'not-expected') {
+    const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
+    if (granularity === 'entity' || granularity === 'namespace') {
+      return 'extraTopLevelObject';
+    }
+    if (granularity === 'field') {
+      return 'extraNestedElement';
+    }
+    return 'extraAuxiliary';
+  }
+  if (issueNode(issue)?.nodeKind === RelationalSchemaNodeKind.check) {
+    return 'valueDrift';
+  }
+  return 'declaredIncompatible';
+}
+
+/**
+ * Whether a `not-expected` issue is a strict-mode-only finding. The legacy
+ * walk detected every relational extra (namespaces, entities, fields, and
+ * their auxiliaries) only under `--strict`; the structural diff (roots, RLS
+ * policies, roles) was never strict-gated — its extras fail in both modes.
+ * Keyed on the issue's granularity, resolved via `granularityOf`.
+ */
+function isStrictOnlyExtra(
+  issue: SchemaDiffIssue,
+  granularityOf: (nodeKind: string) => DiffSubjectGranularity,
+): boolean {
+  const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
+  return (
+    granularity === 'namespace' ||
+    granularity === 'entity' ||
+    granularity === 'field' ||
+    granularity === 'auxiliary'
+  );
+}
+
+// ============================================================================
+// The post-diff filter + verdict
+// ============================================================================
+
+export interface SqlDiffVerdictInput {
+  /** The full, ownership-scoped diff issue list from the target's differ. */
+  readonly issues: readonly SchemaDiffIssue[];
+  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */
+  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;
+  readonly strict: boolean;
+  readonly defaultControlPolicy: ControlPolicy | undefined;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+
+export interface SqlDiffVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+
+/**
+ * Applies the two consumer filters to a diff issue list: strict gating
+ * (relational `not-expected` findings drop in lenient mode) and
+ * control-policy disposition (each surviving issue grades against its
+ * subject table's effective policy; suppressed issues drop, `observed`
+ * subjects warn). The verify verdict is `failures.length === 0`.
+ */
+export function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict {
+  const failures: SchemaDiffIssue[] = [];
+  const warnings: SchemaDiffIssue[] = [];
+  for (const issue of input.issues) {
+    if (
+      !input.strict &&
+      issue.reason === 'not-expected' &&
+      isStrictOnlyExtra(issue, input.granularityOf)
+    ) {
+      continue;
+    }
+    const tablePolicy = input.resolveControlPolicy(issue);
+    const policy = effectiveControlPolicy(tablePolicy, input.defaultControlPolicy);
+    const disposition: VerifierOutcome = dispositionForCategory(
+      policy,
+      classifySqlDiffIssue(issue, input.granularityOf),
+    );
+    if (disposition === 'suppress') continue;
+    if (disposition === 'warn') {
+      warnings.push(issue);
+      continue;
+    }
+    failures.push(issue);
+  }
+  return { failures, warnings };
+}
+
+// ============================================================================
+// Storage-types check — the codec verifyType hook path
+// ============================================================================
+
+export interface StorageTypeVerdictInput {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Expected/actual namespace-node pairs the target's differ input produced:
+   * for a namespaced tree, one entry per expected namespace with a
+   * non-empty table set, paired by DDL schema name (absent actual side for
+   * a schema the database lacks); a flat tree is the sole pair.
+   */
+  readonly namespacePairs: ReadonlyArray<{
+    readonly actual: SqlSchemaIRNode | undefined;
+  }>;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+
+/**
+ * Runs the codec `verifyType` hooks the way the legacy walk did: once per
+ * contract namespace with tables, against that namespace's paired actual
+ * node (the hook reads namespace-scoped state such as
+ * `nativeEnumTypeNames` off it). Issue dispositions grade against the
+ * contract default policy, matching the legacy `pushTypeNode` semantics.
+ */
+export interface StorageTypeVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+
+export function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict {
+  const failures: SchemaDiffIssue[] = [];
+  const warnings: SchemaDiffIssue[] = [];
+  const policy = effectiveControlPolicy(undefined, input.contract.defaultControlPolicy);
+  for (const pair of input.namespacePairs) {
+    if (pair.actual === undefined) continue;
+    for (const [typeName, typeInstance] of Object.entries(input.contract.storage.types ?? {})) {
+      if (!isStorageTypeInstance(typeInstance)) continue;
+      const hook = input.codecHooks.get(typeInstance.codecId);
+      if (!hook?.verifyType) continue;
+      const typeIssues = hook.verifyType({ typeName, typeInstance, schema: pair.actual });
+      for (const issue of typeIssues) {
+        const disposition = verifierDisposition(policy, issue);
+        if (disposition === 'suppress') continue;
+        if (disposition === 'warn') {
+          warnings.push(issue);
+          continue;
+        }
+        failures.push(issue);
+      }
+    }
+  }
+  return { failures, warnings };
+}
+
+// ============================================================================
+// The issue-based verify envelope
+// ============================================================================
+
+export interface VerifySqlSchemaByDiffInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /** The target's full-tree node diff (`diffSchema` descriptor hook). */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+
+/**
+ * THE SQL schema verify: runs the target's full-tree node diff, grades it
+ * through the family's post-diff filters (strict gating + control-policy
+ * disposition) plus the codec `verifyType` hook findings, and wraps the
+ * verdict in the issue-based result envelope. `ok` holds exactly when both
+ * issue lists are empty — the lists carry the verdict's failures.
+ */
+export function verifySqlSchemaByDiff(
+  input: VerifySqlSchemaByDiffInput,
+): VerifyDatabaseSchemaResult {
+  const startTime = Date.now();
+  const verdictDiff = input.diffSchema({
+    contract: input.contract,
+    schema: input.schema,
+    frameworkComponents: input.frameworkComponents,
+  });
+  const diffVerdict = computeSqlDiffVerdict({
+    issues: verdictDiff.issues,
+    resolveControlPolicy: verdictDiff.resolveControlPolicy,
+    strict: input.strict,
+    defaultControlPolicy: input.contract.defaultControlPolicy,
+    granularityOf: input.granularityOf,
+  });
+  const storageTypeVerdict = computeStorageTypeVerdict({
+    contract: input.contract,
+    namespacePairs: verdictDiff.namespacePairs,
+    codecHooks: extractCodecControlHooks(input.frameworkComponents),
+  });
+  const failCount = diffVerdict.failures.length + storageTypeVerdict.failures.length;
+  const ok = failCount === 0;
+  const profileHash =
+    'profileHash' in input.contract && typeof input.contract.profileHash === 'string'
+      ? input.contract.profileHash
+      : undefined;
+  return {
+    ok,
+    ...(ok ? {} : { code: 'PN-SCHEMA-0001' }),
+    summary: ok
+      ? 'Database schema satisfies contract'
+      : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? '' : 's'})`,
+    contract: {
+      storageHash: input.contract.storage.storageHash,
+      ...ifDefined('profileHash', profileHash),
+    },
+    target: {
+      expected: input.contract.target,
+      actual: input.contract.target,
+    },
+    schema: {
+      issues: [...diffVerdict.failures, ...storageTypeVerdict.failures],
+      warnings: {
+        issues: [...diffVerdict.warnings, ...storageTypeVerdict.warnings],
+      },
+    },
+    meta: { strict: input.strict },
+    timings: { total: Date.now() - startTime },
+  };
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Shared relational-diff types and semantic-satisfaction predicates. The
+ * coordinate-based issue diff this module used to house (`collectSqlSchemaIssues`
+ * / `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner
+ * took `plan(start, end)` over the one differ (`buildPostgresPlanDiff` /
+ * `buildSqlitePlanDiff`); what remains here is consumed by the surviving
+ * verify verdict (`schema-verify.ts`) and the control adapters.
+ */
+
+import type { ColumnDefault } from '@prisma-next/contract/types';
+import type { SqlIndexIR, SqlUniqueIR } from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * 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;
+
+/**
+ * Compares two arrays of strings for equality (order-sensitive).
+ */
+export function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Checks if a unique constraint requirement is satisfied by the given columns:
+ * a unique constraint with the same columns, or a unique index with the same
+ * columns (semantic satisfaction). Used by the planners to keep the
+ * "stronger satisfies weaker" behavior consistent across the control plane.
+ */
+export function isUniqueConstraintSatisfied(
+  uniques: readonly SqlUniqueIR[],
+  indexes: readonly SqlIndexIR[],
+  columns: readonly string[],
+): boolean {
+  const hasConstraint = uniques.some((unique) => arraysEqual(unique.columns, columns));
+  if (hasConstraint) {
+    return true;
+  }
+  return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
+}
+
+/**
+ * Checks if an index requirement is satisfied by the given columns: any index
+ * (unique or non-unique) with the same columns, or a unique constraint with
+ * the same columns (stronger satisfies weaker).
+ */
+export function isIndexSatisfied(
+  indexes: readonly SqlIndexIR[],
+  uniques: readonly SqlUniqueIR[],
+  columns: readonly string[],
+): boolean {
+  const hasMatchingIndex = indexes.some((index) => arraysEqual(index.columns, columns));
+  if (hasMatchingIndex) {
+    return true;
+  }
+  return uniques.some((unique) => arraysEqual(unique.columns, columns));
+}

package/src/core/diff/verifier-disposition.ts

@@ -0,0 +1,30 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import type {
+  SchemaDiffIssue,
+  VerifierIssueCategory,
+  VerifierOutcome,
+} from '@prisma-next/framework-components/control';
+import { dispositionForCategory } from '@prisma-next/framework-components/control';
+
+/**
+ * Classifies a codec `verifyType` hook finding into the target-neutral
+ * categories the framework grades. A storage type is a named type instance
+ * (e.g. a native enum); the only shape divergence it can carry is a change
+ * to its value set, so a paired mismatch always classifies as `valueDrift`.
+ */
+export function classifyStorageTypeDiffIssue(issue: SchemaDiffIssue): VerifierIssueCategory {
+  if (issue.reason === 'not-found') {
+    return 'declaredMissing';
+  }
+  if (issue.reason === 'not-expected') {
+    return 'extraAuxiliary';
+  }
+  return 'valueDrift';
+}
+
+export function verifierDisposition(
+  controlPolicy: ControlPolicy,
+  issue: SchemaDiffIssue,
+): VerifierOutcome {
+  return dispositionForCategory(controlPolicy, classifyStorageTypeDiffIssue(issue));
+}